Spaces:
Running
Running
Download test_recommendation.py from minjiechen/ThinkPower: direct link, hf CLI and curl.
- Browser
- Download file 7.18 kB
-
https://huggingface.co/spaces/minjiechen/ThinkPower/resolve/main/test_recommendation.py
- Command line
-
hf download hf://spaces/minjiechen/ThinkPower/test_recommendation.py
-
curl -L -o test_recommendation.py https://huggingface.co/spaces/minjiechen/ThinkPower/resolve/main/test_recommendation.py
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() | |