Spaces:
Running
Running
File size: 15,736 Bytes
3bb2683 96a7f6a 4fe5203 3bb2683 4fe5203 3bb2683 4fe5203 3bb2683 4fe5203 3bb2683 4fe5203 3bb2683 4fe5203 3bb2683 4fe5203 3bb2683 4fe5203 3bb2683 424d972 4fe5203 2f04bef 4fe5203 424d972 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 | """Traceable limiting models transcribed from XFLY-IEEE Table I.
Numerical outputs are estimates, never a substitute for a verified switched graph.
"""
import math
import numpy as np
CATALOG = [
dict(id='xfly2p',name='XFLY6S · 2P',short='XFLY2P',family='Cross-linked',switches=6,color='#168276',gain='M = D/2',range='0 < M < 0.5',status='Paper model',ratio=[1,1,1,3],asset='xfly6s.svg',note='Paper XFLY2P coefficients use the effective six-switch current model with the physical split-middle 1:1:1:3 area allocation. A true six-device area budget requires a separate normalization. Clamp recharge is excluded.'),
dict(id='xfly4p',name='XFLY8S · 4P',short='XFLY4P',family='Cross-linked',switches=8,color='#cf7b30',gain='M = D/2; gate pulse d = D/2',range='0 < M ≤ 0.25',status='Paper model · limited',ratio=[1,1,1,math.sqrt(5)],asset='xfly4p.svg',note='Split-middle four-pulse realization only. Additional clamp recharge is excluded; this is not a loss model for every eight-switch control sequence.'),
dict(id='3lbuck',name='Three-level buck',short='3LBUCK',family='Flying capacitor',switches=8,color='#5c70b8',gain='M = D/2; gate duty = M',range='0 < M ≤ 0.5',status='Paper model',ratio=[1,1,math.sqrt(3),math.sqrt(3)],asset='3lbuck.svg',note='Two phases, local flying capacitors, lower-half-input operating region.'),
dict(id='2sbuck',name='Capacitor-clamped buck',short='2SBUCK',family='Clamped',switches=8,color='#ad5c88',gain='M = D/2',range='0 < M < 0.5',status='Paper model',ratio=[1,1,1,3],asset='2sbuck.svg',note='Equal main and clamp capacitance; clamp ESR = 0. Recharge still contributes to switch current and SSL loss.'),
dict(id='buck',name='Stacked synchronous buck',short='BUCK',family='Benchmark',switches=8,color='#48535f',gain='M = gate duty; comparison D = 2M',range='0 < M ≤ 0.5',status='Paper model',ratio=[1,1,math.sqrt(3),math.sqrt(3)],asset='buck.svg',note='Two phases, two series devices in each switch position. Nominal voltage sharing requires suitable drive/balancing.'),
dict(id='buck2',name='Two-phase synchronous buck',short='BUCK2Φ',family='2:1 family · four MOSFETs',switches=4,color='#a06a22',gain='M = gate duty Db',range='0 < M < 1; sized at M = 0.5',status='Derived flat-current model',ratio=[1,1],asset='buck2.svg',note='Two 180-degree interleaved phases, one upper and one lower MOSFET each; two inverse-coupled windings. Equal widths at the 2:1 sizing point, total 12 A0. RFET = Rs/6; RIND = Rl/2. Flat equal winding currents; winding DCR is unchanged by coupling. Mutual inductance affects ripple and dynamics, which are not quantified here.'),
dict(id='sp2',name='2:1 series-parallel SC',short='SP-SC 2:1',family='2:1 family · two SC phases',switches=8,color='#8c6caf',gain='Fixed ideal M = 1/2; 50% two-state clock',range='M = 0.5 only; finite output droop',status='Derived periodic RC model',ratio=[1,1,1,1],asset='sp2.svg',note='Two interleaved four-switch series-parallel cells; two equal flying capacitors, no power inductor. Identical switches Rs×2/3, stiff ports, 50% states, dead time omitted. Exact linear periodic RC: Req = RSSL coth(RSSL/RFSL), RFSL = 2Rs/3 + Rc/2, RSSL = 1/(8 Cf fs), Cf per phase. Fixed 2:1 topology; not a continuously variable ratio.'),
dict(id='boost',name='XFLY-Boost',short='XFLY-Boost',family='Step-up',switches=2,color='#3a849b',gain='Vhigh/Vlow = 2/(1−Db)',range='Balanced CCM branch: Db ≥ 0.5',status='Topology only',ratio=[],asset='boost.svg',note='Two low-side MOSFETs and four diodes. Buck loss coefficients cannot be reused for this graph. No numeric loss model is assigned.'),
dict(id='ns',name='XFLY-NS',short='XFLY-NS',family='Scalable',switches=8,color='#887553',gain='Sequence and level dependent',range='Requires state-table derivation',status='Topology only',ratio=[],asset='ns.svg',note='Use the state-table workspace to derive coefficients for a specified extension and switching sequence.'),
]
INDEX={x['id']:x for x in CATALOG}
FORMULAS={
'buck2':['Rs/6 (equal fixed widths; Db=M)','0','Rl/2','0'],
'sp2':['2 Rs/3','Rc/2','0','1/(8 Cf fs); Req = RSSL coth[RSSL/(2Rs/3 + Rc/2)]'],
'xfly2p':['(2+5D) Rs /12, D≤0.5; (5D²−2D+2) Rs /[12(1−D)], D>0.5','D Rc /4, D≤0.5; D² Rc /[4(1−D)], D>0.5','Rl /2','max(2D−1,0)² / (8 Cf fs)'],
'xfly4p':['(3+√5)[3D+(2+D)/√5] Rs /24','D Rc /2','Rl /2','0 (specified sequence)'],
'3lbuck':['(1+√3)[D+(2−D)/√3] Rs /6','D Rc /2','Rl /2','0 (specified sequence)'],
'2sbuck':['(2+D−D²) Rs /[12(1−D)]','D Rc /[8(1−D)]','Rl /2','D² / (8 Cf fs)'],
'buck':['(1+√3)[D+(2−D)/√3] Rs /6','0','Rl /2','0'],
}
def number(p,key,default,lo,hi):
try:v=float(p.get(key,default))
except (ValueError,TypeError):raise ValueError(f'{key} must be a number')
if not math.isfinite(v) or not lo<=v<=hi:raise ValueError(f'{key} must be between {lo} and {hi}')
return v
def coefficients(key,D):
if key=='buck2':return (1/6,0,0)
if key=='sp2':return (2/3,.5,1/8)
if key=='xfly2p':
return ((2+5*D)/12,D/4,0) if D<=.5 else ((5*D*D-2*D+2)/(12*(1-D)),D*D/(4*(1-D)),max(2*D-1,0)**2/8)
if key=='xfly4p':return ((3+math.sqrt(5))/24*(3*D+(2+D)/math.sqrt(5)),D/2,0)
if key in ('3lbuck','buck'):return ((1+math.sqrt(3))/6*(D+(2-D)/math.sqrt(3)), D/2 if key=='3lbuck' else 0,0)
if key=='2sbuck':return ((2+D-D*D)/(12*(1-D)),D/(8*(1-D)),D*D/8)
raise ValueError('This topology has no verified numeric loss model')
def valid(key,M):
if key not in FORMULAS:return False
if key=='sp2':return abs(M-.5)<1e-12
if key=='buck2':return 0<M<1
return M>0 and (M<=.25+1e-12 if key=='xfly4p' else M<.5 if key in ('xfly2p','2sbuck') else M<=.5)
def charging_resistance(key,net,ssl):
if key=='sp2':return ssl/math.tanh(ssl/net) if net and ssl else net+ssl
return math.hypot(net,ssl)
def evaluate(key,M,p):
if not valid(key,M):return None
D=2*M; a,b,c=coefficients(key,D)
fet=a*p['rs'];cap=b*p['rc'];ind=(0 if key=='sp2' else .5)*p['rl'];ssl=c/(p['cf']*p['fs'])
total=ind+charging_resistance(key,fet+cap,ssl)
return dict(fet=fet,cap=cap,ind=ind,ssl=ssl,fsl=fet+cap+ind,total=total,coefficients=[a,b,0 if key=='sp2' else .5,c],D=D,gate_duty=M if key=='buck2' else .5 if key=='sp2' else None)
def allocation(key):
# Figure 18 uses the physical split-middle layout for XFLY2P.
if key=='xfly2p':weights=[1,1,1,3]; per_phase=6
else:weights=INDEX[key]['ratio'];per_phase=6
s=sum(weights);areas=[per_phase*x/s for x in weights]
return dict(relative=weights,areas=areas,area_fractions=[x/12 for x in areas],labels=[f'S{i+1}' for i in range(len(areas))],total_area=12,reference_ratio=2 if key in ('buck2','sp2') else 4)
def analyze(payload):
p=dict(rs=number(payload,'rs_mohm',20,0,1e5)/1000,rc=number(payload,'rc_mohm',20,0,1e5)/1000,
rl=number(payload,'rl_mohm',20,0,1e5)/1000,cf=number(payload,'cf_nf',50,.001,1e9)*1e-9,
fs=number(payload,'fs_mhz',50,.000001,1e4)*1e6)
ratio=number(payload,'ratio',4,1.01,256); M=1/ratio;io=number(payload,'iout',10,.001,1e6);vin=number(payload,'vin',16,.001,1e6)
selected=payload.get('topologies',['xfly2p','xfly4p','3lbuck','2sbuck','buck'])
if not isinstance(selected,list) or not selected or any(k not in INDEX for k in selected):raise ValueError('Select known topologies')
rows=[]
for key in dict.fromkeys(selected):
r=evaluate(key,M,p);meta=INDEX[key]
row=dict(id=key,name=meta['name'],short=meta['short'],color=meta['color'],note=meta['note'],formulas=FORMULAS.get(key),allocation=allocation(key) if key in FORMULAS else None,valid=r is not None,domain=meta['range'])
if r:
loss=io*io*r['total'];pout=vin*M*io
row.update(r);row.update(loss_w=loss,conduction_efficiency=100*pout/(pout+loss),droop_estimate_v=io*r['total'])
rows.append(row)
xs=np.unique(np.r_[np.linspace(.0005,.4995,500),.25,.5,M])
curves=[]
for key in dict.fromkeys(selected):
pts=[]
for x in xs:
r=evaluate(key,float(x),p)
if r:pts.append([float(x),r['total']*1000])
if pts:curves.append(dict(id=key,name=INDEX[key]['short'],color=INDEX[key]['color'],points=pts))
return dict(ratio=ratio,M=M,vin=vin,iout=io,parameters=p,rows=rows,curves=curves,
provenance='XFLY-IEEE Section V-F, Table I; Figures 18–20. Equations transcribed from the current working manuscript.',
assumptions=['Fixed transistor allocations: 4:1 for paper cells, 2:1 for BUCK2Φ and SP-SC; total area 12 A₀ and identical device technology.',
'Matched average phase currents; flat-current FSL for inductive cells, periodic linear RC for SP-SC; zero clamp-capacitor ESR.',
'Paper cells: Rout = RIND + √((RFET + RCAP)² + RSSL²). SP-SC: exact periodic RC coth relation. FSL and SSL are asymptotes, not additive losses.',
'Switching transitions, gate drive, core loss, winding ripple, dead time and interconnect loss are excluded.',
'An operating ratio change is not a newly derived higher-order topology. Additional levels need their own graph and state model.',
'Conduction efficiency uses nominal output power and modeled conduction loss; it is not a measured or total converter efficiency.'])
def state_model(p):
"""Evaluate user-reviewed normalized state currents, with periodic charge balance."""
states=p.get('states',[]);budget=number(p,'area_budget',12,.001,1e6)
if not isinstance(states,list) or not 1<=len(states)<=64:raise ValueError('Provide 1–64 switching states')
def vector(v):
if not isinstance(v,list) or len(v)>256:raise ValueError('State currents must be arrays with at most 256 entries')
a=np.asarray(v,dtype=float)
if not np.isfinite(a).all() or (abs(a)>1e6).any():raise ValueError('Invalid normalized current')
return a
durations=np.array([number(s,'fraction',0,0,1) for s in states])
if abs(durations.sum()-1)>1e-7:raise ValueError('State fractions must sum to 1')
out={};weights={}
for field in ['switch','capacitor','inductor']:
vs=[vector(s.get(field+'_currents',[])) for s in states]
if len({len(a) for a in vs})!=1:raise ValueError(f'{field} current dimensions must match in every state')
matrix=np.array(vs);weights[field]=(durations[:,None]*matrix**2).sum(axis=0)
if field=='capacitor':
charge=(durations[:,None]*matrix).sum(axis=0)
if np.any(abs(charge)>1e-7):raise ValueError('Capacitor charge balance failed: '+str(charge.tolist()))
out['capacitor_charge_residuals']=charge.tolist()
roots=np.sqrt(weights['switch']);den=roots.sum()
if den<=0:raise ValueError('At least one switch must carry current')
areas=budget*roots/den
rs=number(p,'rs_mohm',20,0,1e5)/1000
rc=number(p,'rc_mohm',20,0,1e5)/1000
rl=number(p,'rl_mohm',20,0,1e5)/1000
out.update(switch_weights=weights['switch'].tolist(),capacitor_weights=weights['capacitor'].tolist(),inductor_weights=weights['inductor'].tolist(),optimal_areas=areas.tolist(),rfet=rs*den**2/budget,rcap=rc*weights['capacitor'].sum(),rind=rl*weights['inductor'].sum(),status='Conditional FSL result: charge balance checked; KCL, gate legality, voltage balance and graph consistency must be independently verified. SSL is not inferred from these currents.')
return out
def control(p):
# Separate verification operating point: not silently tied to 50 MHz loss example.
vin=number(p,'vin',16,.01,1e4);D=number(p,'duty',.4,.001,.5);io=number(p,'iout',10,.001,1e5)
cf=number(p,'cf_uf',2,.001,1e6)*1e-6;co=number(p,'co_uf',10,.001,1e6)*1e-6
rl=number(p,'rl_mohm',20,.001,1e4)/1000;lk=number(p,'lk_nh',200,.01,1e9)*1e-9;lm=number(p,'lm_uh',2,0,1e6)*1e-6
fs=number(p,'fs_khz',500,.1,1e6)*1e3;fc=number(p,'fc_khz',5,.001,fs/1e3/4)*1e3;fp=min(fc*10,fs/3)
vo=D*vin/2-rl*io/2
if vo<=0:raise ValueError('The requested load exceeds the positive-output equilibrium of this model')
load=vo/io;ldm=lk+2*lm;f=np.logspace(1,np.log10(fs/2),1000);s=2j*np.pi*f
def plant(z):return vin/((lk*z+rl)*(co*z+1/load)+2)
z=2j*np.pi*fc;ki=abs(z*(1+z/(2*np.pi*fp)))/abs(plant(z))
loop=plant(s)*ki/(s*(1+s/(2*np.pi*fp)))*np.exp(-s/fs)
phase=np.unwrap(np.angle(loop))*180/np.pi
gc=vin/((lk*s+rl)*(co*s+1/load)+2)
gd=-(io*(ldm*s+rl)+D*vin)/(2*(ldm*cf*s*s+rl*cf*s+D*D))
ph_fc=float((np.angle(plant(z))-np.pi/2-np.arctan(fc/fp)-2*np.pi*fc/fs)*180/np.pi)
crosses=np.where(np.diff(np.sign(np.log(abs(loop))))!=0)[0]
return dict(frequency=f.tolist(),loop_db=(20*np.log10(abs(loop))).tolist(),loop_phase=phase.tolist(),gcm_db=(20*np.log10(abs(gc))).tolist(),gdm_db=(20*np.log10(abs(gd))).tolist(),fc=fc,f_dm=D/(2*np.pi*np.sqrt(ldm*cf)),f_cm=np.sqrt((2+rl/load)/(lk*co))/(2*np.pi),phase_margin=180+ph_fc,unity_crossings=len(crosses),ki=ki,fp=fp,vo=vo,
note='XFLY6S symmetric nonoverlap CCM example only. Unity feedback/PWM gain, resistive load, stiff source, one-period delay. The voltage loop does not damp an unobservable differential mode; input-filter interaction requires an impedance model.')
def analyze_pu(payload):
"""Compare dimensionless coefficients using Rs as the shared resistance base."""
rho_c=number(payload,'rho_c',1,0,1e6)
rho_l=number(payload,'rho_l',1,0,1e6)
rho_q=number(payload,'rho_q',20,0,1e9)
ratio=number(payload,'ratio',4,1.01,256);M=1/ratio
selected=payload.get('topologies',['xfly2p','xfly4p','3lbuck','2sbuck','buck'])
if not isinstance(selected,list) or not selected or any(k not in INDEX for k in selected):raise ValueError('Select known topologies')
def result(key,m):
if not valid(key,m):return None
a,b,c=coefficients(key,2*m)
fet=a;cap=b*rho_c;ind=(0 if key=='sp2' else .5)*rho_l;ssl=c*rho_q
net=fet+cap
increment=(charging_resistance(key,net,ssl)-net) if key=='sp2' else ssl*ssl/(math.hypot(net,ssl)+net) if net or ssl else 0
return dict(fet=fet,cap=cap,ind=ind,ssl=ssl,ssl_series=increment,fsl=fet+cap+ind,total=ind+charging_resistance(key,net,ssl),coefficients=[a,b,0 if key=='sp2' else .5,c],D=2*m,gate_duty=m if key=='buck2' else .5 if key=='sp2' else None)
rows=[]
for key in dict.fromkeys(selected):
r=result(key,M);meta=INDEX[key]
row=dict(id=key,name=meta['name'],short=meta['short'],color=meta['color'],note=meta['note'],formulas=FORMULAS.get(key),allocation=allocation(key) if key in FORMULAS else None,valid=r is not None,domain=meta['range'])
if r:row.update(r)
rows.append(row)
xs=np.unique(np.r_[np.linspace(.0005,.4995,500),.25,.5,M]);curves=[]
for key in dict.fromkeys(selected):
pts=[]
for m in xs:
r=result(key,float(m))
if r:pts.append([float(m),r['total']])
if pts:curves.append(dict(id=key,name=INDEX[key]['short'],color=INDEX[key]['color'],points=pts))
assumptions=analyze({})['assumptions']
assumptions=[x for x in assumptions if not x.startswith('Conduction efficiency')]
assumptions.insert(0,'Rs is the common resistance base. rho_C=Rc/Rs; rho_L=Rl/Rs; rho_Q=1/(Cf fs Rs). No absolute resistance, current or power is assigned.')
assumptions.insert(1,'Table columns k_FET=RFET/Rs, k_CAP=RCAP/Rc, k_IND=RIND/Rl and k_SSL=RSSL Cf fs are independent coefficients. These columns are not directly additive. Coefficients remain defined when their corresponding loss scale is zero.')
return dict(ratio=ratio,M=M,normalization=dict(base='R_S',rho_c=rho_c,rho_l=rho_l,rho_q=rho_q,component_unit='R/R_S',coefficient_bases=['R_S','R_C','R_L','1/(C_F f_s)']),rows=rows,curves=curves,provenance='XFLY-IEEE Section V-F, Table I; Figures 18–20. Dimensionless form of the current manuscript models.',assumptions=assumptions)
def state_model_pu(payload):
"""Return coefficients from normalized state currents; no device values needed."""
out=state_model({**payload,'rs_mohm':1000,'rc_mohm':1000,'rl_mohm':1000})
return {k:v for k,v in out.items() if k not in ['rfet','rcap','rind']} | dict(k_fet=out['rfet'],k_cap=out['rcap'],k_ind=out['rind'],bases=dict(k_fet='R_S',k_cap='R_C',k_ind='R_L'),normalization='Currents / Iout; areas / A0; resistances as coefficients of Rs, Rc, Rl. SSL requires a separate charge-transfer model.')
|