Jspice3
b2eval.c File Reference
#include "spice.h"
#include <stdio.h>
#include <math.h>
#include "bsim2def.h"
#include "const.h"
#include "util.h"
Include dependency graph for b2eval.c:

Go to the source code of this file.

Functions

void B2evaluate (double Vds, double Vbs, double Vgs, B2instance *here, B2model *model, double *gm, double *gds, double *gmb, double *qg, double *qb, double *qd, double *cgg, double *cgd, double *cgs, double *cbg, double *cbd, double *cbs, double *cdg, double *cdd, double *cds, double *Ids, double *von, double *vdsat, CKTcircuit *ckt)
 

Function Documentation

void B2evaluate ( double  Vds,
double  Vbs,
double  Vgs,
B2instance here,
B2model model,
double *  gm,
double*  gds,
double*  gmb,
double*  qg,
double*  qb,
double*  qd,
double*  cgg,
double*  cgd,
double*  cgs,
double*  cbg,
double *  cbd,
double*  cbs,
double*  cdg,
double*  cdd,
double*  cds,
double*  Ids,
double*  von,
double*  vdsat,
CKTcircuit ckt 
)

Definition at line 22 of file b2eval.c.

31  {
32  double Vth, Vdsat;
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;
53  int valuetypeflag; /* added 3/19/90 JSD */
54 
55  if ((ckt->CKTmode & (MODEAC | MODETRAN)) ||
56  ((ckt->CKTmode & MODETRANOP) && (ckt->CKTmode & MODEUIC)) ||
57  (ckt->CKTmode & MODEINITSMSIG) )
58  { ChargeComputationNeeded = 1;
59  }
60  else
61  { ChargeComputationNeeded = 0;
62  }
63 
64  if (Vbs < model->B2vbb2) Vbs = model->B2vbb2;
65  if (Vgs > model->B2vgg2) Vgs = model->B2vgg2;
66  if (Vds > model->B2vdd2) Vds = model->B2vdd2;
67 
68 /* Threshold Voltage. */
69  if (Vbs <= 0.0)
70  { Phisb = here->pParam->B2phi - Vbs;
71  dPhisb_dVb = -1.0;
72  T1s = sqrt(Phisb);
73  dT1s_dVb = -0.5 / T1s;
74  }
75  else
76  { tmp = here->pParam->B2phi / (here->pParam->B2phi + Vbs);
77  Phisb = here->pParam->B2phi * tmp;
78  dPhisb_dVb = -tmp * tmp;
79  T1s = here->pParam->Phis3 / (here->pParam->B2phi + 0.5 * Vbs);
80  dT1s_dVb = -0.5 * T1s * T1s / here->pParam->Phis3;
81  }
82 
83  Eta = here->pParam->B2eta0 + here->pParam->B2etaB * Vbs;
84  Ua = here->pParam->B2ua0 + here->pParam->B2uaB * Vbs;
85  Ub = here->pParam->B2ub0 + here->pParam->B2ubB * Vbs;
86  U1s = here->pParam->B2u10 + here->pParam->B2u1B * Vbs;
87 
88  Vth = here->pParam->B2vfb + here->pParam->B2phi + here->pParam->B2k1
89  * T1s - here->pParam->B2k2 * Phisb - Eta * Vds;
90  dVth_dVd = -Eta;
91  dVth_dVb = here->pParam->B2k1 * dT1s_dVb + here->pParam->B2k2
92  - here->pParam->B2etaB * Vds;
93 
94  Vgst = Vgs - Vth;
95 
96  tmp = 1.0 / (1.744 + 0.8364 * Phisb);
97  Gg = 1.0 - tmp;
98  dGg_dVb = 0.8364 * tmp * tmp * dPhisb_dVb;
99  T0 = Gg / T1s;
100  tmp1 = 0.5 * T0 * here->pParam->B2k1;
101  Aa = 1.0 + tmp1;
102  dAa_dVb = (Aa - 1.0) * (dGg_dVb / Gg - dT1s_dVb / T1s);
103  Inv_Aa = 1.0 / Aa;
104 
105  Vghigh = here->pParam->B2vghigh;
106  Vglow = here->pParam->B2vglow;
107 
108  if ((Vgst >= Vghigh) || (here->pParam->B2n0 == 0.0))
109  { Vgeff = Vgst;
110  dVgeff_dVg = 1.0;
111  dVgeff_dVd = -dVth_dVd;
112  dVgeff_dVb = -dVth_dVb;
113  }
114  else
115  { Vof = here->pParam->B2vof0 + here->pParam->B2vofB * Vbs
116  + here->pParam->B2vofD * Vds;
117  n = here->pParam->B2n0 + here->pParam->B2nB / T1s
118  + here->pParam->B2nD * Vds;
119  tmp = 0.5 / (n * model->B2Vtm);
120 
121  ExpArg1 = -Vds / model->B2Vtm;
122  ExpArg1 = MAX(ExpArg1, -30.0);
123  Exp1 = exp(ExpArg1);
124  tmp1 = 1.0 - Exp1;
125  tmp1 = MAX(tmp1, 1.0e-18);
126  tmp2 = 2.0 * Aa * tmp1;
127 
128  if (Vgst <= Vglow)
129  {
130  ExpArg = Vgst * tmp;
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
137  * here->pParam->B2nD / n + T0 * here->pParam->B2vofD);
138  dVgeff_dVb = dVgeff_dVg * (here->pParam->B2vofB * T0
139  - dVth_dVb + here->pParam->B2nB * Vgst
140  / (n * T1s * T1s) * dT1s_dVb + T0 * Inv_Aa * dAa_dVb);
141  }
142  else
143  {
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;
148  Con1 = Vghigh;
149  Con3 = Vgeff;
150  Con4 = Con3 * tmp;
151  SqrVghigh = Vghigh * Vghigh;
152  SqrVglow = Vglow * Vglow;
153  CubVghigh = Vghigh * SqrVghigh;
154  CubVglow = Vglow * SqrVglow;
155  T0 = 2.0 * Vghigh;
156  T1 = 2.0 * Vglow;
157  T2 = 3.0 * SqrVghigh;
158  T3 = 3.0 * SqrVglow;
159  T4 = Vghigh - Vglow;
160  T5 = SqrVghigh - SqrVglow;
161  T6 = CubVghigh - CubVglow;
162  T7 = Con1 - Con3;
163  delta = (T1 - T0) * T6 + (T2 - T3) * T5 + (T0 * T3 - T1 * T2) * T4;
164  delta = 1.0 / delta;
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)))
171  * delta;
172  dVgeff_dVg = (Coeffb + Vgst * (2.0 * Coeffc + 3.0 * Vgst * Coeffd))
173  * delta;
174  T7 = Con3 * tmp;
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
178  / n + T9 * here->pParam->B2vofD);
179  dCon3_dVb = T7 * (T9 * Inv_Aa * dAa_dVb + Vglow * T8
180  + T9 * here->pParam->B2vofB);
181  dCon4_dVd = tmp * dCon3_dVd - T7 * here->pParam->B2nD / n;
182  dCon4_dVb = tmp * dCon3_dVb + T7 * T8;
183 
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);
189 
190  dVgeff_dVd = -dVgeff_dVg * dVth_dVd + (dCoeffa_dVd + Vgst
191  * (dCoeffb_dVd + Vgst * (dCoeffc_dVd + Vgst
192  * dCoeffd_dVd))) * delta;
193 
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);
199 
200  dVgeff_dVb = -dVgeff_dVg * dVth_dVb + (dCoeffa_dVb + Vgst
201  * (dCoeffb_dVb + Vgst * (dCoeffc_dVb + Vgst
202  * dCoeffd_dVb))) * delta;
203  }
204  }
205 
206  if (Vgeff > 0.0)
207  {
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
215  + Vgeff * here->pParam->B2ubB);
216 
217  T8 = U1s * Inv_Aa * Inv_Uvert;
218  Vc = T8 * Vgeff;
219  T9 = Vc * 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;
224 
225 
226  tmp2 = sqrt(1.0 + 2.0 * Vc);
227  Kk = 0.5 * (1.0 + Vc + tmp2);
228  Inv_Kk = 1.0 / Kk;
229  dKk_dVc = 0.5 + 0.5 / tmp2;
230  SqrtKk = sqrt(Kk);
231 
232  T8 = Inv_Aa / SqrtKk;
233  Vdsat = Vgeff * T8;
234  Vdsat = MAX(Vdsat, 1.0e-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;
240 
241  Beta0 = here->pParam->B2beta0 + here->pParam->B2beta0B * Vbs;
242  Betas = here->pParam->B2betas0 + here->pParam->B2betasB * Vbs;
243  Beta2 = here->pParam->B2beta20 + here->pParam->B2beta2B * Vbs
244  + here->pParam->B2beta2G * Vgs;
245  Beta3 = here->pParam->B2beta30 + here->pParam->B2beta3B * Vbs
246  + here->pParam->B2beta3G * Vgs;
247  Beta4 = here->pParam->B2beta40 + here->pParam->B2beta4B * Vbs
248  + here->pParam->B2beta4G * Vgs;
249  Beta1 = Betas - (Beta0 + model->B2vdd * (Beta3 - model->B2vdd
250  * Beta4));
251 
252  T0 = Vds * Beta2 * Inv_Vdsat;
253  T0 = MIN(T0, 30.0);
254  T1 = exp(T0);
255  T2 = T1 * T1;
256  T3 = T2 + 1.0;
257  tanh = (T2 - 1.0) / T3;
258  Sqrsech = 4.0 * T2 / (T3 * T3);
259 
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);
264  dBeta_dVg = T4 * (here->pParam->B2beta2G * Vds - T0 * dVdsat_dVg)
265  + here->pParam->B2beta3G * (Vds - T5)
266  - here->pParam->B2beta4G * (Vds * Vds - model->B2vdd * T5);
267  dBeta1_dVb = here->pParam->Arg;
268  dBeta_dVb = here->pParam->B2beta0B + dBeta1_dVb * tanh + Vds
269  * (here->pParam->B2beta3B - Vds * here->pParam->B2beta4B)
270  + T4 * (here->pParam->B2beta2B * Vds - T0 * dVdsat_dVb);
271 
272 
273  if (Vgst > Vglow)
274  {
275  if (Vds <= Vdsat) /* triode region */
276  {
277  T3 = Vds * Inv_Vdsat;
278  T4 = T3 - 1.0;
279  T2 = 1.0 - here->pParam->B2u1D * T4 * T4;
280  U1 = U1s * T2;
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;
291 
292  tmp1 = (Vgeff - 0.5 * Aa * Vds);
293  tmp3 = tmp1 * 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
300  * dVgeff_dVg;
301  *gmb = T6 * (dBeta_dVb - Betaeff * dUtot_dVb) + Betaeff * Vds
302  * (dVgeff_dVb - 0.5 * Vds * dAa_dVb);
303  }
304  else /* Saturation */
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;
312 
313  if (here->pParam->B2ai0 != 0.0)
314  {
315  Ai = here->pParam->B2ai0 + here->pParam->B2aiB * Vbs;
316  Bi = here->pParam->B2bi0 + here->pParam->B2biB * Vbs;
317  T5 = Bi / (Vds - Vdsat);
318  T5 = MIN(T5, 30.0);
319  T6 = exp(-T5);
320  FR = 1.0 + Ai * T6;
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
326  * here->pParam->B2biB / (Vds - Vdsat));
327 
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;
335  *Ids *= FR;
336  }
337  else
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
341  - T2 * dVc_dVg;
342  *gmb = T0 * (dBeta_dVb - Betaeff * dUvert_dVb) + T1
343  * dVgeff_dVb - T2 * dVc_dVb - *Ids * Inv_Aa * dAa_dVb;
344  }
345  } /* end of Saturation */
346  }
347  else
348  { T0 = Exp0 * Exp0;
349  T1 = Exp1;
350  *Ids = Beta * model->B2Vtm * model->B2Vtm * T0 * (1.0 - T1);
351  T2 = *Ids / Beta;
352  T4 = n * model->B2Vtm;
353  T3 = *Ids / T4;
354  if ((Vds > Vdsat) && here->pParam->B2ai0 != 0.0)
355  { Ai = here->pParam->B2ai0 + here->pParam->B2aiB * Vbs;
356  Bi = here->pParam->B2bi0 + here->pParam->B2biB * Vbs;
357  T5 = Bi / (Vds - Vdsat);
358  T5 = MIN(T5, 30.0);
359  T6 = exp(-T5);
360  FR = 1.0 + Ai * T6;
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
366  * here->pParam->B2biB / (Vds - Vdsat));
367  }
368  else
369  { FR = 1.0;
370  dFR_dVd = 0.0;
371  dFR_dVg = 0.0;
372  dFR_dVb = 0.0;
373  }
374 
375  *gds = (T2 * dBeta_dVd + T3 * (here->pParam->B2vofD * T4 - dVth_dVd
376  - here->pParam->B2nD * Vgst / n) + Beta * model->B2Vtm
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
381  + *Ids * dFR_dVb;
382  *Ids *= FR;
383  }
384  }
385  else
386  { *Ids = 0.0;
387  *gm = 0.0;
388  *gds = 0.0;
389  *gmb = 0.0;
390  }
391 
392 
393 ChargeComputation:
394 
395  /* Some Limiting of DC Parameters */
396  *gds = MAX(*gds,1.0e-20);
397 
398 
399  if ((model->B2channelChargePartitionFlag > 1)
400  || ((!ChargeComputationNeeded) &&
401  (model->B2channelChargePartitionFlag > -5)))
402  {
403  *qg = 0.0;
404  *qd = 0.0;
405  *qb = 0.0;
406  *cgg = 0.0;
407  *cgs = 0.0;
408  *cgd = 0.0;
409  *cdg = 0.0;
410  *cds = 0.0;
411  *cdd = 0.0;
412  *cbg = 0.0;
413  *cbs = 0.0;
414  *cbd = 0.0;
415  goto finished;
416  }
417  else
418  {
419  if (Vbs < 0.0)
420  { Vbseff = Vbs;
421  dVbseff_dVb = 1.0;
422  }
423  else
424  { Vbseff = here->pParam->B2phi - Phisb;
425  dVbseff_dVb = -dPhisb_dVb;
426  }
427  Arg1 = Vgs - Vbseff - here->pParam->B2vfb;
428  Arg2 = Arg1 - Vgst;
429  Qbulk = here->pParam->One_Third_CoxWL * Arg2;
430  dQbulk_dVb = here->pParam->One_Third_CoxWL * (dVth_dVb - dVbseff_dVb);
431  dQbulk_dVd = here->pParam->One_Third_CoxWL * dVth_dVd;
432  if (Arg1 <= 0.0)
433  {
434  *qg = here->pParam->CoxWL * Arg1;
435  *qb = -(*qg);
436  *qd = 0.0;
437 
438  *cgg = here->pParam->CoxWL;
439  *cgd = 0.0;
440  *cgs = -*cgg * (1.0 - dVbseff_dVb);
441 
442  *cdg = 0.0;
443  *cdd = 0.0;
444  *cds = 0.0;
445 
446  *cbg = -here->pParam->CoxWL;
447  *cbd = 0.0;
448  *cbs = -*cgs;
449  }
450  else if (Vgst <= 0.0)
451  { T2 = Arg1 / Arg2;
452  T3 = T2 * T2 * (here->pParam->CoxWL - here->pParam->Two_Third_CoxWL
453  * T2);
454 
455  *qg = here->pParam->CoxWL * Arg1 * (1.0 - T2 * (1.0 - T2 / 3.0));
456  *qb = -(*qg);
457  *qd = 0.0;
458 
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);
463 
464  *cdg = 0.0;
465  *cdd = 0.0;
466  *cds = 0.0;
467 
468  *cbg = -*cgg;
469  *cbd = -*cgd;
470  *cbs = -*cgs;
471  }
472  else
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
480  * (here->pParam->B2uaB + Vgst * here->pParam->B2ubB);
481 
482  T8 = U1s * Inv_Aa * Inv_Uvert;
483  Vc = T8 * Vgst;
484  T9 = Vc * 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;
489 
490  tmp2 = sqrt(1.0 + 2.0 * Vc);
491  Kk = 0.5 * (1.0 + Vc + tmp2);
492  Inv_Kk = 1.0 / Kk;
493  dKk_dVc = 0.5 + 0.5 / tmp2;
494  SqrtKk = sqrt(Kk);
495 
496  T8 = Inv_Aa / SqrtKk;
497  Vdsat = Vgst * T8;
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;
503  }
504  if (Vds >= Vdsat)
505  { /* saturation region */
506  *cgg = here->pParam->Two_Third_CoxWL;
507  *cgd = -*cgg * dVth_dVd + dQbulk_dVd;
508  tmp = -*cgg * dVth_dVb + dQbulk_dVb;
509  *cgs = -(*cgg + *cgd + tmp);
510 
511  *cbg = 0.0;
512  *cbd = -dQbulk_dVd;
513  *cbs = dQbulk_dVd + dQbulk_dVb;
514 
515  *cdg = -0.4 * *cgg;
516  tmp = -*cdg * dVth_dVb;
517  *cdd = -*cdg * dVth_dVd;
518  *cds = -(*cdg + *cdd + tmp);
519 
520  *qb = -Qbulk;
521  *qg = here->pParam->Two_Third_CoxWL * Vgst + Qbulk;
522  *qd = *cdg * Vgst;
523  }
524  else
525  { /* linear region */
526  T7 = Vds / Vdsat;
527  T8 = Vgst / Vdsat;
528  T6 = T7 * T8;
529  T9 = 1.0 - T7;
530  Vgdt = Vgst * T9;
531  T0 = Vgst / (Vgst + Vgdt);
532  T1 = Vgdt / (Vgst + Vgdt);
533  T5 = T0 * T1;
534  T2 = 1.0 - T1 + T5;
535  T3 = 1.0 - T0 + T5;
536 
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;
540 
541  *qg = here->pParam->Two_Third_CoxWL * (Vgst + Vgdt
542  - Vgdt * T0) + Qbulk;
543  *qb = -Qbulk;
544  *qd = -here->pParam->One_Third_CoxWL * (0.2 * Vgdt
545  + 0.8 * Vgst + Vgdt * T1
546  + 0.2 * T5 * (Vgdt - Vgst));
547 
548  *cgg = here->pParam->Two_Third_CoxWL * (T2 + T3 * dVgdt_dVg);
549  tmp = dQbulk_dVb + here->pParam->Two_Third_CoxWL * (T3 * dVgdt_dVb
550  - T2 * dVth_dVb);
551  *cgd = here->pParam->Two_Third_CoxWL * (T3 * dVgdt_dVd
552  - T2 * dVth_dVd) + dQbulk_dVd;
553  *cgs = -(*cgg + *cgd + tmp);
554 
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));
557  *cdg = -here->pParam->One_Third_CoxWL * (T2 + T3 * dVgdt_dVg);
558  tmp = here->pParam->One_Third_CoxWL * (T2 * dVth_dVb
559  - T3 * dVgdt_dVb);
560  *cdd = here->pParam->One_Third_CoxWL * (T2 * dVth_dVd
561  - T3 * dVgdt_dVd);
562  *cds = -(*cdg + tmp + *cdd);
563 
564  *cbg = 0.0;
565  *cbd = -dQbulk_dVd;
566  *cbs = dQbulk_dVd + dQbulk_dVb;
567  }
568  }
569  }
570 
571 finished: /* returning Values to Calling Routine */
572  valuetypeflag = (int) model->B2channelChargePartitionFlag;
573  switch (valuetypeflag)
574  {
575  case 0: *Ids = MAX(*Ids,1e-50);
576  break;
577  case -1: *Ids = MAX(*Ids,1e-50);
578  break;
579  case -2: *Ids = *gm;
580  break;
581  case -3: *Ids = *gds;
582  break;
583  case -4: *Ids = 1.0 / *gds;
584  break;
585  case -5: *Ids = *gmb;
586  break;
587  case -6: *Ids = *qg / 1.0e-12;
588  break;
589  case -7: *Ids = *qb / 1.0e-12;
590  break;
591  case -8: *Ids = *qd / 1.0e-12;
592  break;
593  case -9: *Ids = -(*qb + *qg + *qd) / 1.0e-12;
594  break;
595  case -10: *Ids = *cgg / 1.0e-12;
596  break;
597  case -11: *Ids = *cgd / 1.0e-12;
598  break;
599  case -12: *Ids = *cgs / 1.0e-12;
600  break;
601  case -13: *Ids = -(*cgg + *cgd + *cgs) / 1.0e-12;
602  break;
603  case -14: *Ids = *cbg / 1.0e-12;
604  break;
605  case -15: *Ids = *cbd / 1.0e-12;
606  break;
607  case -16: *Ids = *cbs / 1.0e-12;
608  break;
609  case -17: *Ids = -(*cbg + *cbd + *cbs) / 1.0e-12;
610  break;
611  case -18: *Ids = *cdg / 1.0e-12;
612  break;
613  case -19: *Ids = *cdd / 1.0e-12;
614  break;
615  case -20: *Ids = *cds / 1.0e-12;
616  break;
617  case -21: *Ids = -(*cdg + *cdd + *cds) / 1.0e-12;
618  break;
619  case -22: *Ids = -(*cgg + *cdg + *cbg) / 1.0e-12;
620  break;
621  case -23: *Ids = -(*cgd + *cdd + *cbd) / 1.0e-12;
622  break;
623  case -24: *Ids = -(*cgs + *cds + *cbs) / 1.0e-12;
624  break;
625  default: *Ids = MAX(*Ids, 1.0e-50);
626  break;
627  }
628  *von = Vth;
629  *vdsat = Vdsat;
630 }
double B2vbb2
Definition: bsim2def.h:354
#define MODEAC
Definition: cktdefs.h:146
#define MODETRAN
Definition: cktdefs.h:145
#define MAX(a, b)
Definition: spdefs.h:135
#define MIN(a, b)
Definition: spdefs.h:136
static double e
Definition: vectors.c:17
double B2Vtm
Definition: bsim2def.h:359
double Two_Third_CoxWL
Definition: bsim2def.h:213
double B2vgg2
Definition: bsim2def.h:352
double One_Third_CoxWL
Definition: bsim2def.h:212
double B2vdd2
Definition: bsim2def.h:350
#define MODEINITSMSIG
Definition: cktdefs.h:159
#define MODETRANOP
Definition: cktdefs.h:151
struct bsim2SizeDependParam * pParam
Definition: bsim2def.h:50
double B2channelChargePartitionFlag
Definition: bsim2def.h:358
double B2vdd
Definition: bsim2def.h:349
long CKTmode
Definition: cktdefs.h:139
#define MODEUIC
Definition: cktdefs.h:166