ThinkPower / test_recommendation.py
minjiechen's picture
Publish ThinkPower topology analysis website
3f7f105 verified
Raw History Blame Contribute Delete
7.18 kB
"""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()