Files
MeltMind/tools/test_r4a.py
T

128 lines
8.4 KiB
Python

"""Bounded synthetic acceptance only; no real archive or labels."""
import json
import resource
import sys
import tempfile
from pathlib import Path
import unittest
from unittest.mock import patch
import numpy as np
from gre24_features_v2 import mesh, exterior_faces, cell_flow_speed, solve_eikonal, strict_volume_cdf
from gre24_prepare_v2 import sha
from r4a_core import graph_field, paired_summary, may_dispatch, scoring_allowed
import r4a_part as part
import r4a_score as scorer
from run_r4a import fresh
from s2_recovery_supervisor import save, supervise
class Checks(unittest.TestCase):
def test_single_constant_tet(self):
x=np.array([[0.,0,0],[1,0,0],[0,1,0],[0,0,1]])
g=mesh(x,[[0,1,2,3]]);field,_=graph_field(g,[2.],[0])
np.testing.assert_allclose(field,[0,.5,.5,.5],rtol=1e-12,atol=1e-12)
def test_tet_chain_agreement(self):
g=mesh([[0.,0,0],[1,0,0],[2,0,0],[1,1,0],[1,0,1]],[[0,1,3,4],[1,2,3,4]])
eik=solve_eikonal(g,[0],1.);graph,_=graph_field(g,np.ones(2),[0])
np.testing.assert_allclose(eik,graph,rtol=1e-10,atol=1e-10)
np.testing.assert_allclose(eik[:3],[0,1,2],rtol=1e-10,atol=1e-10)
def test_planar_front_known_sqrt_two_factor(self):
# Equilateral source face x=0, circumradius1; apex normal distance1.
x=np.array([[0.,1,0],[0,-.5,np.sqrt(3)/2],[0,-.5,-np.sqrt(3)/2],[1,0,0]])
g=mesh(x,[[0,1,2,3]])
eik=solve_eikonal(g,[0,1,2],1.);graph,_=graph_field(g,[1.],[0,1,2])
self.assertAlmostEqual(eik[3],1.,places=10)
self.assertAlmostEqual(graph[3],np.sqrt(2),places=10)
self.assertAlmostEqual(graph[3]/eik[3],np.sqrt(2),places=10)
def test_parallel_incident_minimum_not_sum(self):
g=mesh([[0.,0,0],[1,0,0],[0,1,0],[0,0,1],[0,0,-1]],[[0,1,2,3],[0,1,2,4]])
graph,_=graph_field(g,[1.,4.],[0]);self.assertEqual(graph[1],.25)
def test_all_wall_centroid_shared_and_double_wall_edge_retained(self):
g=mesh([[0.,0,0],[1,0,0],[0,1,0],[0,0,1]],[[0,1,2,3]])
a,zero=cell_flow_speed(g,np.zeros(4),exterior_faces(g['t']))
self.assertGreater(a[0],0);np.testing.assert_array_equal(zero,[0])
graph,_=graph_field(g,a,[0]);self.assertAlmostEqual(graph[1],1/a[0])
eik=solve_eikonal(g,[0],a);np.testing.assert_allclose(eik,graph,rtol=1e-10,atol=1e-10)
def test_cdf_shared_strict_ties_full_volume(self):
f=strict_volume_cdf([0,2,2,3],[1,2,3,4]);g=strict_volume_cdf([0,2,2,3],[1,2,3,4])
np.testing.assert_array_equal(f,g);np.testing.assert_allclose(f,[0,.1,.1,.6]);self.assertLess(f.max(),1)
def test_incomplete_component_not_trimmed_and_percentile_printed(self):
roster=[dict(case='a',component_id='A'),dict(case='b',component_id='A'),dict(case='c',component_id='C')]
def row(case,f,g):return dict(case=case,metrics={'F':{'relative_l2':{'value':f}},'G':{'relative_l2':{'value':g}}})
out=paired_summary([row('a',.1,.2),row('c',.2,.4)],roster,'relative_l2')
self.assertEqual(out['paired_components'],1);self.assertIn('A',out['excluded_components'])
self.assertAlmostEqual(out['delta']['low'],.5);self.assertAlmostEqual(out['delta']['high'],.5)
self.assertNotIn('region',out['delta']);self.assertEqual(out['delta']['seed'],2026111408)
def test_undefined_bootstrap_not_replaced(self):
roster=[dict(case='a',component_id='A')]
out=paired_summary([dict(case='a',metrics={'F':{'relative_l2':{'value':0.}},'G':{'relative_l2':{'value':0.}}})],roster,'relative_l2')
self.assertIsNone(out['delta']['value']);self.assertEqual(out['delta']['reason'],'zero reference mean')
def test_budget_reserves_entire_active_jobs(self):
self.assertTrue(may_dispatch(28800-1802,0));self.assertFalse(may_dispatch(28800-1801,0))
self.assertFalse(may_dispatch(28800-4*1802+1,3))
def test_any_failure_or_missing_or_stop_blocks_score(self):
ok={'worker':{'status':'PASS'}};bad={'worker':{'status':'STOPPED_OR_FAILED'}}
self.assertTrue(scoring_allowed([ok],1,None))
for rows,n,reason in [([ok,bad],2,None),([ok],2,None),([ok],1,'CPU')]:
self.assertFalse(scoring_allowed(rows,n,reason))
with tempfile.TemporaryDirectory() as temp:
r=Path(temp);save(r/'preparation-complete.json',dict(records=[bad],stop_reason=None))
with patch.object(scorer,'contract',return_value={'parts':[{}]}):
with self.assertRaisesRegex(ValueError,'forbids'):scorer.score(r)
def test_restart_and_hash_mismatch_rejected(self):
with tempfile.TemporaryDirectory() as temp:
r=Path(temp);fresh(r);(r/'started.json').write_text('{}')
with self.assertRaises(FileExistsError):fresh(r)
p=r/'cached.npy';np.save(p,np.arange(3.))
with self.assertRaisesRegex(ValueError,'SHA mismatch'):part.checked(p,'0'*64)
def test_real_guard_wall_stop_and_failed_cpu_preserved(self):
with tempfile.TemporaryDirectory() as temp:
r=supervise([sys.executable,'-c','import time; time.sleep(5)'],Path(temp),'worker',
dict(total_cpu_seconds=5,job_cpu_seconds=5,job_wall_seconds=.1,tree_rss_bytes=2**28,disk_bytes=2**20,max_processes=1),poll=.01)
self.assertEqual(r['status'],'STOPPED_OR_FAILED');self.assertIn('wall_limit',r['stop_reason'])
self.assertGreater(r['cpu_seconds'],0);self.assertFalse(r['retry'])
def test_cache_worker_no_solver_no_targets_and_full_provenance(self):
with tempfile.TemporaryDirectory() as temp:
root=Path(temp);case='00000001_synthetic';dest=root/'parts'/case;dest.mkdir(parents=True)
source=root/'source';source.mkdir();cache=root/'cache';cache.mkdir()
x=np.array([[0.,0,0],[1,0,0],[0,1,0],[0,0,1]]);t=np.array([[0,1,2,3]]);raw=np.arange(4)
g=mesh(x,t);faces=exterior_faces(t);dw=np.zeros(4);a,zero=cell_flow_speed(g,dw,faces);df,_=graph_field(g,a,[0])
meta={'inlet_config':{'inlet_location':[0.,0.,0.]}}
np.savez(source/'geometry.npz',points_raw=x,tetra=t,raw_node_ids=raw,boundary_triangles=faces,gate_location_raw=x[0])
for n,v in dict(Dw=dw,Df=df,raw_ids=raw,mass=g['mass'],all_wall_tet_ids=zero).items():np.save(cache/(n+'.npy'),v)
old=dict(status='PASS',case=case,geometry=meta,t_scale_seconds=2.,features=dict(gate_raw_ids=[0],wall_mode='tet_exterior_proxy',
precision='float64',max_iterations=100000,speed_min=float(a.min()),speed_max=float(a.max()),Df_coordinate_and_speed_scale=1.))
save(cache/'result.json',old)
row=dict(case=case,component_id='A',preparation={'preparation_root':str(source),'output_sha256':{'geometry.npz':sha(source/'geometry.npz')}},
v5_cache=dict(output=str(cache),result_sha256=sha(cache/'result.json'),output_sha256={p.name:sha(p) for p in cache.glob('*.npy')}))
q=dict(raw_ids=np.array([1,2,3]),counts=np.array([2,1,1]),t_set=2.)
with patch.object(part,'contract',return_value={'parts':[row],'archive':'SYNTHETIC'}),patch.object(part,'read_geometry',return_value=(x,t,raw,meta)),patch.object(part,'prediction_inputs',return_value=q),patch.object(part,'solve_eikonal',side_effect=AssertionError('Cache route must not solve')):
part.worker(root,0)
result=json.loads((dest/'output/result.json').read_text())
self.assertTrue(result['cache_identity_verified']);self.assertEqual(result['decoded_labels'],[])
self.assertFalse(result['spatial_moment_computed'])
with np.load(dest/'output/query-predictions.npz') as z:np.testing.assert_array_equal(z['F'],z['G'])
if __name__=='__main__':
out=Path(sys.argv[1]);out.mkdir(parents=True,exist_ok=False)
with (out/'tests.log').open('x') as log:
result=unittest.TextTestRunner(stream=log,verbosity=2).run(unittest.defaultTestLoader.loadTestsFromTestCase(Checks))
save(out/'receipt.json',dict(status='PASS' if result.wasSuccessful() else 'FAIL',tests=result.testsRun,
failures=len(result.failures),errors=len(result.errors),
cpu_seconds=sum(resource.getrusage(resource.RUSAGE_SELF)[:2])+sum(resource.getrusage(resource.RUSAGE_CHILDREN)[:2]),
scope='Synthetic only; no real archive/labels',source_sha256={str(p):sha(p) for p in [Path(__file__),Path('tools/r4a_core.py'),Path('tools/r4a_part.py'),Path('tools/r4a_score.py'),Path('tools/run_r4a.py')]}))
print((out/'receipt.json').read_text());raise SystemExit(0 if result.wasSuccessful() else 1)