33 double Phisb, T1s, Eta, Gg, Aa, Inv_Aa, U1, U1s, Vc, Kk, SqrtKk;
34 double dPhisb_dVb, dT1s_dVb, dVth_dVb, dVth_dVd, dAa_dVb, dVc_dVd;
35 double dVc_dVg, dVc_dVb, dKk_dVc, dVdsat_dVd, dVdsat_dVg, dVdsat_dVb;
36 double dUvert_dVg, dUvert_dVd, dUvert_dVb, dBeta0_dVd, dBeta0_dVb, Inv_Kk;
37 double dUtot_dVd, dUtot_dVb, dUtot_dVg, Ai, Bi, Vghigh, Vglow, Vgeff, Vof;
38 double Vbseff, Vgst, Vgdt, Qbulk, Utot;
39 double T0, T1, T2, T3, T4, T5, Arg1, Arg2, Exp0;
40 double tmp, tmp1, tmp2, tmp3, Uvert, Beta1, Beta2, Beta0, dGg_dVb, Exp1;
41 double T6, T7, T8, T9, Usat, n, ExpArg, ExpArg1;
42 double Beta, dQbulk_dVb, dVgdt_dVg, dVgdt_dVd;
43 double dVbseff_dVb, Ua, Ub, dVgdt_dVb, dQbulk_dVd;
44 double Con1, Con3, Con4, SqrVghigh, SqrVglow, CubVghigh, CubVglow;
45 double delta, Coeffa, Coeffb, Coeffc, Coeffd, Inv_Uvert, Inv_Utot;
46 double Inv_Vdsat, tanh, Sqrsech, dBeta1_dVb, dU1_dVd, dU1_dVg, dU1_dVb;
47 double Betaeff, FR, dFR_dVd, dFR_dVg, dFR_dVb, Betas, Beta3, Beta4;
48 double dBeta_dVd, dBeta_dVg, dBeta_dVb, dVgeff_dVg, dVgeff_dVd, dVgeff_dVb;
49 double dCon3_dVd, dCon3_dVb, dCon4_dVd, dCon4_dVb, dCoeffa_dVd, dCoeffa_dVb;
50 double dCoeffb_dVd, dCoeffb_dVb, dCoeffc_dVd, dCoeffc_dVb;
51 double dCoeffd_dVd, dCoeffd_dVb;
52 int ChargeComputationNeeded;
58 { ChargeComputationNeeded = 1;
61 { ChargeComputationNeeded = 0;
64 if (Vbs < model->B2vbb2) Vbs = model->
B2vbb2;
73 dT1s_dVb = -0.5 / T1s;
78 dPhisb_dVb = -tmp * tmp;
89 * T1s - here->
pParam->
B2k2 * Phisb - Eta * Vds;
96 tmp = 1.0 / (1.744 + 0.8364 * Phisb);
98 dGg_dVb = 0.8364 * tmp * tmp * dPhisb_dVb;
102 dAa_dVb = (Aa - 1.0) * (dGg_dVb / Gg - dT1s_dVb / T1s);
108 if ((Vgst >= Vghigh) || (here->
pParam->
B2n0 == 0.0))
111 dVgeff_dVd = -dVth_dVd;
112 dVgeff_dVb = -dVth_dVb;
119 tmp = 0.5 / (n * model->
B2Vtm);
121 ExpArg1 = -Vds / model->
B2Vtm;
122 ExpArg1 =
MAX(ExpArg1, -30.0);
125 tmp1 =
MAX(tmp1, 1.0
e-18);
126 tmp2 = 2.0 * Aa * tmp1;
131 ExpArg =
MAX(ExpArg, -30.0);
132 Exp0 = exp(0.5 * Vof + ExpArg);
133 Vgeff = sqrt(tmp2) * model->
B2Vtm * Exp0;
134 T0 = n * model->
B2Vtm;
135 dVgeff_dVg = Vgeff * tmp;
136 dVgeff_dVd = dVgeff_dVg * (n / tmp1 * Exp1 - dVth_dVd - Vgst
140 / (n * T1s * T1s) * dT1s_dVb + T0 * Inv_Aa * dAa_dVb);
144 ExpArg = Vglow * tmp;
145 ExpArg =
MAX(ExpArg, -30.0);
146 Exp0 = exp(0.5 * Vof + ExpArg);
147 Vgeff = sqrt(2.0 * Aa * (1.0 - Exp1)) * model->
B2Vtm * Exp0;
151 SqrVghigh = Vghigh * Vghigh;
152 SqrVglow = Vglow * Vglow;
153 CubVghigh = Vghigh * SqrVghigh;
154 CubVglow = Vglow * SqrVglow;
157 T2 = 3.0 * SqrVghigh;
160 T5 = SqrVghigh - SqrVglow;
161 T6 = CubVghigh - CubVglow;
163 delta = (T1 - T0) * T6 + (T2 - T3) * T5 + (T0 * T3 - T1 * T2) * T4;
165 Coeffb = (T1 - Con4 * T0) * T6 + (Con4 * T2 - T3) * T5
166 + (T0 * T3 - T1 * T2) * T7;
167 Coeffc = (Con4 - 1.0) * T6 + (T2 - T3) * T7 + (T3 - Con4 * T2) * T4;
168 Coeffd = (T1 - T0) * T7 + (1.0 - Con4) * T5 + (Con4 * T0 - T1) * T4;
169 Coeffa = SqrVghigh * (Coeffc + Coeffd * T0);
170 Vgeff = (Coeffa + Vgst * (Coeffb + Vgst * (Coeffc + Vgst * Coeffd)))
172 dVgeff_dVg = (Coeffb + Vgst * (2.0 * Coeffc + 3.0 * Vgst * Coeffd))
175 T8 = dT1s_dVb * here->
pParam->
B2nB / (T1s * T1s * n);
176 T9 = n * model->
B2Vtm;
177 dCon3_dVd = T7 * (n * Exp1 / tmp1 - Vglow * here->
pParam->
B2nD 179 dCon3_dVb = T7 * (T9 * Inv_Aa * dAa_dVb + Vglow * T8
181 dCon4_dVd = tmp * dCon3_dVd - T7 * here->
pParam->
B2nD / n;
182 dCon4_dVb = tmp * dCon3_dVb + T7 * T8;
184 dCoeffb_dVd = dCon4_dVd * (T2 * T5 - T0 * T6) + dCon3_dVd
185 * (T1 * T2 - T0 * T3);
186 dCoeffc_dVd = dCon4_dVd * (T6 - T2 * T4) + dCon3_dVd * (T3 - T2);
187 dCoeffd_dVd = dCon4_dVd * (T0 * T4 - T5) + dCon3_dVd * (T0 - T1);
188 dCoeffa_dVd = SqrVghigh * (dCoeffc_dVd + dCoeffd_dVd * T0);
190 dVgeff_dVd = -dVgeff_dVg * dVth_dVd + (dCoeffa_dVd + Vgst
191 * (dCoeffb_dVd + Vgst * (dCoeffc_dVd + Vgst
192 * dCoeffd_dVd))) * delta;
194 dCoeffb_dVb = dCon4_dVb * (T2 * T5 - T0 * T6) + dCon3_dVb
195 * (T1 * T2 - T0 * T3);
196 dCoeffc_dVb = dCon4_dVb * (T6 - T2 * T4) + dCon3_dVb * (T3 - T2);
197 dCoeffd_dVb = dCon4_dVb * (T0 * T4 - T5) + dCon3_dVb * (T0 - T1);
198 dCoeffa_dVb = SqrVghigh * (dCoeffc_dVb + dCoeffd_dVb * T0);
200 dVgeff_dVb = -dVgeff_dVg * dVth_dVb + (dCoeffa_dVb + Vgst
201 * (dCoeffb_dVb + Vgst * (dCoeffc_dVb + Vgst
202 * dCoeffd_dVb))) * delta;
208 Uvert = 1.0 + Vgeff * (Ua + Vgeff * Ub);
209 Uvert =
MAX(Uvert, 0.2);
210 Inv_Uvert = 1.0 / Uvert;
211 T8 = Ua + 2.0 * Ub * Vgeff;
212 dUvert_dVg = T8 * dVgeff_dVg;
213 dUvert_dVd = T8 * dVgeff_dVd;
214 dUvert_dVb = T8 * dVgeff_dVb + Vgeff * (here->
pParam->
B2uaB 217 T8 = U1s * Inv_Aa * Inv_Uvert;
220 dVc_dVg = T8 * dVgeff_dVg - T9 * dUvert_dVg;
221 dVc_dVd = T8 * dVgeff_dVd - T9 * dUvert_dVd;
222 dVc_dVb = T8 * dVgeff_dVb + here->
pParam->
B2u1B * Vgeff * Inv_Aa
223 * Inv_Uvert - Vc * Inv_Aa * dAa_dVb - T9 * dUvert_dVb;
226 tmp2 = sqrt(1.0 + 2.0 * Vc);
227 Kk = 0.5 * (1.0 + Vc + tmp2);
229 dKk_dVc = 0.5 + 0.5 / tmp2;
232 T8 = Inv_Aa / SqrtKk;
234 Vdsat =
MAX(Vdsat, 1.0
e-18);
235 Inv_Vdsat = 1.0 / Vdsat;
236 T9 = 0.5 * Vdsat * Inv_Kk * dKk_dVc;
237 dVdsat_dVd = T8 * dVgeff_dVd - T9 * dVc_dVd;
238 dVdsat_dVg = T8 * dVgeff_dVg - T9 * dVc_dVg;
239 dVdsat_dVb = T8 * dVgeff_dVb - T9 * dVc_dVb - Vdsat* Inv_Aa * dAa_dVb;
249 Beta1 = Betas - (Beta0 + model->
B2vdd * (Beta3 - model->
B2vdd 252 T0 = Vds * Beta2 * Inv_Vdsat;
257 tanh = (T2 - 1.0) / T3;
258 Sqrsech = 4.0 * T2 / (T3 * T3);
260 Beta = Beta0 + Beta1 * tanh + Vds * (Beta3 - Beta4 * Vds);
261 T4 = Beta1 * Sqrsech * Inv_Vdsat;
262 T5 = model->
B2vdd * tanh;
263 dBeta_dVd = Beta3 - 2.0 * Beta4 * Vds + T4 * (Beta2 - T0 * dVdsat_dVd);
277 T3 = Vds * Inv_Vdsat;
281 Utot = Uvert + U1 * Vds;
282 Utot =
MAX(Utot, 0.5);
283 Inv_Utot = 1.0 / Utot;
284 T5 = 2.0 * U1s * here->
pParam->
B2u1D * Inv_Vdsat * T4;
285 dU1_dVd = T5 * (T3 * dVdsat_dVd - 1.0);
286 dU1_dVg = T5 * T3 * dVdsat_dVg;
287 dU1_dVb = T5 * T3 * dVdsat_dVb + here->
pParam->
B2u1B * T2;
288 dUtot_dVd = dUvert_dVd + U1 + Vds * dU1_dVd;
289 dUtot_dVg = dUvert_dVg + Vds * dU1_dVg;
290 dUtot_dVb = dUvert_dVb + Vds * dU1_dVb;
292 tmp1 = (Vgeff - 0.5 * Aa * Vds);
294 Betaeff = Beta * Inv_Utot;
295 *Ids = Betaeff * tmp3;
296 T6 = *Ids / Betaeff * Inv_Utot;
297 *gds = T6 * (dBeta_dVd - Betaeff * dUtot_dVd) + Betaeff * (tmp1
298 + (dVgeff_dVd - 0.5 * Aa) * Vds);
299 *gm = T6 * (dBeta_dVg - Betaeff * dUtot_dVg) + Betaeff * Vds
301 *gmb = T6 * (dBeta_dVb - Betaeff * dUtot_dVb) + Betaeff * Vds
302 * (dVgeff_dVb - 0.5 * Vds * dAa_dVb);
305 { tmp1 = Vgeff * Inv_Aa * Inv_Kk;
306 tmp3 = 0.5 * Vgeff * tmp1;
307 Betaeff = Beta * Inv_Uvert;
308 *Ids = Betaeff * tmp3;
309 T0 = *Ids / Betaeff * Inv_Uvert;
310 T1 = Betaeff * Vgeff * Inv_Aa * Inv_Kk;
311 T2 = *Ids * Inv_Kk * dKk_dVc;
317 T5 = Bi / (Vds - Vdsat);
321 T7 = T5 / (Vds - Vdsat);
322 T8 = (1.0 - FR) * T7;
323 dFR_dVd = T8 * (dVdsat_dVd - 1.0);
324 dFR_dVg = T8 * dVdsat_dVg;
325 dFR_dVb = T8 * dVdsat_dVb + T6 * (here->
pParam->
B2aiB - Ai
328 *gds = (T0 * (dBeta_dVd - Betaeff * dUvert_dVd) + T1
329 * dVgeff_dVd - T2 * dVc_dVd) * FR + *Ids * dFR_dVd;
330 *gm = (T0 * (dBeta_dVg - Betaeff * dUvert_dVg)
331 + T1 * dVgeff_dVg - T2 * dVc_dVg) * FR + *Ids * dFR_dVg;
332 *gmb = (T0 * (dBeta_dVb - Betaeff * dUvert_dVb) + T1
333 * dVgeff_dVb - T2 * dVc_dVb - *Ids * Inv_Aa * dAa_dVb)
334 * FR + *Ids * dFR_dVb;
338 { *gds = T0 * (dBeta_dVd - Betaeff * dUvert_dVd) + T1
339 * dVgeff_dVd - T2 * dVc_dVd;
340 *gm = T0 * (dBeta_dVg - Betaeff * dUvert_dVg) + T1 * dVgeff_dVg
342 *gmb = T0 * (dBeta_dVb - Betaeff * dUvert_dVb) + T1
343 * dVgeff_dVb - T2 * dVc_dVb - *Ids * Inv_Aa * dAa_dVb;
350 *Ids = Beta * model->
B2Vtm * model->
B2Vtm * T0 * (1.0 - T1);
352 T4 = n * model->
B2Vtm;
357 T5 = Bi / (Vds - Vdsat);
361 T7 = T5 / (Vds - Vdsat);
362 T8 = (1.0 - FR) * T7;
363 dFR_dVd = T8 * (dVdsat_dVd - 1.0);
364 dFR_dVg = T8 * dVdsat_dVg;
365 dFR_dVb = T8 * dVdsat_dVb + T6 * (here->
pParam->
B2aiB - Ai
375 *gds = (T2 * dBeta_dVd + T3 * (here->
pParam->
B2vofD * T4 - dVth_dVd
377 * T0 * T1) * FR + *Ids * dFR_dVd;
378 *gm = (T2 * dBeta_dVg + T3) * FR + *Ids * dFR_dVg;
379 *gmb = (T2 * dBeta_dVb + T3 * (here->
pParam->
B2vofB * T4 - dVth_dVb
380 + here->
pParam->
B2nB * Vgst / (n * T1s * T1s) * dT1s_dVb)) * FR
396 *gds =
MAX(*gds,1.0
e-20);
400 || ((!ChargeComputationNeeded) &&
425 dVbseff_dVb = -dPhisb_dVb;
440 *cgs = -*cgg * (1.0 - dVbseff_dVb);
450 else if (Vgst <= 0.0)
455 *qg = here->
pParam->
CoxWL * Arg1 * (1.0 - T2 * (1.0 - T2 / 3.0));
459 *cgg = here->
pParam->
CoxWL * (1.0 - T2 * (2.0 - T2));
460 tmp = T3 * dVth_dVb - (*cgg + T3) * dVbseff_dVb;
461 *cgd = T3 * dVth_dVd;
462 *cgs = -(*cgg + *cgd + tmp);
473 {
if (Vgst < here->pParam->B2vghigh)
474 { Uvert = 1.0 + Vgst * (Ua + Vgst * Ub);
475 Uvert =
MAX(Uvert, 0.2);
476 Inv_Uvert = 1.0 / Uvert;
477 dUvert_dVg = Ua + 2.0 * Ub * Vgst;
478 dUvert_dVd = -dUvert_dVg * dVth_dVd;
479 dUvert_dVb = -dUvert_dVg * dVth_dVb + Vgst
482 T8 = U1s * Inv_Aa * Inv_Uvert;
485 dVc_dVg = T8 - T9 * dUvert_dVg;
486 dVc_dVd = -T8 * dVth_dVd - T9 * dUvert_dVd;
487 dVc_dVb = -T8 * dVth_dVb + here->
pParam->
B2u1B * Vgst * Inv_Aa
488 * Inv_Uvert - Vc * Inv_Aa * dAa_dVb - T9 * dUvert_dVb;
490 tmp2 = sqrt(1.0 + 2.0 * Vc);
491 Kk = 0.5 * (1.0 + Vc + tmp2);
493 dKk_dVc = 0.5 + 0.5 / tmp2;
496 T8 = Inv_Aa / SqrtKk;
498 T9 = 0.5 * Vdsat * Inv_Kk * dKk_dVc;
499 dVdsat_dVd = -T8 * dVth_dVd - T9 * dVc_dVd;
500 dVdsat_dVg = T8 - T9 * dVc_dVg;
501 dVdsat_dVb = -T8 * dVth_dVb - T9 * dVc_dVb
502 - Vdsat* Inv_Aa * dAa_dVb;
507 *cgd = -*cgg * dVth_dVd + dQbulk_dVd;
508 tmp = -*cgg * dVth_dVb + dQbulk_dVb;
509 *cgs = -(*cgg + *cgd + tmp);
513 *cbs = dQbulk_dVd + dQbulk_dVb;
516 tmp = -*cdg * dVth_dVb;
517 *cdd = -*cdg * dVth_dVd;
518 *cds = -(*cdg + *cdd + tmp);
531 T0 = Vgst / (Vgst + Vgdt);
532 T1 = Vgdt / (Vgst + Vgdt);
537 dVgdt_dVg = T9 + T6 * dVdsat_dVg;
538 dVgdt_dVd = T6 * dVdsat_dVd - T8 -T9 * dVth_dVd;
539 dVgdt_dVb = T6 * dVdsat_dVb -T9 * dVth_dVb;
542 - Vgdt * T0) + Qbulk;
545 + 0.8 * Vgst + Vgdt * T1
546 + 0.2 * T5 * (Vgdt - Vgst));
552 - T2 * dVth_dVd) + dQbulk_dVd;
553 *cgs = -(*cgg + *cgd + tmp);
555 T2 = 0.8 - 0.4 * T1 * (2.0 * T1 + T0 + T0 * (T1 - T0));
556 T3 = 0.2 + T1 + T0 * (1.0 - 0.4 * T0 * (T1 + 3.0 * T0));
562 *cds = -(*cdg + tmp + *cdd);
566 *cbs = dQbulk_dVd + dQbulk_dVb;
573 switch (valuetypeflag)
575 case 0: *Ids =
MAX(*Ids,1
e-50);
577 case -1: *Ids =
MAX(*Ids,1
e-50);
581 case -3: *Ids = *gds;
583 case -4: *Ids = 1.0 / *gds;
585 case -5: *Ids = *gmb;
587 case -6: *Ids = *qg / 1.0e-12;
589 case -7: *Ids = *qb / 1.0e-12;
591 case -8: *Ids = *qd / 1.0e-12;
593 case -9: *Ids = -(*qb + *qg + *qd) / 1.0
e-12;
595 case -10: *Ids = *cgg / 1.0e-12;
597 case -11: *Ids = *cgd / 1.0e-12;
599 case -12: *Ids = *cgs / 1.0e-12;
601 case -13: *Ids = -(*cgg + *cgd + *cgs) / 1.0
e-12;
603 case -14: *Ids = *cbg / 1.0e-12;
605 case -15: *Ids = *cbd / 1.0e-12;
607 case -16: *Ids = *cbs / 1.0e-12;
609 case -17: *Ids = -(*cbg + *cbd + *cbs) / 1.0
e-12;
611 case -18: *Ids = *cdg / 1.0e-12;
613 case -19: *Ids = *cdd / 1.0e-12;
615 case -20: *Ids = *cds / 1.0e-12;
617 case -21: *Ids = -(*cdg + *cdd + *cds) / 1.0
e-12;
619 case -22: *Ids = -(*cgg + *cdg + *cbg) / 1.0
e-12;
621 case -23: *Ids = -(*cgd + *cdd + *cbd) / 1.0
e-12;
623 case -24: *Ids = -(*cgs + *cds + *cbs) / 1.0
e-12;
625 default: *Ids =
MAX(*Ids, 1.0
e-50);
struct bsim2SizeDependParam * pParam
double B2channelChargePartitionFlag