source/validate_dynamics.py

"""Independent scipy matrix-exponential checks and reproducible dynamic labels.

Labels are assembled ROM simulations, not new independent full-solid FE solves.
"""
import json,subprocess,os,shutil
from pathlib import Path
import numpy as np
from scipy.linalg import expm
from assembly import solve

ROOT=Path(__file__).resolve().parents[1]
(ROOT/'reports').mkdir(exist_ok=True)
NODE=os.environ.get('PIPE_NODE') or shutil.which('node')
if not NODE:raise RuntimeError('Install Node.js or set PIPE_NODE to the Node executable')
catalog=json.loads((ROOT/'web/data/catalog.json').read_text())['components']
def component(kind,ratio):
    return next(e['id'] for e in catalog if e['kind']==kind and np.isclose(e['diameter'],.2) and np.isclose(e['thickness'],.012) and np.isclose(e['length' if kind=='straight' else 'radius']/.2,ratio))
S,E=component('straight',5),component('elbow',2)
requests=[]
for shape in ['L','U','spatial']:
    ids=[S,E,S] if shape=='L' else [S,E,S,E,S]
    rolls=[0]*len(ids)
    if shape=='spatial':rolls[3]=np.pi/2
    for end_support in ['free','spring']:
        supports=[{'node':0,'fixed':list(range(6))}]
        if end_support=='spring':supports.append({'node':len(ids),'spring':[0,0,100000,0,0,0]})
        for axis in [1,2]:
            for c in [0,1000,10000,100000]:
                requests.append(dict(id=f'{shape}_{end_support}_{axis}_{c}',component_ids=ids,rolls=rolls,supports=supports,deltaT=100,gravity=[0,0,-9.81],dynamic=dict(node=len(ids),axis=axis,c=c)))
# Blocked damper must not create artificial damping.
requests.append(dict(id='blocked',component_ids=[S,E,S],rolls=[0]*3,supports=[{'node':0,'fixed':list(range(6))},{'node':3,'fixed':[2]}],dynamic=dict(node=3,axis=2,c=100000)))
request_path=ROOT/'reports/dynamic_requests.json';output_path=ROOT/'reports/dynamic_browser_raw.json'
request_path.write_text(json.dumps(requests));subprocess.run([NODE,str(ROOT/'src/dynamic_batch.cjs'),str(request_path),str(output_path)],check=True)
data=json.loads(output_path.read_text());checks=[];rows=[]
cache={}
def get(id):
    if id not in cache:
        c=json.loads((ROOT/'web/data'/f'{id}.json').read_text())
        cache[id]={k:np.asarray(v) if isinstance(v,list) else v for k,v in c.items()}
    return cache[id]
for row in data:
    chain=[get(id) for id in row['component_ids']];result=row['result'];d=result['dynamics'];n=d['modeCount']
    py=solve(chain,row['rolls'],supports=row['supports'],nmodes=n)
    w=py['frequency']*2*np.pi;p=d['probe'];probe=py['mode_displacements'][p['component']][p['sample'],p['axis']]
    z0=np.zeros(n);z0[0]=.001/probe[0]
    b=py['modes'][d['node']*6+d['axis']];C=d['c']*np.outer(b,b)
    A=np.block([[np.zeros((n,n)),np.eye(n)],[-np.diag(w*w),-C]])
    propagator=expm(A*(d['time'][1]-d['time'][0]));state=np.r_[z0,np.zeros(n)];signals=[];forces=[]
    for _ in d['time']:
        signals.append(float(probe@state[:n]));forces.append(float(-d['c']*b@state[n:]));state=propagator@state
    error=float(np.max(np.abs(np.asarray(signals)-d['signal']))/.001)
    force_error=float(np.max(np.abs(np.asarray(forces)-d['force']))/max(1,np.max(np.abs(forces))))
    checks.append(dict(id=row['id'],signal_error_relative_to_initial_peak=error,force_relative_error=force_error,energy_balance_relative=d['energyBalanceRelative'],peak_energy_rise=d['peakEnergyRise']))
    assert error<.005,(row['id'],error)
    assert force_error<.02,(row['id'],force_error)
    assert d['energyBalanceRelative']<1e-7 and d['peakEnergyRise']<1e-9
    if not d['c'] or d['blocked']:assert abs(d['energy'][-1]/d['initialEnergy']-1)<1e-7
    rows.append({k:v for k,v in row.items() if k!='result'}|{'label_source':'assembled_component_ROM_Newmark','initial_condition':'first_undamped_mode_peak_1mm_zero_velocity','modal_basis_count':n,'probe':p,'time_s':d['time'],'displacement_with_damper_m':d['signal'],'displacement_without_damper_m':d['reference'],'damper_force_N':d['force'],'energy_J':d['energy'],'dissipated_energy_J':d['dissipated'],'dt_s':d['dt'],'first_three_frequencies_Hz':result['frequency']})
out=ROOT/'data/dynamics';out.mkdir(exist_ok=True,parents=True)
(out/'release_cases.jsonl').write_text(''.join(json.dumps(r)+'\n' for r in rows))
# Modal retention: identical first-mode initial condition, 12 versus 24 modes.
extra=[]
for r in requests:
    if r['dynamic']['c']==100000 and r['dynamic']['axis']==2 and r['id']!='blocked':
        extra.append({**r,'dynamic':{**r['dynamic'],'modeCount':24}})
request_path.write_text(json.dumps(extra));subprocess.run([NODE,str(ROOT/'src/dynamic_batch.cjs'),str(request_path),str(ROOT/'reports/dynamic_retention_raw.json')],check=True)
retention=[]
for r in json.loads((ROOT/'reports/dynamic_retention_raw.json').read_text()):
    ref=next(x for x in data if x['id']==r['id'])['result']['dynamics'];d=r['result']['dynamics']
    e=float(np.max(np.abs(np.array(ref['signal'])-d['signal']))/.001)
    assert e<.005,(r['id'],'retention',e)
    retention.append({'id':r['id'],'12_vs_24_signal_error_relative_to_initial_peak':e})
report={'passed':True,'cases':len(rows),'method':'Independent scipy matrix exponential on the same reduced equations; not an independent physical validation','max_signal_error_relative_to_initial_peak':max(c['signal_error_relative_to_initial_peak'] for c in checks),'max_force_relative_error':max(c['force_relative_error'] for c in checks),'checks':checks,'retention':retention}
(ROOT/'reports/dynamic_validation.json').write_text(json.dumps(report,indent=2));print(json.dumps({k:v for k,v in report.items() if k not in ['checks']},indent=2))