"""Verify constraint screening and silicon-budget optimization independently.""" import json,math,subprocess,unittest from pathlib import Path ROOT=Path(__file__).resolve().parent def run(p): js="const fs=require('fs'),r=require('./static/recommend.js'),e=require('./static/engine.js'),t=require('./static/technology.js'),d=require('./static/models-data.json'),p=JSON.parse(fs.readFileSync(0,'utf8'));try{console.log(JSON.stringify(r.recommend(p,d,e,t)))}catch(e){console.log(JSON.stringify({error:e.message}))}" return json.loads(subprocess.check_output(['node','-e',js],cwd=ROOT,input=json.dumps(p).encode())) class RecommendationTest(unittest.TestCase): def test_area_calibration_and_analytic_buck_width_optimum(self): r=run(dict(ratio=2));self.assertAlmostEqual(r['available_width_mm'],.602*.5/.001) buck=next(x for x in r['eligible'] if x['id']=='buck2') k=2**2*(1/6)*.602*12;g=3.3*1e7*1.51102e-12/.602 optimum=math.sqrt(k/g) self.assertAlmostEqual(buck['width_mm'],optimum,places=4) self.assertAlmostEqual(buck['loss'],k/optimum+g*optimum+4*.038/2) self.assertAlmostEqual(buck['used_die_mm2'],optimum*.001/.602) self.assertLessEqual(buck['used_die_mm2'],.5) def test_width_budget_is_a_maximum(self): a=run(dict(budget_mode='width',width_mm=100,io=.02,ratio=2,lm_uh=100,max_drop_percent=100)) b=run(dict(budget_mode='width',width_mm=1000,io=.02,ratio=2,lm_uh=100,max_drop_percent=100)) ra=next(x for x in a['eligible'] if x['id']=='buck2');rb=next(x for x in b['eligible'] if x['id']=='buck2') self.assertLess(ra['width_mm'],100) self.assertAlmostEqual(ra['width_mm'],rb['width_mm'],places=5) self.assertAlmostEqual(ra['loss'],rb['loss']) def test_component_exclusions(self): r=run(dict(ratio=2,max_windings=0));self.assertIsNone(r['winner']) r=run(dict(ratio=4,max_windings=0));self.assertIsNone(r['winner']) r=run(dict(ratio=2,max_caps=0,cap_uf=0));self.assertTrue(r['eligible']) self.assertTrue(all(x['capacitors']==0 for x in r['eligible'])) def test_ratios_not_invented(self): for ratio in [6,8,16]: r=run(dict(ratio=ratio,max_drop_percent=100)) self.assertEqual(r['native_models'],0);self.assertFalse(r['eligible']);self.assertFalse(r['rows']) self.assertTrue(all(not x['reference_match'] for x in r['eligible'])) self.assertTrue(all(x['id']!='sp2' for x in r['eligible'])) r=run(dict(ratio=2));self.assertEqual(r['native_models'],3) def test_ranking_and_budgets(self): for ratio in [2,4,6,8,16]: r=run(dict(ratio=ratio,max_drop_percent=100)) losses=[x['loss'] for x in r['eligible']];self.assertEqual(losses,sorted(losses)) for row in r['eligible']: self.assertLessEqual(row['width_mm'],r['available_width_mm']*(1+1e-12)) self.assertLessEqual(row['used_die_mm2'],.5*(1+1e-12)) self.assertAlmostEqual(row['loss'],row['conduction_power']+row['gate_power']) if row['capacitors']:self.assertAlmostEqual(row['cf']*row['capacitors'],4e-6) def test_droop_constraint_can_require_larger_width(self): r=run(dict(ratio=2,rl_mohm=0,max_drop_percent=.55)) row=next(x for x in r['eligible'] if x['id']=='buck2') self.assertLessEqual(row['drop_percent'],.55+1e-10) self.assertGreater(row['width_mm'],240) self.assertLessEqual(row['width_mm'],301) def test_objective_priority(self): r=run(dict(ratio=2,objective='capacitors'));self.assertEqual(r['winner']['capacitors'],0) r=run(dict(ratio=2,objective='magnetics'));self.assertEqual(r['winner']['windings'],2) def test_only_cancellation_families_and_phase_ripple(self): two=run(dict(ratio=2));self.assertEqual({r['id'] for r in two['rows']},{'buck2','buck','3lbuck'}) four=run(dict(ratio=4));self.assertEqual({r['id'] for r in four['rows']},{'xfly2p','xfly4p','3lbuck','2sbuck'}) r=next(r for r in two['eligible'] if r['id']=='buck2') lself=50e-9+1e-6;mutual=-1e-6;v1=3.3/2;v2=-v1 slope=(lself*v1-mutual*v2)/(lself*lself-mutual*mutual) self.assertAlmostEqual(r['phase_ripple_pp'],slope/(2*1e7)) self.assertGreater(r['phase_ripple_pp'],0) self.assertAlmostEqual(r['phase_ripple_percent'],100*r['phase_ripple_pp']) weak=run(dict(ratio=2,lm_uh=.001));self.assertEqual({r['id'] for r in weak['eligible']},{'3lbuck'}) self.assertTrue(all(any('phase ripple' in reason for reason in row['reasons']) for row in weak['rows'] if row['id']!='3lbuck')) self.assertTrue(all(r['phase_ripple_percent']<=5 for r in four['eligible'])) def test_output_current_and_power_load_inputs(self): current=run(dict(vin=3.2,vout=.8,io=2)) power=run(dict(vin=3.2,vout=.8,load_mode='power',pout_w=1.6)) self.assertAlmostEqual(current['load_resistance'],.4) self.assertAlmostEqual(current['output_power'],1.6) self.assertAlmostEqual(power['output_current'],2) self.assertAlmostEqual(power['load_resistance'],.8**2/1.6) self.assertTrue(current['voltage_ratio_match']) for a,b in zip(current['eligible'],power['eligible']): self.assertEqual(a['id'],b['id']);self.assertAlmostEqual(a['rout'],b['rout']) self.assertAlmostEqual(a['rout'],a['req']) self.assertAlmostEqual(a['rout_over_rload'],a['rout']/.4) self.assertAlmostEqual(a['drop_percent']/100,a['rout_over_rload']) self.assertAlmostEqual(a['conduction_power'],4*a['rout']) def test_voltage_target_mismatch_and_invalid_load(self): mismatch=run(dict(vin=3.3,vout=.8)) self.assertFalse(mismatch['voltage_ratio_match']);self.assertFalse(mismatch['eligible']) self.assertAlmostEqual(mismatch['load_resistance'],.4) for row in mismatch['rows']:self.assertTrue(any('Requested Vout' in reason for reason in row['reasons'])) for p in [dict(vout=0),dict(vout=-1),dict(load_mode='power',pout_w=0),dict(load_mode='unknown')]:self.assertIn('error',run(p)) def test_output_only_operating_point(self): for ratio in [2,4,6,8,16]: r=run(dict(voltage_mode='output_ratio',load_mode='power',vout=.8,pout_w=1.6,ratio=ratio,vin=999)) self.assertAlmostEqual(r['parameters']['vin'],ratio*.8) self.assertAlmostEqual(r['requested_vout'],.8) self.assertAlmostEqual(r['output_current'],2) self.assertAlmostEqual(r['output_power'],1.6) self.assertAlmostEqual(r['load_resistance'],.4) self.assertTrue(r['voltage_ratio_match']) def test_three_level_buck_in_two_ratio_families(self): two=run(dict(ratio=2));four=run(dict(ratio=4)) a=next(r for r in two['eligible'] if r['id']=='3lbuck');b=next(r for r in four['eligible'] if r['id']=='3lbuck') self.assertEqual(a['native_ratio'],2);self.assertEqual(b['native_ratio'],4) self.assertEqual(a['ripple_model'],'ideal_midpoint_hold');self.assertEqual(a['phase_ripple_pp'],0) self.assertTrue(a['residual_ripple_unmodeled']);self.assertEqual(a['gate_duty'],.5) self.assertEqual(a['effective_duty'],1);self.assertGreater(b['phase_ripple_pp'],0) self.assertEqual(b['ripple_model'],'complementary_excitation') self.assertEqual(a['allocation_reference_ratio'],4) def test_missing_calibration_and_invalid_inputs(self): r=run(dict(ron_area_mohm_mm2=0));self.assertFalse(r['calibrated']);self.assertIsNone(r['winner']) for p in [dict(io=-1),dict(utilization=2),dict(max_caps=1.5),dict(objective='anything'),dict(cap_uf=-1)]:self.assertIn('error',run(p)) if __name__=='__main__':unittest.main()