116 lines
5.1 KiB
Python
116 lines
5.1 KiB
Python
"""Research interface contracts; no CUDA context or physical validation."""
|
|
import importlib.util
|
|
from pathlib import Path
|
|
from types import SimpleNamespace
|
|
from unittest.mock import patch
|
|
|
|
import numpy as np
|
|
import pytest
|
|
|
|
ROOT = Path(__file__).resolve().parents[2]
|
|
spec = importlib.util.spec_from_file_location('karman_viv_research_driver', ROOT/'research/karman_viv/run.py')
|
|
m = importlib.util.module_from_spec(spec)
|
|
spec.loader.exec_module(m)
|
|
|
|
|
|
def test_observation_unit_mapping_and_order():
|
|
norm = dict(force_norm_fact=2.,sens_deviation=np.arange(6)/10.,sens_norm_fact=np.ones(6)*3)
|
|
s=np.arange(6)*.001; f=np.arange(6)*.01
|
|
raw,obs,nclip=m.observation(s,f,2,norm)
|
|
np.testing.assert_array_equal(raw,np.asarray([*(s*156),*(f*2)],np.float32))
|
|
expected=np.hstack((raw[6:]/2,(raw[:6]-np.asarray(norm['sens_deviation'],np.float32))/3))
|
|
np.testing.assert_array_equal(obs,expected.astype(np.float32))
|
|
assert nclip==0
|
|
|
|
|
|
def test_same_physical_signal_d20_d40():
|
|
norm=dict(force_norm_fact=1.,sens_deviation=np.zeros(6),sens_norm_fact=np.ones(6))
|
|
a=m.observation(np.ones(6)*.001,np.arange(6)*.01,1,norm)
|
|
b=m.observation(np.ones(6)*.0005,np.arange(6)*.005,2,norm)
|
|
np.testing.assert_array_equal(a[0],b[0]); np.testing.assert_array_equal(a[1],b[1])
|
|
|
|
|
|
def test_zero_action_and_ccw_scale():
|
|
np.testing.assert_array_equal(m.wall_target(-m.BIAS/8,2),np.zeros(3))
|
|
np.testing.assert_allclose(m.wall_target(np.ones(3),2),[.04,.02,.06])
|
|
assert m.wall_target(np.ones(3),2)[0]/20 == .002
|
|
|
|
|
|
def test_ema_equal_physical_time_and_interval_reset():
|
|
target=np.array([.01,-.02,.03]); coarse=np.zeros(3); fine=np.zeros(3)
|
|
for _ in range(13): coarse=m.ema(coarse,target,1)
|
|
for _ in range(52): fine=m.ema(fine,target,2)
|
|
np.testing.assert_allclose(fine,coarse,rtol=2e-15,atol=1e-17)
|
|
np.testing.assert_allclose(m.ema(np.zeros(3),target,2),(1-.9**.25)*target)
|
|
|
|
|
|
def test_config_real_parser(tmp_path):
|
|
import json
|
|
from CelerisLab.config import load_lbm_config
|
|
path=tmp_path/'config.json';path.write_text(json.dumps(m.config(40)))
|
|
cfg=load_lbm_config(str(path));cfg.validate()
|
|
assert (cfg.nx,cfg.ny,cfg.velocity,cfg.viscosity)==(2559,1022,.005,.004)
|
|
|
|
|
|
def test_structure_physical_scaling_and_no_damping():
|
|
coarse=m.Structure(2,1e-4,0,20);fine=m.Structure(2,2.5e-5,0,40)
|
|
assert fine.mass==4*coarse.mass
|
|
assert fine.stiffness==coarse.stiffness/4
|
|
assert fine.damping==0
|
|
assert fine.candidate(0)==(0.,0.)
|
|
|
|
|
|
def test_observation_clipping_and_nonfinite():
|
|
norm=dict(force_norm_fact=1.,sens_deviation=np.zeros(6),sens_norm_fact=np.ones(6))
|
|
_,obs,n=m.observation(np.ones(6),np.ones(6),2,norm)
|
|
assert n==12 and np.array_equal(obs,np.ones(12,np.float32))
|
|
with pytest.raises(RuntimeError,match='nonfinite'):
|
|
m.observation(np.full(6,np.nan),np.zeros(6),2,norm)
|
|
|
|
|
|
def test_arm_step_order_and_native_rhs(tmp_path):
|
|
import CelerisLab
|
|
from CelerisLab.body.motion import MovingTables
|
|
from contextlib import nullcontext
|
|
log=[];candidates=[]
|
|
class Structure:
|
|
y=v=0.;mass=2.;stiffness=3.;frequency=.1
|
|
def __init__(self,*args): pass
|
|
def candidate(self,f):
|
|
candidates.append(f)
|
|
return self.y+.001,self.v+.002
|
|
class Sim:
|
|
def __init__(self,*args): self.n=0
|
|
def __enter__(self): return self
|
|
def __exit__(self,*args): pass
|
|
def initialize(self): pass
|
|
def set_body(self,p,**kw): log.append(('set',p,kw))
|
|
def run(self,n,**kw): self.n+=1;log.append(('run',n,kw))
|
|
def moving_diagnostics(self):
|
|
a=np.zeros((3,len(MovingTables.DIAG)),np.float32)
|
|
a[:,MovingTables.DIAG.index('cme_y')]=self.n
|
|
a[:,MovingTables.DIAG.index('wen_y')]=10*self.n
|
|
a[:,MovingTables.DIAG.index('cover_jy')]=1000
|
|
return a
|
|
def read_force(self,p): return [0.,float(self.n),0.]
|
|
def read_sensor(self,p): return [.001,0.,0.]
|
|
seen=[]
|
|
model=SimpleNamespace(predict=lambda obs,**kw:(seen.append(obs.copy()) or np.ones(3)*.1,None))
|
|
norm=dict(force_norm_fact=1.,sens_deviation=np.zeros(6),sens_norm_fact=np.ones(6))
|
|
with patch.object(CelerisLab,'Simulation',Sim),patch.object(m,'Structure',Structure), \
|
|
patch.object(m,'add_scene',return_value=([1,2,3],[4,5,6])),patch.object(m,'install_seed',return_value={}), \
|
|
patch.object(m,'check_time'):
|
|
m.run_arm('controlled','cfg',2,2,2,None,7.,model,norm,tmp_path,0,1)
|
|
assert candidates==[7.,33.,66.,99.] # previous native force, NOT SI mean or node impulse
|
|
assert not seen[0].any() and len(seen)==2
|
|
assert [e[0] for e in log]==['set','set','set','run']*4
|
|
for e in log:
|
|
if e[0]=='set': assert e[2]['vy']==pytest.approx(.001) and e[2]['omega']!=0
|
|
else: assert e[2]==dict(zero_obs=True,sync_obs=True)
|
|
rows=np.load(tmp_path/'controlled/steps.npy')
|
|
np.testing.assert_allclose(rows[:,1],[.001,.002,.003,.004])
|
|
assert rows.shape==(4,18)
|
|
np.testing.assert_array_equal(rows[0,15:],rows[2,15:]) # EMA resets at SI boundary
|
|
signals=np.load(tmp_path/'controlled/signals.npz')
|
|
np.testing.assert_array_equal(signals['forces'][:,1],[3.,7.]) # interval CME *2, not CME+Wen
|