Jspice3
b1dset.c
Go to the documentation of this file.
1 /***************************************************************************
2 JSPICE3 adaptation of Spice3f2 - Copyright (c) Stephen R. Whiteley 1992
3 Copyright 1990 Regents of the University of California. All rights reserved.
4 Authors: 1985 Hong J. Park, Thomas L. Quarles
5  1993 Stephen R. Whiteley
6 ****************************************************************************/
7 
8 #include "spice.h"
9 #include <stdio.h>
10 #include <math.h>
11 #include "bsim1def.h"
12 #include "distodef.h"
13 #include "const.h"
14 #include "sperror.h"
15 #include "util.h"
16 #include "distoext.h"
17 
18 int
19 B1dSetup(inModel,ckt)
20 
21  GENmodel *inModel;
22  register CKTcircuit *ckt;
23 
24 {
25  register B1model* model = (B1model*)inModel;
26  register B1instance *here;
27  double DrainSatCurrent;
28  double EffectiveLength;
29  double GateBulkOverlapCap;
30  double GateDrainOverlapCap;
31  double GateSourceOverlapCap;
32  double SourceSatCurrent;
33  double DrainArea;
34  double SourceArea;
35  double DrainPerimeter;
36  double SourcePerimeter;
37  double vt0;
38  double evbs;
39  double lgbs1, lgbs2, lgbs3;
40  double czbd, czbs, czbdsw, czbssw;
41  double PhiB, MJ, MJSW, PhiBSW;
42  double arg, argsw, sarg, sargsw;
43  double capbs1, capbs2, capbs3;
44  double capbd1, capbd2, capbd3;
45  double qg;
46  double qb;
47  double qd;
48  double Vfb;
49  double Phi;
50  double K1;
51  double K2;
52  double Vdd;
53  double Ugs;
54  double Uds;
55  double Leff;
56  double Eta;
57  double Vpb;
58  double SqrtVpb;
59  double Von;
60  double Vth;
61  double DrCur;
62  double G;
63  double A;
64  double Arg;
65  double Beta;
66  double Beta_Vds_0;
67  double BVdd;
68  double Beta0;
69  double VddSquare;
70  double C1;
71  double C2;
72  double VdsSat;
73  double Argl1;
74  double Argl2;
75  double Vc;
76  double Term1;
77  double K;
78  double Args1;
79  double Args2;
80  double Args3;
81  double Warg1;
82  double Vcut;
83  double N;
84  double N0;
85  double NB;
86  double ND;
87  double Warg2;
88  double Wds;
89  double Wgs;
90  double Ilimit;
91  double Iexp;
92  double Vth0;
93  double Arg1;
94  double Arg2;
95  double Arg3;
96  double Arg5;
97  double Ent;
98  double Vcom;
99  double Vgb;
100  double Vgb_Vfb;
101  double VdsPinchoff;
102  double EntSquare;
103  double VgsVthSquare;
104  double Argl5;
105  double Argl6;
106  double Argl7;
107  double WLCox;
108  double Vtsquare;
109  int ChargeComputationNeeded;
110  double co4v15;
111 double VgsVth = 0.0;
112 double lgbd1, lgbd2, lgbd3, evbd;
113 double vbd = 0.0;
114 double vgd = 0.0;
115 double vgb = 0.0;
116 double vds = 0.0;
117 double vgs = 0.0;
118  double vbs = 0.0;
119  double dBVdddVds;
120  Dderivs d_Argl6;
121  Dderivs d_Vgb, d_Vgb_Vfb, d_EntSquare, d_Argl5, d_Argl7;
122  Dderivs d_Arg5, d_Ent, d_Vcom, d_VdsPinchoff;
123  Dderivs d_qb, d_qd, d_Vth0, d_Arg1, d_Arg2, d_Arg3;
124  Dderivs d_dummy, d_Vth, d_BVdd, d_Warg1, d_qg;
125  Dderivs d_N, d_Wds, d_Wgs, d_Iexp;
126  Dderivs d_Argl1, d_Argl2, d_Args1, d_Args2, d_Args3;
127  Dderivs d_Beta, d_Vc, d_Term1, d_K, d_VdsSat;
128  Dderivs d_Beta_Vds_0, d_C1, d_C2, d_Beta0;
129  Dderivs d_VgsVth, d_G, d_A, d_Arg, d_DrCur;
130  Dderivs d_Ugs, d_Uds, d_Eta, d_Vpb, d_SqrtVpb, d_Von;
131  Dderivs d_p, d_q, d_r, d_zero;
132 
133 
134  /* loop through all the B1 device models */
135  for( ; model != NULL; model = model->B1nextModel ) {
136 
137  /* loop through all the instances of the model */
138  for (here = model->B1instances; here != NULL ;
139  here=here->B1nextInstance) {
140  EffectiveLength=here->B1l - model->B1deltaL * 1.e-6;/* m */
141  DrainArea = here->B1drainArea;
142  SourceArea = here->B1sourceArea;
143  DrainPerimeter = here->B1drainPerimeter;
144  SourcePerimeter = here->B1sourcePerimeter;
145  if( (DrainSatCurrent=DrainArea*model->B1jctSatCurDensity)
146  < 1e-15){
147  DrainSatCurrent = 1.0e-15;
148  }
149  if( (SourceSatCurrent=SourceArea*model->B1jctSatCurDensity)
150  <1.0e-15){
151  SourceSatCurrent = 1.0e-15;
152  }
153  GateSourceOverlapCap = model->B1gateSourceOverlapCap *here->B1w;
154  GateDrainOverlapCap = model->B1gateDrainOverlapCap * here->B1w;
155  GateBulkOverlapCap = model->B1gateBulkOverlapCap *EffectiveLength;
156  vt0 = model->B1type * here->B1vt0;
157 
158  vbs = model->B1type * (
159  *(ckt->CKTrhsOld+here->B1bNode) -
160  *(ckt->CKTrhsOld+here->B1sNodePrime));
161  vgs = model->B1type * (
162  *(ckt->CKTrhsOld+here->B1gNode) -
163  *(ckt->CKTrhsOld+here->B1sNodePrime));
164  vds = model->B1type * (
165  *(ckt->CKTrhsOld+here->B1dNodePrime) -
166  *(ckt->CKTrhsOld+here->B1sNodePrime));
167 
168  if(vds >= 0) {
169  /* normal mode */
170  here->B1mode = 1;
171  } else {
172  /* inverse mode */
173  here->B1mode = -1;
174  vds = -vds;
175  vgs = vgs + vds; /* these are the local(fake) values now */
176  vbs = vbs + vds;
177  }
178 
179  vgb = vgs - vbs;
180  vgd = vgs - vds;
181  vbd = vbs - vds;
182 
183  if(vbs <= 0.0 ) {
184  lgbs1 = SourceSatCurrent / CONSTvt0 + ckt->CKTgmin;
185  lgbs2 = lgbs3 = 0.0;
186  } else {
187  evbs = exp(vbs/CONSTvt0);
188  lgbs1 = SourceSatCurrent*evbs/CONSTvt0 + ckt->CKTgmin;
189  lgbs2 = (lgbs1 - ckt->CKTgmin)/(CONSTvt0*2);
190  lgbs3 = lgbs2/(CONSTvt0*3);
191  }
192  if(vbd <= 0.0) {
193  lgbd1 = DrainSatCurrent / CONSTvt0 + ckt->CKTgmin;
194  lgbd2 = lgbd3 = 0.0;
195  } else {
196  evbd = exp(vbd/CONSTvt0);
197  lgbd1 = DrainSatCurrent*evbd/CONSTvt0 +ckt->CKTgmin;
198  lgbd2 = (lgbd1 - ckt->CKTgmin)/(CONSTvt0*2);
199  lgbd3 = lgbd2/(CONSTvt0*3);
200  }
201  /* line 400 */
202  /* call B1evaluate to calculate drain current and its
203  * derivatives and charge and capacitances related to gate
204  * drain, and bulk
205  */
206 
207 /* check quadratic interpolation for beta0 ; line 360 */
208 /*
209  * Copyright (c) 1985 Hong J. Park, Thomas L. Quarles
210  * modified 1988 Jaijeet Roychowdhury
211  */
212 
213 /* This routine evaluates the drain current, its derivatives and the
214  * charges associated with the gate,bulk and drain terminal
215  * using the BSIM1 (Berkeley Short-Channel IGFET Model) Equations.
216  */
217  /* as usual p=vgs, q=vbs, r=vds */
218  {
219 
220  ChargeComputationNeeded = 1;
221 
222  Vfb = here->B1vfb;
223  Phi = here->B1phi;
224  K1 = here->B1K1;
225  K2 = here->B1K2;
226  Vdd = model->B1vdd;
227 d_p.value = 0.0;
228 d_p.d1_p = 1.0;
229 d_p.d1_q = 0.0;
230 d_p.d1_r = 0.0;
231 d_p.d2_p2 = 0.0;
232 d_p.d2_q2 = 0.0;
233 d_p.d2_r2 = 0.0;
234 d_p.d2_pq = 0.0;
235 d_p.d2_qr = 0.0;
236 d_p.d2_pr = 0.0;
237 d_p.d3_p3 = 0.0;
238 d_p.d3_q3 = 0.0;
239 d_p.d3_r3 = 0.0;
240 d_p.d3_p2r = 0.0;
241 d_p.d3_p2q = 0.0;
242 d_p.d3_q2r = 0.0;
243 d_p.d3_pq2 = 0.0;
244 d_p.d3_pr2 = 0.0;
245 d_p.d3_qr2 = 0.0;
246 d_p.d3_pqr = 0.0;
247  EqualDeriv(&d_q,&d_p);
248  EqualDeriv(&d_r,&d_p);
249  EqualDeriv(&d_zero,&d_p);
250  d_q.d1_p = d_r.d1_p = d_zero.d1_p = 0.0;
251  d_q.d1_q = d_r.d1_r = 1.0;
252  d_p.value = vgs; d_q.value = vbs; d_r.value = vds;
253 
254  if((Ugs = here->B1ugs + here->B1ugsB * vbs) <= 0 ) {
255  Ugs = 0;
256  EqualDeriv(&d_Ugs,&d_zero);
257  } else {
258  EqualDeriv(&d_Ugs,&d_q);
259  d_Ugs.value = Ugs;
260  d_Ugs.d1_q = here->B1ugsB;
261  }
262  if((Uds = here->B1uds + here->B1udsB * vbs +
263  here->B1udsD*(vds-Vdd)) <= 0 ) {
264  Uds = 0.0;
265  EqualDeriv(&d_Uds,&d_zero);
266  } else {
267  Leff = here->B1l * 1.e6 - model->B1deltaL; /* Leff in um */
268  /*const*/
269  Uds = Uds / Leff;
270  /* Uds = (here->B1uds + here->B1udsB * vbs here->B1udsD*
271  (vds-Vdd))/Leff */
272  EqualDeriv(&d_Uds,&d_r);
273  d_Uds.value = Uds;
274  d_Uds.d1_r = here->B1udsD/Leff;
275  d_Uds.d1_q = here->B1udsB/Leff;
276  }
277  Eta = here->B1eta + here->B1etaB * vbs + here->B1etaD *
278  (vds - Vdd);
279  EqualDeriv(&d_Eta,&d_r);
280  d_Eta.value = Eta;
281  d_Eta.d1_r = here->B1etaD;
282  d_Eta.d1_q = here->B1etaB;
283 
284  if( Eta <= 0 ) {
285  Eta = 0;
286  EqualDeriv(&d_Eta,&d_zero);
287  } else if ( Eta > 1 ) {
288  Eta = 1;
289  EqualDeriv(&d_Eta,&d_zero);
290  d_Eta.value = 1.0;
291  }
292  if( vbs < 0 ) {
293  Vpb = Phi - vbs;
294  EqualDeriv(&d_Vpb,&d_q);
295  d_Vpb.value = Vpb;
296  d_Vpb.d1_q = -1;
297  } else {
298  Vpb = Phi;
299  EqualDeriv(&d_Vpb,&d_zero);
300  d_Vpb.value = Phi;
301  }
302  SqrtVpb = sqrt( Vpb );
303  SqrtDeriv(&d_SqrtVpb,&d_Vpb);
304  Von = Vfb + Phi + K1 * SqrtVpb - K2 * Vpb - Eta * vds;
305  EqualDeriv(&d_dummy,&d_r);
306  d_dummy.value = -Eta*vds;
307  d_dummy.d1_r = -Eta;
308  TimesDeriv(&d_Von,&d_Vpb,-K2);
309  PlusDeriv(&d_Von,&d_Von,&d_dummy);
310  TimesDeriv(&d_dummy,&d_SqrtVpb,K1);
311  PlusDeriv(&d_Von,&d_dummy,&d_Von);
312  d_Von.value = Von;
313  Vth = Von;
314  EqualDeriv(&d_Vth,&d_Von);
315  VgsVth = vgs - Vth;
316  TimesDeriv(&d_VgsVth,&d_Vth,-1.0);
317  d_VgsVth.value = VgsVth;
318  d_VgsVth.d1_p += 1.0;
319 
320  G = 1./(1.744+0.8364 * Vpb);
321  TimesDeriv(&d_G,&d_Vpb,0.8364);
322  d_G.value += 1.744;
323  InvDeriv(&d_G,&d_G);
324  G = 1 - G;
325  TimesDeriv(&d_G,&d_G,-1.0);
326  d_G.value += 1.0;
327  A = G/SqrtVpb;
328  DivDeriv(&d_A,&d_G,&d_SqrtVpb);
329  A = 1.0 + 0.5*K1*A;
330  TimesDeriv(&d_A,&d_A,0.5*K1);
331  d_A.value += 1.0;
332  A = MAX( A, 1.0); /* Modified */
333  if (A <= 1.0) {
334  EqualDeriv(&d_A,&d_zero);
335  d_A.value = 1.0;
336  }
337  Arg = MAX(( 1 + Ugs * VgsVth), 1.0);
338  MultDeriv(&d_dummy,&d_Ugs,&d_VgsVth);
339  d_dummy.value += 1.0;
340  if (d_dummy.value <= 1.0) {
341  EqualDeriv(&d_Arg,&d_zero);
342  d_Arg.value = 1.0;
343  }
344  else
345  EqualDeriv(&d_Arg,&d_dummy);
346 
347  if( VgsVth < 0 ) {
348  /* cutoff */
349  DrCur = 0;
350  EqualDeriv(&d_DrCur,&d_zero);
351  goto SubthresholdComputation;
352  }
353 
354  /* Quadratic Interpolation for Beta0 (Beta at vgs = 0, vds=Vds) */
355 
356  Beta_Vds_0 = (here->B1betaZero + here->B1betaZeroB * vbs);
357  EqualDeriv(&d_Beta_Vds_0,&d_q);
358  d_Beta_Vds_0.value = Beta_Vds_0;
359  d_Beta_Vds_0.d1_q = here->B1betaZeroB;
360  BVdd = (here->B1betaVdd + here->B1betaVddB * vbs);
361  EqualDeriv(&d_BVdd,&d_q);
362  d_BVdd.value = BVdd;
363  d_BVdd.d1_q = here->B1betaVddB;
364  dBVdddVds = MAX( here->B1betaVddD, 0.0);
365 
366 
367  /* is the above wrong ?!? */
368 
369 
370 
371  if( vds > Vdd ) {
372  Beta0 = BVdd + dBVdddVds * (vds - Vdd);
373  EqualDeriv(&d_Beta0,&d_r); d_Beta0.value = vds - Vdd;
374  TimesDeriv(&d_Beta0,&d_Beta0,dBVdddVds);
375  PlusDeriv(&d_Beta0,&d_Beta0,&d_BVdd);
376  /* dBVdddVds = const */
377 
378 
379  /* and this stuff here? */
380 
381  } else {
382  VddSquare = Vdd * Vdd; /* const */
383  C1 = ( -BVdd + Beta_Vds_0 + dBVdddVds * Vdd) / VddSquare;
384  TimesDeriv(&d_C1,&d_BVdd,-1.0);
385  PlusDeriv(&d_C1,&d_C1,&d_Beta_Vds_0);
386  d_C1.value += dBVdddVds * Vdd;
387  TimesDeriv(&d_C1,&d_C1,1/VddSquare);
388 
389  C2 = 2 * (BVdd - Beta_Vds_0) / Vdd - dBVdddVds;
390  TimesDeriv(&d_C2,&d_Beta_Vds_0,-1.0);
391  PlusDeriv(&d_C2,&d_C2,&d_BVdd);
392  TimesDeriv(&d_C2,&d_C2,2/Vdd);
393  d_C2.value -= dBVdddVds;
394  Beta0 = (C1 * vds + C2) * vds + Beta_Vds_0;
395  MultDeriv(&d_Beta0,&d_r,&d_C1);
396  PlusDeriv(&d_Beta0,&d_Beta0,&d_C2);
397  MultDeriv(&d_Beta0,&d_Beta0,&d_dummy);
398  PlusDeriv(&d_Beta0,&d_Beta0,&d_Beta_Vds_0);
399 
400  /*
401  dBeta0dVds = 2*C1*vds + C2;
402  dBeta0dVbs = dC1dVbs * vds * vds + dC2dVbs * vds + dBeta_Vds_0_dVbs;
403  maybe we'll need these later */
404  }
405 
406  /*Beta = Beta0 / ( 1 + Ugs * VgsVth );*/
407 
408  Beta = Beta0 / Arg ;
409  DivDeriv(&d_Beta,&d_Beta0,&d_Arg);
410 
411  /*VdsSat = MAX( VgsVth / ( A + Uds * VgsVth ), 0.0);*/
412 
413  Vc = Uds * VgsVth / A;
414  DivDeriv(&d_Vc,&d_VgsVth,&d_A);
415  MultDeriv(&d_Vc,&d_Vc,&d_Uds);
416 
417  if(Vc < 0.0 ) {
418  EqualDeriv(&d_Vc,&d_zero);
419  Vc=0.0;
420  }
421  Term1 = sqrt( 1 + 2 * Vc );
422  TimesDeriv(&d_Term1,&d_Vc,2.0);
423  d_Term1.value += 1.0;
424  SqrtDeriv(&d_Term1,&d_Term1);
425  K = 0.5 * ( 1 + Vc + Term1 );
426  PlusDeriv(&d_K,&d_Vc,&d_Term1);
427  d_K.value += 1.0;
428  TimesDeriv(&d_K,&d_K,0.5);
429  VdsSat = VgsVth / ( A * sqrt(K));
430  if (VdsSat < 0.0) {
431  EqualDeriv(&d_VdsSat,&d_zero);
432  VdsSat = 0.0;
433  }
434  else
435  {
436  SqrtDeriv(&d_VdsSat,&d_K);
437  MultDeriv(&d_VdsSat,&d_VdsSat,&d_A);
438  DivDeriv(&d_VdsSat,&d_VgsVth,&d_VdsSat);
439  }
440 
441  if( vds < VdsSat ) {
442  /* Triode Region */
443  /*Argl1 = 1 + Uds * vds;*/
444  Argl1 = 1 + Uds * vds;
445  if (Argl1 < 1.0) {
446  Argl1 = 1.0;
447  EqualDeriv(&d_Argl1,&d_zero);
448  d_Argl1.value = 1.0;
449  }
450  else
451  {
452  MultDeriv(&d_Argl1,&d_r,&d_Uds);
453  d_Argl1.value += 1.0;
454  }
455 
456 
457  Argl2 = VgsVth - 0.5 * A * vds;
458  MultDeriv(&d_Argl2,&d_r,&d_A);
459  TimesDeriv(&d_Argl2,&d_Argl2,-0.5);
460  PlusDeriv(&d_Argl2,&d_Argl2,&d_VgsVth);
461  DrCur = Beta * Argl2 * vds / Argl1;
462  DivDeriv(&d_DrCur,&d_r,&d_Argl1);
463  MultDeriv(&d_DrCur,&d_DrCur,&d_Argl2);
464  MultDeriv(&d_DrCur,&d_DrCur,&d_Beta);
465  } else {
466  /* Pinchoff (Saturation) Region */
467  /* history
468  Args1 = 1.0 + 1. / Term1;
469  InvDeriv(&d_Args1,&d_Term1);
470  d_Args1.value += 1.0;
471  */
472  /* dVcdVgs = Uds / A;
473  dVcdVds = VgsVth * dUdsdVds / A - dVcdVgs * dVthdVds;
474  dVcdVbs = ( VgsVth * dUdsdVbs - Uds *
475  (dVthdVbs + VgsVth * dAdVbs / A ))/ A;
476  dKdVc = 0.5* Args1;
477  dKdVgs = dKdVc * dVcdVgs;
478  dKdVds = dKdVc * dVcdVds;
479  dKdVbs = dKdVc * dVcdVbs; */
480  Args2 = VgsVth / A / K;
481  MultDeriv(&d_Args2,&d_A,&d_K);
482  DivDeriv(&d_Args2,&d_VgsVth,&d_Args2);
483  Args3 = Args2 * VgsVth;
484  MultDeriv(&d_Args3,&d_Args2,&d_VgsVth);
485  DrCur = 0.5 * Beta * Args3;
486  MultDeriv(&d_DrCur,&d_Beta,&d_Args3);
487  TimesDeriv(&d_DrCur,&d_DrCur,0.5);
488  }
489 
490 SubthresholdComputation:
491 
492  N0 = here->B1subthSlope;/*const*/
493  Vcut = - 40. * N0 * CONSTvt0 ;/*const*/
494  if( (N0 >= 200) || (VgsVth < Vcut ) || (VgsVth > (-0.5*Vcut))) {
495  goto ChargeComputation;
496  }
497 
498  NB = here->B1subthSlopeB;/*const*/
499  ND = here->B1subthSlopeD;/*const*/
500  N = N0 + NB * vbs + ND * vds; /* subthreshold slope */
501  EqualDeriv(&d_N,&d_r);
502  d_N.value = N;
503  d_N.d1_q = NB;
504  d_N.d1_r = ND;
505  if( N < 0.5 ){ N = 0.5;
506  d_N.value = 0.5;
507  d_N.d1_q = d_N.d1_r = 0.0;
508  }
509  Warg1 = exp( - vds / CONSTvt0 );
510  TimesDeriv(&d_Warg1,&d_r,-1/CONSTvt0);
511  ExpDeriv(&d_Warg1,&d_Warg1);
512  Wds = 1 - Warg1;
513  TimesDeriv(&d_Wds,&d_Warg1,-1.0);
514  d_Wds.value += 1.0;
515  Wgs = exp( VgsVth / ( N * CONSTvt0 ));
516  DivDeriv(&d_Wgs,&d_VgsVth,&d_N);
517  TimesDeriv(&d_Wgs,&d_Wgs,1/CONSTvt0);
518  ExpDeriv(&d_Wgs,&d_Wgs);
519  Vtsquare = CONSTvt0 * CONSTvt0 ;/*const*/
520  Warg2 = 6.04965 * Vtsquare * here->B1betaZero;/*const*/
521  Ilimit = 4.5 * Vtsquare * here->B1betaZero;/*const*/
522  Iexp = Warg2 * Wgs * Wds;
523  MultDeriv(&d_Iexp,&d_Wgs,&d_Wds);
524  TimesDeriv(&d_Iexp,&d_Iexp,Warg2);
525  DrCur = DrCur + Ilimit * Iexp / ( Ilimit + Iexp );
526  EqualDeriv(&d_dummy,&d_Iexp);
527  d_dummy.value += Ilimit;
528  InvDeriv(&d_dummy,&d_dummy);
529  MultDeriv(&d_dummy,&d_dummy,&d_Iexp);
530  TimesDeriv(&d_dummy,&d_dummy,Ilimit);
531  PlusDeriv(&d_DrCur,&d_DrCur,&d_dummy);
532 
533  /* gds term has been modified to prevent blow up at Vds=0 */
534  /* gds = gds + Temp3 * ( -Wds / N / CONSTvt0 * (dVthdVds +
535  VgsVth * ND / N ) + Warg1 / CONSTvt0 ); */
536 
537 ChargeComputation:
538 
539  /* Some Limiting of DC Parameters */
540 /* if(DrCur < 0.0) DrCur = 0.0;
541  if(gm < 0.0) gm = 0.0;
542  if(gds < 0.0) gds = 0.0;
543  if(gmbs < 0.0) gmbs = 0.0;
544  */
545 
546  WLCox = model->B1Cox *
547  (here->B1l - model->B1deltaL * 1.e-6) *
548  (here->B1w - model->B1deltaW * 1.e-6) * 1.e4; /* F */
549 
550  if( ! ChargeComputationNeeded ) {
551  qg = 0;
552  qd = 0;
553  qb = 0;
554  EqualDeriv(&d_qg,&d_zero);
555  EqualDeriv(&d_qb,&d_zero);
556  EqualDeriv(&d_qd,&d_zero);
557  goto finished;
558  }
559  G = 1.0 - 1./(1.744+0.8364 * Vpb);
560  TimesDeriv(&d_G,&d_Vpb,-0.8364);
561  d_G.value -= 1.744;
562  InvDeriv(&d_G,&d_G);
563  d_G.value += 1.0;
564 
565  A = 1.0 + 0.5*K1*G/SqrtVpb;
566  if (A < 1.0) {
567  A = 1.0;
568  EqualDeriv(&d_A,&d_zero);
569  d_A.value = 1.0;
570  }
571  else
572  {
573  DivDeriv(&d_A,&d_G,&d_SqrtVpb);
574  TimesDeriv(&d_A,&d_A,0.5*K1);
575  d_A.value += 1.0;
576  }
577 
578  /*Arg = 1 + Ugs * VgsVth;*/
579  Phi = MAX( 0.1, Phi);/*const*/
580 
581  if( model->B1channelChargePartitionFlag >= 1 ) {
582 
583 /*0/100 partitioning for drain/source chArges at the saturation region*/
584  Vth0 = Vfb + Phi + K1 * SqrtVpb;
585  TimesDeriv(&d_Vth0,&d_SqrtVpb,K1);
586  d_Vth0.value += Vfb + Phi;
587  VgsVth = vgs - Vth0;
588  TimesDeriv(&d_VgsVth,&d_Vth0,-1.0);
589  PlusDeriv(&d_VgsVth,&d_VgsVth,&d_p);
590  Arg1 = A * vds;
591  MultDeriv(&d_Arg1,&d_A,&d_r);
592  Arg2 = VgsVth - 0.5 * Arg1;
593  TimesDeriv(&d_Arg2,&d_Arg1,-0.5);
594  PlusDeriv(&d_Arg2,&d_Arg2,&d_VgsVth);
595  Arg3 = vds - Arg1;
596  TimesDeriv(&d_Arg3,&d_Arg1,-1.0);
597  PlusDeriv(&d_Arg3,&d_Arg3,&d_r);
598  Arg5 = Arg1 * Arg1;
599  MultDeriv(&d_Arg5,&d_Arg1,&d_Arg1);
600 
601  Ent = MAX(Arg2,1.0e-8);
602  if (Arg2 < 1.0e-8) {
603  EqualDeriv(&d_Ent,&d_zero);
604  d_Ent.value = 1.0e-8;
605  }
606  else
607  {
608  EqualDeriv(&d_Ent,&d_Arg2);
609  }
610 
611  Vcom = VgsVth * VgsVth / 6.0 - 1.25e-1 * Arg1 *
612  VgsVth + 2.5e-2 * Arg5;
613  TimesDeriv(&d_dummy,&d_Arg1,-0.125);
614  TimesDeriv(&d_Vcom,&d_VgsVth,1/6.0);
615  PlusDeriv(&d_Vcom,&d_Vcom,&d_dummy);
616  MultDeriv(&d_Vcom,&d_Vcom,&d_VgsVth);
617  TimesDeriv(&d_dummy,&d_Arg5,2.5e-2);
618  PlusDeriv(&d_Vcom,&d_Vcom,&d_dummy);
619  VdsPinchoff = VgsVth / A;
620  if (VdsPinchoff < 0.0) {
621  VdsPinchoff = 0.0;
622  EqualDeriv(&d_VdsPinchoff,&d_zero);
623  }
624  else
625  {
626  DivDeriv(&d_VdsPinchoff,&d_VgsVth,&d_A);
627  }
628  Vgb = vgs - vbs ;
629  EqualDeriv(&d_Vgb,&d_p);
630  d_Vgb.value = Vgb;
631  d_Vgb.d1_q = -1.0;
632  Vgb_Vfb = Vgb - Vfb;
633  EqualDeriv(&d_Vgb_Vfb,&d_Vgb);
634  d_Vgb_Vfb.value -= Vfb;
635 
636  if( Vgb_Vfb < 0){
637  /* Accumulation Region */
638  qg = WLCox * Vgb_Vfb;
639  TimesDeriv(&d_qg,&d_Vgb_Vfb,WLCox);
640  qb = - qg;
641  TimesDeriv(&d_qb,&d_qg,-1.0);
642  qd = 0. ;
643  EqualDeriv(&d_qd,&d_zero);
644  goto finished;
645  } else if ( vgs < Vth0 ){
646  /* Subthreshold Region */
647  qg = 0.5 * WLCox * K1 * K1 * (-1 +
648  sqrt(1 + 4 * Vgb_Vfb / (K1 * K1)));
649  TimesDeriv(&d_qg,&d_Vgb_Vfb,4/(K1*K1));
650  d_qg.value += 1.0;
651  SqrtDeriv(&d_qg,&d_qg);
652  d_qg.value -= 1.0;
653  TimesDeriv(&d_qg,&d_qg,0.5 * WLCox * K1 * K1);
654  qb = -qg;
655  TimesDeriv(&d_qb,&d_qg,-1.0);
656  qd = 0.;
657  EqualDeriv(&d_qd,&d_zero);
658  goto finished;
659  } else if( vds < VdsPinchoff ){ /* triode region */
660  /*VgsVth2 = VgsVth*VgsVth;*/
661  EntSquare = Ent * Ent;
662  MultDeriv(&d_EntSquare,&d_Ent,&d_Ent);
663  Argl1 = 1.2e1 * EntSquare;
664  TimesDeriv(&d_Argl1,&d_EntSquare,12.0);
665  Argl2 = 1.0 - A;
666  TimesDeriv(&d_Argl2,&d_A,-1.0);
667  d_Argl2.value += 1.0;
668  /*
669  Argl3 = Arg1 * vds;
670  MultDeriv(&d_Argl3,&d_Arg1,&d_r);
671  */
672  /*Argl4 = Vcom/Ent/EntSquare;*/
673  if (Ent > 1.0e-8) {
674  Argl5 = Arg1 / Ent;
675  DivDeriv(&d_Argl5,&d_Arg1,&d_Ent);
676  /*Argl6 = Vcom/EntSquare;*/
677  } else {
678  Argl5 = 2.0;
679  EqualDeriv(&d_Argl5,&d_zero);
680  d_Argl5.value = 2.0;
681  Argl6 = 4.0 / 1.5e1;/*const*/
682  }
683  Argl7 = Argl5 / 1.2e1;
684  TimesDeriv(&d_Argl7,&d_Argl5,1.0/12.0);
685  /*
686  Argl8 = 6.0 * Ent;
687  TimesDeriv(&d_Argl8,&d_Ent,6.0);
688  Argl9 = 0.125 * Argl5 * Argl5;
689  MultDeriv(&d_Argl9,&d_Argl5,&d_Argl5);
690  TimesDeriv(&d_Argl9,&d_Argl9,0.125);
691  */
692  qg = WLCox * (vgs - Vfb - Phi - 0.5 * vds + vds * Argl7);
693  EqualDeriv(&d_qg,&d_Argl7);
694  d_qg.value -= 0.5;
695  MultDeriv(&d_qg,&d_qg,&d_r);
696  d_qg.value += vgs - Vfb - Phi;
697  d_qg.d1_p += 1.0;
698  TimesDeriv(&d_qg,&d_qg,WLCox);
699  qb = WLCox * ( - Vth0 + Vfb + Phi + 0.5 * Arg3 - Arg3 * Argl7);
700  TimesDeriv(&d_qb,&d_Argl7,-1.0);
701  d_qb.value += 0.5;
702  MultDeriv(&d_qb,&d_qb,&d_Arg3);
703  d_qb.value += Vfb + Phi;
704  TimesDeriv(&d_dummy,&d_Vth0,-1.0);
705  PlusDeriv(&d_qb,&d_qb,&d_dummy);
706  TimesDeriv(&d_qb,&d_qb,WLCox);
707  qd = - WLCox * (0.5 * VgsVth - 0.75 * Arg1 +
708  0.125 * Arg1 * Argl5);
709  TimesDeriv(&d_qd,&d_Argl5,0.125);
710  d_qd.value -= 0.75;
711  MultDeriv(&d_qd,&d_qd,&d_Arg1);
712  TimesDeriv(&d_dummy,&d_VgsVth,0.5);
713  PlusDeriv(&d_qd,&d_qd,&d_dummy);
714  TimesDeriv(&d_qd,&d_qd, -WLCox);
715  goto finished;
716  } else if( vds >= VdsPinchoff ) { /* saturation region */
717  Args1 = 1.0 / (3*A);
718  TimesDeriv(&d_Args1,&d_A,3.0);
719  InvDeriv(&d_Args1,&d_Args1);
720  qg = WLCox * (vgs - Vfb - Phi - VgsVth * Args1);
721  MultDeriv(&d_qg,&d_VgsVth,&d_Args1);
722  d_qg.value += Vfb + Phi - vgs;
723  d_qg.d1_p -= 1.0;
724  TimesDeriv(&d_qg,&d_qg,-WLCox);
725  qb = WLCox * (Vfb + Phi - Vth0 + (1.0 - A) * VgsVth * Args1);
726  TimesDeriv(&d_dummy,&d_A,-1.0);
727  d_dummy.value += 1.0;
728  MultDeriv(&d_qb,&d_VgsVth, &d_dummy);
729  MultDeriv(&d_qb,&d_qb,&d_Args1);
730  d_qb.value += Vfb + Phi;
731  TimesDeriv(&d_dummy,&d_Vth0,-1.0);
732  PlusDeriv(&d_qb,&d_qb,&d_dummy);
733  TimesDeriv(&d_qb,&d_qb,WLCox);
734  qd = 0.0;
735  EqualDeriv(&d_qd,&d_zero);
736  goto finished;
737  }
738 
739  goto finished;
740 
741  } else {
742 
743 /*0/100 partitioning for drain/source chArges at the saturation region*/
744  co4v15 = 1./15.;
745  Vth0 = Vfb + Phi + K1 * SqrtVpb;
746  TimesDeriv(&d_Vth0,&d_SqrtVpb,K1);
747  d_Vth0.value += Vfb + Phi;
748  VgsVth = vgs - Vth0;
749  TimesDeriv(&d_VgsVth,&d_Vth0,-1.0);
750  d_VgsVth.value += vgs;
751  d_VgsVth.d1_p += 1.0;
752  Arg1 = A * vds;
753  MultDeriv(&d_Arg1,&d_A,&d_r);
754  Arg2 = VgsVth - 0.5 * Arg1;
755  TimesDeriv(&d_Arg2,&d_Arg1,-0.5);
756  PlusDeriv(&d_Arg2,&d_Arg2,&d_VgsVth);
757  Arg3 = vds - Arg1;
758  TimesDeriv(&d_Arg3,&d_Arg1,-1.0);
759  d_Arg3.value = Arg3;
760  d_Arg3.d1_r += 1.0;
761  Arg5 = Arg1 * Arg1;
762  MultDeriv(&d_Arg5,&d_Arg1,&d_Arg1);
763  Ent = MAX(Arg2,1.0e-8);
764  if (Arg2 < 1.0e-8) {
765  EqualDeriv(&d_Ent,&d_zero);
766  d_Ent.value = Ent;
767  }
768  else
769  {
770  EqualDeriv(&d_Ent,&d_Arg2);
771  }
772 
773  Vcom = VgsVth * VgsVth / 6.0 - 1.25e-1 * Arg1 *
774  VgsVth + 2.5e-2 * Arg5;
775  TimesDeriv(&d_dummy,&d_VgsVth,1/6.0);
776  TimesDeriv(&d_Vcom,&d_Arg1,-0.125);
777  PlusDeriv(&d_Vcom,&d_Vcom,&d_dummy);
778  MultDeriv(&d_Vcom,&d_Vcom,&d_VgsVth);
779  TimesDeriv(&d_dummy,&d_Arg5,2.5e-2);
780  PlusDeriv(&d_Vcom,&d_Vcom,&d_dummy);
781  VdsPinchoff = VgsVth / A;
782  if (VdsPinchoff < 0.0) {
783  VdsPinchoff = 0.0;
784  EqualDeriv(&d_VdsPinchoff,&d_zero);
785  }
786  else
787  {
788  DivDeriv(&d_VdsPinchoff,&d_VgsVth,&d_A);
789  }
790 
791  Vgb = vgs - vbs ;
792  EqualDeriv(&d_Vgb,&d_p);
793  d_Vgb.value = Vgb;
794  d_Vgb.d1_q = -1.0;
795  Vgb_Vfb = Vgb - Vfb;
796  EqualDeriv(&d_Vgb_Vfb,&d_Vgb);
797  d_Vgb_Vfb.value = Vgb_Vfb;
798 
799  if( Vgb_Vfb < 0){
800  /* Accumulation Region */
801  qg = WLCox * Vgb_Vfb;
802  TimesDeriv(&d_qg,&d_Vgb_Vfb,WLCox);
803  qb = - qg;
804  TimesDeriv(&d_qb,&d_qg,-1.0);
805  qd = 0. ;
806  EqualDeriv(&d_qd,&d_zero);
807  goto finished;
808  } else if ( vgs < Vth0 ){
809  /* Subthreshold Region */
810  qg = 0.5 * WLCox * K1 * K1 * (-1 +
811  sqrt(1 + 4 * Vgb_Vfb / (K1 * K1)));
812  TimesDeriv(&d_qg,&d_Vgb_Vfb,4/(K1*K1));
813  d_qg.value += 1.0;
814  SqrtDeriv(&d_qg,&d_qg);
815  d_qg.value -= 1.0;
816  TimesDeriv(&d_qg,&d_qg,0.5 * WLCox * K1 * K1);
817  qb = -qg;
818  TimesDeriv(&d_qb,&d_qg,-1.0);
819  qd = 0.;
820  EqualDeriv(&d_qd,&d_zero);
821  goto finished;
822  } else if( vds < VdsPinchoff ){ /* triode region */
823  /*
824  VgsVthSquare = VgsVth*VgsVth;
825  MultDeriv(&d_VgsVthSquare,&d_VgsVth,&d_VgsVth);
826  */
827  EntSquare = Ent * Ent;
828  MultDeriv(&d_EntSquare,&d_Ent,&d_Ent);
829  Argl1 = 1.2e1 * EntSquare;
830  TimesDeriv(&d_Argl1,&d_EntSquare,12.0);
831  Argl2 = 1.0 - A;
832  TimesDeriv(&d_Argl2,&d_A,-1.0);
833  d_Argl2.value += 1.0;
834  /*
835  Argl3 = Arg1 * vds;
836  MultDeriv(&d_Argl3,&d_Arg1,&d_r);
837  Argl4 = Vcom/Ent/EntSquare;
838  MultDeriv(&d_Argl4,&d_Ent,&d_EntSquare);
839  DivDeriv(&d_Argl4,&d_Vcom,&d_Argl4);
840  */
841  if (Ent > 1.0e-8) {
842  Argl5 = Arg1 / Ent;
843  DivDeriv(&d_Argl5,&d_Arg1,&d_Ent);
844  Argl6 = Vcom/EntSquare;
845  DivDeriv(&d_Argl6,&d_Vcom,&d_EntSquare);
846  } else {
847  Argl5 = 2.0;
848  EqualDeriv(&d_Argl5,&d_zero);
849  d_Argl5.value = Argl5;
850  Argl6 = 4.0 / 1.5e1;
851  EqualDeriv(&d_Argl6,&d_zero);
852  d_Argl6.value = Argl6;
853  }
854  Argl7 = Argl5 / 1.2e1;
855  TimesDeriv(&d_Argl7,&d_Argl5,1/12.0);
856  /*
857  Argl8 = 6.0 * Ent;
858  TimesDeriv(&d_Argl8,&d_Ent,6.0);
859  Argl9 = 0.125 * Argl5 * Argl5;
860  MultDeriv(&d_Argl9,&d_Argl5,&d_Argl5);
861  TimesDeriv(&d_Argl9,&d_Argl9,0.125);
862  */
863  qg = WLCox * (vgs - Vfb - Phi - 0.5 * vds + vds * Argl7);
864  EqualDeriv(&d_qg,&d_Argl7);
865  d_qg.value -= 0.5;
866  MultDeriv(&d_qg,&d_qg,&d_r);
867  d_qg.value += vgs - Vfb - Phi;
868  d_qg.d1_p += 1.0;
869  TimesDeriv(&d_qg,&d_qg,WLCox);
870  qb = WLCox * ( - Vth0 + Vfb + Phi + 0.5 * Arg3 - Arg3 * Argl7);
871  TimesDeriv(&d_qb,&d_Argl7,-1.0);
872  d_qb.value += 0.5;
873  MultDeriv(&d_qb,&d_qb,&d_Arg3);
874  d_qb.value += Vfb + Phi;
875  TimesDeriv(&d_dummy,&d_Vth0,-1.0);
876  PlusDeriv(&d_qb,&d_qb,&d_dummy);
877  TimesDeriv(&d_qb,&d_qb,WLCox);
878  qd = - WLCox * (0.5 * (VgsVth - Arg1) +
879  Arg1 * Argl6);
880  MultDeriv(&d_dummy,&d_Arg1,&d_Argl6);
881  TimesDeriv(&d_qd,&d_Arg1,-1.0);
882  PlusDeriv(&d_qd,&d_qd,&d_VgsVth);
883  TimesDeriv(&d_qd,&d_qd,0.5);
884  PlusDeriv(&d_qd,&d_qd,&d_dummy);
885  TimesDeriv(&d_qd,&d_qd,-WLCox);
886  goto finished;
887  } else if( vds >= VdsPinchoff ) { /* saturation region */
888  Args1 = 1.0 / (3*A);
889  TimesDeriv(&d_Args1,&d_A,3.0);
890  InvDeriv(&d_Args1,&d_Args1);
891 
892  qg = WLCox * (vgs - Vfb - Phi - VgsVth * Args1);
893  MultDeriv(&d_qg,&d_VgsVth,&d_Args1);
894  d_qg.value += Vfb + Phi - vgs;
895  d_qg.d1_p -= 1.0;
896  TimesDeriv(&d_qg,&d_qg,-WLCox);
897  qb = WLCox * (Vfb + Phi - Vth0 + (1.0 - A) * VgsVth * Args1);
898  TimesDeriv(&d_dummy,&d_A,-1.0);
899  d_dummy.value += 1.0;
900  MultDeriv(&d_qb,&d_VgsVth, &d_dummy);
901  MultDeriv(&d_qb,&d_qb,&d_Args1);
902  d_qb.value += Vfb + Phi;
903  TimesDeriv(&d_dummy,&d_Vth0,-1.0);
904  PlusDeriv(&d_qb,&d_qb,&d_dummy);
905  TimesDeriv(&d_qb,&d_qb,WLCox);
906  qd = -co4v15*WLCox*VgsVth;
907  TimesDeriv(&d_qd,&d_VgsVth,-co4v15*WLCox);
908  goto finished;
909  }
910 
911 
912  }
913 
914 }
915 finished: /* returning Values to Calling Routine */
916 
917 
918 
919 
920  /*
921  * the above has set up (DrCur) and (the node q's)
922  * and (their derivatives upto third order wrt vgs, vbs, and
923  * vds)
924  */
925  /*
926  *
927  */
928  /*
929  * charge storage elements
930  *
931  * bulk-drain and bulk-source depletion capacitances
932  * czbd : zero bias drain junction capacitance
933  * czbs : zero bias source junction capacitance
934  * czbdsw:zero bias drain junction sidewall capacitance
935  * czbssw:zero bias source junction sidewall capacitance
936  */
937 
938  czbd = model->B1unitAreaJctCap * DrainArea;
939  czbs = model->B1unitAreaJctCap * SourceArea;
940  czbdsw= model->B1unitLengthSidewallJctCap * DrainPerimeter;
941  czbssw= model->B1unitLengthSidewallJctCap * SourcePerimeter;
942  PhiB = model->B1bulkJctPotential;
943  PhiBSW = model->B1sidewallJctPotential;
944  MJ = model->B1bulkJctBotGradingCoeff;
945  MJSW = model->B1bulkJctSideGradingCoeff;
946 
947  /* Source Bulk Junction */
948  if( vbs < 0 ) {
949  arg = 1 - vbs / PhiB;
950  argsw = 1 - vbs / PhiBSW;
951  sarg = exp(-MJ*log(arg));
952  sargsw = exp(-MJSW*log(argsw));
953  /* *(ckt->CKTstate0 + here->B1qbs) =
954  PhiB * czbs * (1-arg*sarg)/(1-MJ) + PhiBSW *
955  czbssw * (1-argsw*sargsw)/(1-MJSW); */
956  capbs1 = czbs * sarg + czbssw * sargsw ;
957  capbs2 = (czbs * MJ * sarg / (PhiB*arg)
958  + czbssw * MJSW * sargsw /(PhiBSW*argsw))/2.0;
959  capbs3 = (czbs * (MJ) * (MJ + 1.) * sarg /((PhiB*arg)*(PhiB*arg))
960  + czbssw * MJSW * (MJSW + 1.) * sargsw / (PhiBSW*argsw*PhiBSW*argsw))/6.0;
961  } else {
962  /* *(ckt->CKTstate0+here->B1qbs) =
963  vbs*(czbs+czbssw)+ vbs*vbs*(czbs*MJ*0.5/PhiB
964  + czbssw * MJSW * 0.5/PhiBSW); */
965  capbs1 = czbs + czbssw + vbs *(czbs*MJ/PhiB+
966  czbssw * MJSW / PhiBSW );
967  capbs2 = (czbs*MJ/PhiB+czbssw * MJSW / PhiBSW )*0.5;
968  capbs3 = 0.0;
969  }
970 
971  /* Drain Bulk Junction */
972  if( vbd < 0 ) {
973  arg = 1 - vbd / PhiB;
974  argsw = 1 - vbd / PhiBSW;
975  sarg = exp(-MJ*log(arg));
976  sargsw = exp(-MJSW*log(argsw));
977  /* *(ckt->CKTstate0 + here->B1qbd) =
978  PhiB * czbd * (1-arg*sarg)/(1-MJ) + PhiBSW *
979  czbdsw * (1-argsw*sargsw)/(1-MJSW); */
980  capbd1 = czbd * sarg + czbdsw * sargsw ;
981  capbd2 = (czbd * MJ * sarg / (PhiB*arg)
982  + czbdsw * MJSW * sargsw /(PhiBSW*argsw))*0.5;
983  capbd3 = (czbd * (MJ) * (MJ + 1.) * sarg /((PhiB*arg)*(PhiB*arg))
984  + czbdsw * MJSW * (MJSW + 1.) * sargsw / (PhiBSW*argsw*PhiBSW*argsw))/6.0;
985  } else {
986  /* *(ckt->CKTstate0+here->B1qbd) =
987  vbd*(czbd+czbdsw)+ vbd*vbd*(czbd*MJ*0.5/PhiB
988  + czbdsw * MJSW * 0.5/PhiBSW); */
989  capbd1 = czbd + czbdsw + vbd *(czbd*MJ/PhiB+
990  czbdsw * MJSW / PhiBSW );
991  capbd2 = 0.5*(czbs*MJ/PhiB+czbssw * MJSW / PhiBSW );
992  capbd3 = 0.0;
993  }
994 
995 
996 
997 
998 
999 line755:
1000 
1001  /*
1002  qgd = GateDrainOverlapCap * (vgs - vds);
1003  qgs = GateSourceOverlapCap * vgs;
1004  qgb = GateBulkOverlapCap * (vgs -vbs);
1005  *qGatePointer = *qGatePointer + qgd + qgs + qgb;
1006  *qBulkPointer = *qBulkPointer - qgb;
1007  *qDrainPointer = *qDrainPointer - qgd;
1008  *qSourcePointer = -(*qGatePointer + *qBulkPointer + *qDrainPointer);
1009  */
1010  d_qg.d1_p += GateDrainOverlapCap + GateSourceOverlapCap + GateBulkOverlapCap;
1011  d_qg.d1_q += -GateBulkOverlapCap;
1012  d_qg.d1_r += -GateDrainOverlapCap;
1013  d_qb.d1_p += -GateBulkOverlapCap;
1014  d_qb.d1_q += GateBulkOverlapCap + capbs1 + capbd1;
1015  d_qb.d1_r += -capbd1;
1016  d_qd.d1_p += - GateDrainOverlapCap;
1017  d_qd.d1_q += -capbd1;
1018  d_qd.d1_r += GateDrainOverlapCap + capbd1;
1019  /*
1020  d[23]_qg_d[vlgbds23] += 0.0;
1021  d2_qb_dvgs2 += 0.0;
1022  d3_qb_dvgs3 += 0.0
1023  d[23]_qb_dvgs[dvbds23] += 0.0
1024  */
1025  d_qb.d2_q2 += 2* ( capbd2 + capbs2);
1026  d_qb.d3_q3 += 6*(capbd3 + capbs3);
1027  d_qb.d2_qr += -2*capbd2;
1028  d_qb.d3_q2r += -capbd3*6;
1029  d_qb.d3_qr2 += capbd3*6;
1030  d_qb.d2_r2 += 2*capbd2;
1031  d_qb.d3_r3 += -6*capbd3;
1032  /*
1033  d[23]_qd_dp[dvbds23] += 0.0
1034  */
1035  d_qd.d2_q2 -= 2*capbd2;
1036  d_qd.d3_q3 -= 6*capbd3;
1037  d_qd.d2_r2 -= 2*capbd2;
1038  d_qd.d3_r3 -= -6*capbd3;
1039  d_qd.d2_qr -= -2*capbd2;
1040  d_qd.d3_q2r -= -6*capbd3;
1041  d_qd.d3_qr2 -= 6*capbd3;
1042 
1043 
1044  /* get all the coefficients and adjust for mode and type */
1045  if (here->B1mode == 1)
1046  {
1047  /* normal mode - no source-drain interchange */
1048 here->qg_x = d_qg.d1_p;
1049 here->qg_y = d_qg.d1_q;
1050 here->qg_z = d_qg.d1_r;
1051 here->qg_x2 = d_qg.d2_p2;
1052 here->qg_y2 = d_qg.d2_q2;
1053 here->qg_z2 = d_qg.d2_r2;
1054 here->qg_xy = d_qg.d2_pq;
1055 here->qg_yz = d_qg.d2_qr;
1056 here->qg_xz = d_qg.d2_pr;
1057 here->qg_x3 = d_qg.d3_p3;
1058 here->qg_y3 = d_qg.d3_q3;
1059 here->qg_z3 = d_qg.d3_r3;
1060 here->qg_x2z = d_qg.d3_p2r;
1061 here->qg_x2y = d_qg.d3_p2q;
1062 here->qg_y2z = d_qg.d3_q2r;
1063 here->qg_xy2 = d_qg.d3_pq2;
1064 here->qg_xz2 = d_qg.d3_pr2;
1065 here->qg_yz2 = d_qg.d3_qr2;
1066 here->qg_xyz = d_qg.d3_pqr;
1067 
1068 here->qb_x = d_qb.d1_p;
1069 here->qb_y = d_qb.d1_q;
1070 here->qb_z = d_qb.d1_r;
1071 here->qb_x2 = d_qb.d2_p2;
1072 here->qb_y2 = d_qb.d2_q2;
1073 here->qb_z2 = d_qb.d2_r2;
1074 here->qb_xy = d_qb.d2_pq;
1075 here->qb_yz = d_qb.d2_qr;
1076 here->qb_xz = d_qb.d2_pr;
1077 here->qb_x3 = d_qb.d3_p3;
1078 here->qb_y3 = d_qb.d3_q3;
1079 here->qb_z3 = d_qb.d3_r3;
1080 here->qb_x2z = d_qb.d3_p2r;
1081 here->qb_x2y = d_qb.d3_p2q;
1082 here->qb_y2z = d_qb.d3_q2r;
1083 here->qb_xy2 = d_qb.d3_pq2;
1084 here->qb_xz2 = d_qb.d3_pr2;
1085 here->qb_yz2 = d_qb.d3_qr2;
1086 here->qb_xyz = d_qb.d3_pqr;
1087 
1088 here->qd_x = d_qd.d1_p;
1089 here->qd_y = d_qd.d1_q;
1090 here->qd_z = d_qd.d1_r;
1091 here->qd_x2 = d_qd.d2_p2;
1092 here->qd_y2 = d_qd.d2_q2;
1093 here->qd_z2 = d_qd.d2_r2;
1094 here->qd_xy = d_qd.d2_pq;
1095 here->qd_yz = d_qd.d2_qr;
1096 here->qd_xz = d_qd.d2_pr;
1097 here->qd_x3 = d_qd.d3_p3;
1098 here->qd_y3 = d_qd.d3_q3;
1099 here->qd_z3 = d_qd.d3_r3;
1100 here->qd_x2z = d_qd.d3_p2r;
1101 here->qd_x2y = d_qd.d3_p2q;
1102 here->qd_y2z = d_qd.d3_q2r;
1103 here->qd_xy2 = d_qd.d3_pq2;
1104 here->qd_xz2 = d_qd.d3_pr2;
1105 here->qd_yz2 = d_qd.d3_qr2;
1106 here->qd_xyz = d_qd.d3_pqr;
1107 
1108 here->DrC_x = d_DrCur.d1_p;
1109 here->DrC_y = d_DrCur.d1_q;
1110 here->DrC_z = d_DrCur.d1_r;
1111 here->DrC_x2 = d_DrCur.d2_p2;
1112 here->DrC_y2 = d_DrCur.d2_q2;
1113 here->DrC_z2 = d_DrCur.d2_r2;
1114 here->DrC_xy = d_DrCur.d2_pq;
1115 here->DrC_yz = d_DrCur.d2_qr;
1116 here->DrC_xz = d_DrCur.d2_pr;
1117 here->DrC_x3 = d_DrCur.d3_p3;
1118 here->DrC_y3 = d_DrCur.d3_q3;
1119 here->DrC_z3 = d_DrCur.d3_r3;
1120 here->DrC_x2z = d_DrCur.d3_p2r;
1121 here->DrC_x2y = d_DrCur.d3_p2q;
1122 here->DrC_y2z = d_DrCur.d3_q2r;
1123 here->DrC_xy2 = d_DrCur.d3_pq2;
1124 here->DrC_xz2 = d_DrCur.d3_pr2;
1125 here->DrC_yz2 = d_DrCur.d3_qr2;
1126 here->DrC_xyz = d_DrCur.d3_pqr;
1127 
1128 here->gbs1 = lgbs1;
1129 here->gbs2 = lgbs2;
1130 here->gbs3 = lgbs3;
1131 
1132 here->gbd1 = lgbd1;
1133 here->gbd2 = lgbd2;
1134 here->gbd3 = lgbd3;
1135 
1136 } else {
1137  /*
1138  * inverse mode - source and drain interchanged
1139  * inversion equations for realqg and realqb are the
1140  * same; a minus is added for the
1141  * realDrCur equation;
1142  * realqd = -(realqb + realqg + fakeqd)
1143  */
1144 
1145 here->qg_x = -(-d_qg.d1_p);
1146 here->qg_y = -(-d_qg.d1_q);
1147 here->qg_z = -(d_qg.d1_p + d_qg.d1_q + d_qg.d1_r);
1148 here->qg_x2 = -(-d_qg.d2_p2);
1149 here->qg_y2 = -(-d_qg.d2_q2);
1150 here->qg_z2 = -(-(d_qg.d2_p2 + d_qg.d2_q2 + d_qg.d2_r2 + 2*(d_qg.d2_pq + d_qg.d2_pr + d_qg.d2_qr)));
1151 here->qg_xy = -(-d_qg.d2_pq);
1152 here->qg_yz = -(d_qg.d2_pq + d_qg.d2_q2 + d_qg.d2_qr);
1153 here->qg_xz = -(d_qg.d2_p2 + d_qg.d2_pq + d_qg.d2_pr);
1154 here->qg_x3 = -(-d_qg.d3_p3);
1155 here->qg_y3 = -(-d_qg.d3_q3);
1156 here->qg_z3 = -(d_qg.d3_p3 + d_qg.d3_q3 + d_qg.d3_r3 + 3*(d_qg.d3_p2q + d_qg.d3_p2r + d_qg.d3_pq2 + d_qg.d3_q2r + d_qg.d3_pr2 + d_qg.d3_qr2) + 6*d_qg.d3_pqr );
1157 here->qg_x2z = -(d_qg.d3_p3 + d_qg.d3_p2q + d_qg.d3_p2r);
1158 here->qg_x2y = -(-d_qg.d3_p2q);
1159 here->qg_y2z = -(d_qg.d3_pq2 + d_qg.d3_q3 + d_qg.d3_q2r);
1160 here->qg_xy2 = -(-d_qg.d3_pq2);
1161 here->qg_xz2 = -(-(d_qg.d3_p3 + 2*(d_qg.d3_p2q + d_qg.d3_p2r + d_qg.d3_pqr) + d_qg.d3_pq2 + d_qg.d3_pr2));
1162 here->qg_yz2 = -(-(d_qg.d3_q3 + 2*(d_qg.d3_pq2 + d_qg.d3_q2r + d_qg.d3_pqr) + d_qg.d3_p2q + d_qg.d3_qr2));
1163 here->qg_xyz = -(d_qg.d3_p2q + d_qg.d3_pq2 + d_qg.d3_pqr);
1164 
1165 here->qb_x = -(-d_qb.d1_p);
1166 here->qb_y = -(-d_qb.d1_q);
1167 here->qb_z = -(d_qb.d1_p + d_qb.d1_q + d_qb.d1_r);
1168 here->qb_x2 = -(-d_qb.d2_p2);
1169 here->qb_y2 = -(-d_qb.d2_q2);
1170 here->qb_z2 = -(-(d_qb.d2_p2 + d_qb.d2_q2 + d_qb.d2_r2 + 2*(d_qb.d2_pq + d_qb.d2_pr + d_qb.d2_qr)));
1171 here->qb_xy = -(-d_qb.d2_pq);
1172 here->qb_yz = -(d_qb.d2_pq + d_qb.d2_q2 + d_qb.d2_qr);
1173 here->qb_xz = -(d_qb.d2_p2 + d_qb.d2_pq + d_qb.d2_pr);
1174 here->qb_x3 = -(-d_qb.d3_p3);
1175 here->qb_y3 = -(-d_qb.d3_q3);
1176 here->qb_z3 = -(d_qb.d3_p3 + d_qb.d3_q3 + d_qb.d3_r3 + 3*(d_qb.d3_p2q + d_qb.d3_p2r + d_qb.d3_pq2 + d_qb.d3_q2r + d_qb.d3_pr2 + d_qb.d3_qr2) + 6*d_qb.d3_pqr );
1177 here->qb_x2z = -(d_qb.d3_p3 + d_qb.d3_p2q + d_qb.d3_p2r);
1178 here->qb_x2y = -(-d_qb.d3_p2q);
1179 here->qb_y2z = -(d_qb.d3_pq2 + d_qb.d3_q3 + d_qb.d3_q2r);
1180 here->qb_xy2 = -(-d_qb.d3_pq2);
1181 here->qb_xz2 = -(-(d_qb.d3_p3 + 2*(d_qb.d3_p2q + d_qb.d3_p2r + d_qb.d3_pqr) + d_qb.d3_pq2 + d_qb.d3_pr2));
1182 here->qb_yz2 = -(-(d_qb.d3_q3 + 2*(d_qb.d3_pq2 + d_qb.d3_q2r + d_qb.d3_pqr) + d_qb.d3_p2q + d_qb.d3_qr2));
1183 here->qb_xyz = -(d_qb.d3_p2q + d_qb.d3_pq2 + d_qb.d3_pqr);
1184 
1185 here->qd_x= -here->qg_x - here->qb_x +(-d_qd.d1_p);
1186 here->qd_y= -here->qg_y - here->qb_y +(-d_qd.d1_q);
1187 here->qd_z= -here->qg_z - here->qb_z +(d_qd.d1_p + d_qd.d1_q + d_qd.d1_r);
1188 here->qd_x2 = -here->qg_x2 - here->qb_x2 +(-d_qd.d2_p2);
1189 here->qd_y2 = -here->qg_y2 - here->qb_y2 +(-d_qd.d2_q2);
1190 here->qd_z2 = -here->qg_z2 - here->qb_z2 +(-(d_qd.d2_p2 + d_qd.d2_q2 + d_qd.d2_r2 + 2*(d_qd.d2_pq + d_qd.d2_pr + d_qd.d2_qr)));
1191 here->qd_xy = -here->qg_xy - here->qb_xy +(-d_qd.d2_pq);
1192 here->qd_yz = -here->qg_yz - here->qb_yz +(d_qd.d2_pq + d_qd.d2_q2 + d_qd.d2_qr);
1193 here->qd_xz = -here->qg_xz - here->qb_xz +(d_qd.d2_p2 + d_qd.d2_pq + d_qd.d2_pr);
1194 here->qd_x3 = -here->qg_x3 - here->qb_x3 +(-d_qd.d3_p3);
1195 here->qd_y3 = -here->qg_y3 - here->qb_y3 +(-d_qd.d3_q3);
1196 here->qd_z3 = -here->qg_z3 - here->qb_z3 +(d_qd.d3_p3 + d_qd.d3_q3 + d_qd.d3_r3 + 3*(d_qd.d3_p2q + d_qd.d3_p2r + d_qd.d3_pq2 + d_qd.d3_q2r + d_qd.d3_pr2 + d_qd.d3_qr2) + 6*d_qd.d3_pqr );
1197 here->qd_x2z = -here->qg_x2z - here->qb_x2z +(d_qd.d3_p3 + d_qd.d3_p2q + d_qd.d3_p2r);
1198 here->qd_x2y = -here->qg_x2y - here->qb_x2y +(-d_qd.d3_p2q);
1199 here->qd_y2z = -here->qg_y2z - here->qb_y2z +(d_qd.d3_pq2 + d_qd.d3_q3 + d_qd.d3_q2r);
1200 here->qd_xy2 = -here->qg_xy2 - here->qb_xy2 +(-d_qd.d3_pq2);
1201 here->qd_xz2 = -here->qg_xz2 - here->qb_xz2 +(-(d_qd.d3_p3 + 2*(d_qd.d3_p2q + d_qd.d3_p2r + d_qd.d3_pqr) + d_qd.d3_pq2 + d_qd.d3_pr2));
1202 here->qd_yz2 = -here->qg_yz2 - here->qb_yz2 +(-(d_qd.d3_q3 + 2*(d_qd.d3_pq2 + d_qd.d3_q2r + d_qd.d3_pqr) + d_qd.d3_p2q + d_qd.d3_qr2));
1203 here->qd_xyz = -here->qg_xyz - here->qb_xyz +(d_qd.d3_p2q + d_qd.d3_pq2 + d_qd.d3_pqr);
1204 
1205 here->DrC_x = -d_DrCur.d1_p;
1206 here->DrC_y = -d_DrCur.d1_q;
1207 here->DrC_z = d_DrCur.d1_p + d_DrCur.d1_q + d_DrCur.d1_r;
1208 here->DrC_x2 = -d_DrCur.d2_p2;
1209 here->DrC_y2 = -d_DrCur.d2_q2;
1210 here->DrC_z2 = -(d_DrCur.d2_p2 + d_DrCur.d2_q2 + d_DrCur.d2_r2 + 2*(d_DrCur.d2_pq + d_DrCur.d2_pr + d_DrCur.d2_qr));
1211 here->DrC_xy = -d_DrCur.d2_pq;
1212 here->DrC_yz = d_DrCur.d2_pq + d_DrCur.d2_q2 + d_DrCur.d2_qr;
1213 here->DrC_xz = d_DrCur.d2_p2 + d_DrCur.d2_pq + d_DrCur.d2_pr;
1214 here->DrC_x3 = -d_DrCur.d3_p3;
1215 here->DrC_y3 = -d_DrCur.d3_q3;
1216 here->DrC_z3 = d_DrCur.d3_p3 + d_DrCur.d3_q3 + d_DrCur.d3_r3 + 3*(d_DrCur.d3_p2q + d_DrCur.d3_p2r + d_DrCur.d3_pq2 + d_DrCur.d3_q2r + d_DrCur.d3_pr2 + d_DrCur.d3_qr2) + 6*d_DrCur.d3_pqr ;
1217 here->DrC_x2z = d_DrCur.d3_p3 + d_DrCur.d3_p2q + d_DrCur.d3_p2r;
1218 here->DrC_x2y = -d_DrCur.d3_p2q;
1219 here->DrC_y2z = d_DrCur.d3_pq2 + d_DrCur.d3_q3 + d_DrCur.d3_q2r;
1220 here->DrC_xy2 = -d_DrCur.d3_pq2;
1221 here->DrC_xz2 = -(d_DrCur.d3_p3 + 2*(d_DrCur.d3_p2q + d_DrCur.d3_p2r + d_DrCur.d3_pqr) + d_DrCur.d3_pq2 + d_DrCur.d3_pr2);
1222 here->DrC_yz2 = -(d_DrCur.d3_q3 + 2*(d_DrCur.d3_pq2 + d_DrCur.d3_q2r + d_DrCur.d3_pqr) + d_DrCur.d3_p2q + d_DrCur.d3_qr2);
1223 here->DrC_xyz = d_DrCur.d3_p2q + d_DrCur.d3_pq2 + d_DrCur.d3_pqr;
1224 
1225 here->gbs1 = lgbd1;
1226 here->gbs2 = lgbd2;
1227 here->gbs3 = lgbd3;
1228 
1229 here->gbd1 = lgbs1;
1230 here->gbd2 = lgbs2;
1231 here->gbd3 = lgbs3;
1232 }
1233 
1234 /* now to adjust for type and multiply by factors to convert to Taylor coeffs. */
1235 
1236 here->qg_x2 = 0.5*model->B1type*here->qg_x2;
1237 here->qg_y2 = 0.5*model->B1type*here->qg_y2;
1238 here->qg_z2 = 0.5*model->B1type*here->qg_z2;
1239 here->qg_xy = model->B1type*here->qg_xy;
1240 here->qg_yz = model->B1type*here->qg_yz;
1241 here->qg_xz = model->B1type*here->qg_xz;
1242 here->qg_x3 = here->qg_x3/6.;
1243 here->qg_y3 = here->qg_y3/6.;
1244 here->qg_z3 = here->qg_z3/6.;
1245 here->qg_x2z = 0.5*here->qg_x2z;
1246 here->qg_x2y = 0.5*here->qg_x2y;
1247 here->qg_y2z = 0.5*here->qg_y2z;
1248 here->qg_xy2 = 0.5*here->qg_xy2;
1249 here->qg_xz2 = 0.5*here->qg_xz2;
1250 here->qg_yz2 = 0.5*here->qg_yz2;
1251 
1252 here->qb_x2 = 0.5*model->B1type*here->qb_x2;
1253 here->qb_y2 = 0.5*model->B1type*here->qb_y2;
1254 here->qb_z2 = 0.5*model->B1type*here->qb_z2;
1255 here->qb_xy = model->B1type*here->qb_xy;
1256 here->qb_yz = model->B1type*here->qb_yz;
1257 here->qb_xz = model->B1type*here->qb_xz;
1258 here->qb_x3 = here->qb_x3/6.;
1259 here->qb_y3 = here->qb_y3/6.;
1260 here->qb_z3 = here->qb_z3/6.;
1261 here->qb_x2z = 0.5*here->qb_x2z;
1262 here->qb_x2y = 0.5*here->qb_x2y;
1263 here->qb_y2z = 0.5*here->qb_y2z;
1264 here->qb_xy2 = 0.5*here->qb_xy2;
1265 here->qb_xz2 = 0.5*here->qb_xz2;
1266 here->qb_yz2 = 0.5*here->qb_yz2;
1267 
1268 here->qd_x2 = 0.5*model->B1type*here->qd_x2;
1269 here->qd_y2 = 0.5*model->B1type*here->qd_y2;
1270 here->qd_z2 = 0.5*model->B1type*here->qd_z2;
1271 here->qd_xy = model->B1type*here->qd_xy;
1272 here->qd_yz = model->B1type*here->qd_yz;
1273 here->qd_xz = model->B1type*here->qd_xz;
1274 here->qd_x3 = here->qd_x3/6.;
1275 here->qd_y3 = here->qd_y3/6.;
1276 here->qd_z3 = here->qd_z3/6.;
1277 here->qd_x2z = 0.5*here->qd_x2z;
1278 here->qd_x2y = 0.5*here->qd_x2y;
1279 here->qd_y2z = 0.5*here->qd_y2z;
1280 here->qd_xy2 = 0.5*here->qd_xy2;
1281 here->qd_xz2 = 0.5*here->qd_xz2;
1282 here->qd_yz2 = 0.5*here->qd_yz2;
1283 
1284 here->DrC_x2 = 0.5*model->B1type*here->DrC_x2;
1285 here->DrC_y2 = 0.5*model->B1type*here->DrC_y2;
1286 here->DrC_z2 = 0.5*model->B1type*here->DrC_z2;
1287 here->DrC_xy = model->B1type*here->DrC_xy;
1288 here->DrC_yz = model->B1type*here->DrC_yz;
1289 here->DrC_xz = model->B1type*here->DrC_xz;
1290 here->DrC_x3 = here->DrC_x3/6.;
1291 here->DrC_y3 = here->DrC_y3/6.;
1292 here->DrC_z3 = here->DrC_z3/6.;
1293 here->DrC_x2z = 0.5*here->DrC_x2z;
1294 here->DrC_x2y = 0.5*here->DrC_x2y;
1295 here->DrC_y2z = 0.5*here->DrC_y2z;
1296 here->DrC_xy2 = 0.5*here->DrC_xy2;
1297 here->DrC_xz2 = 0.5*here->DrC_xz2;
1298 here->DrC_yz2 = 0.5*here->DrC_yz2;
1299 
1300 here->gbs2 = model->B1type*here->gbs2;
1301 here->gbd2 = model->B1type*here->gbd2;
1302  } /* End of Mosfet Instance */
1303 
1304  } /* End of Model Instance */
1305  return(OK);
1306 }
double d2_pr
Definition: distodef.h:75
double B1betaVddD
Definition: bsim1def.h:64
double d3_pr2
Definition: distodef.h:83
double B1udsB
Definition: bsim1def.h:68
int B1dSetup(GENmodel *inModel, CKTcircuit *ckt)
Definition: b1dset.c:19
double B1bulkJctPotential
Definition: bsim1def.h:379
double d3_pq2
Definition: distodef.h:81
double B1channelChargePartitionFlag
Definition: bsim1def.h:375
double B1betaZero
Definition: bsim1def.h:60
double d3_p3
Definition: distodef.h:76
double B1betaZeroB
Definition: bsim1def.h:61
#define MAX(a, b)
Definition: spdefs.h:135
double d1_q
Definition: distodef.h:68
double d2_pq
Definition: distodef.h:73
double B1K2
Definition: bsim1def.h:56
double B1uds
Definition: bsim1def.h:67
int B1type
Definition: bsim1def.h:306
void PlusDeriv(Dderivs *new, Dderivs *old1, Dderivs *old2)
Definition: plusder.c:19
double B1deltaL
Definition: bsim1def.h:329
static double e
Definition: vectors.c:17
double B1subthSlopeD
Definition: bsim1def.h:72
double d3_pqr
Definition: distodef.h:85
#define capbs2
Definition: mosdefs.h:164
int B1sNodePrime
Definition: bsim1def.h:32
double d2_r2
Definition: distodef.h:72
double B1betaVdd
Definition: bsim1def.h:62
double B1vt0
Definition: bsim1def.h:76
void SqrtDeriv(Dderivs *new, Dderivs *old)
Definition: sqrtder.c:19
void MultDeriv(Dderivs *new, Dderivs *old1, Dderivs *old2)
Definition: multder.c:19
#define OK
Definition: iferrmsg.h:17
double B1drainArea
Definition: bsim1def.h:36
#define capbd2
Definition: mosdefs.h:166
void ExpDeriv(Dderivs *new, Dderivs *old)
Definition: expderiv.c:19
double d3_p2r
Definition: distodef.h:80
#define G
Definition: parse.c:441
double B1unitLengthSidewallJctCap
Definition: bsim1def.h:384
double B1vfb
Definition: bsim1def.h:53
double d2_qr
Definition: distodef.h:74
#define NULL
Definition: spdefs.h:121
double B1jctSatCurDensity
Definition: bsim1def.h:378
double d1_r
Definition: distodef.h:69
double B1K1
Definition: bsim1def.h:55
double d1_p
Definition: distodef.h:67
double d3_qr2
Definition: distodef.h:84
double B1Cox
Definition: bsim1def.h:369
B1instance * B1instances
Definition: bsim1def.h:303
double B1subthSlope
Definition: bsim1def.h:70
double d3_q3
Definition: distodef.h:77
double B1sourceArea
Definition: bsim1def.h:37
double B1w
Definition: bsim1def.h:35
void DivDeriv(Dderivs *new, Dderivs *old1, Dderivs *old2)
Definition: divderiv.c:19
double B1eta
Definition: bsim1def.h:57
double B1gateBulkOverlapCap
Definition: bsim1def.h:374
void TimesDeriv(Dderivs *new, Dderivs *old, double k)
Definition: timesder.c:19
#define capbs3
Definition: mosdefs.h:165
static char model[32]
Definition: subckt.c:76
double B1sidewallJctPotential
Definition: bsim1def.h:382
#define capbd3
Definition: mosdefs.h:167
struct sBSIM1model * B1nextModel
Definition: bsim1def.h:301
double d3_q2r
Definition: distodef.h:82
double B1bulkJctBotGradingCoeff
Definition: bsim1def.h:380
double B1bulkJctSideGradingCoeff
Definition: bsim1def.h:381
double B1gateDrainOverlapCap
Definition: bsim1def.h:373
struct sBSIM1instance * B1nextInstance
Definition: bsim1def.h:22
double B1udsD
Definition: bsim1def.h:69
double B1phi
Definition: bsim1def.h:54
double B1l
Definition: bsim1def.h:34
double CONSTvt0
Definition: main.c:914
double B1ugsB
Definition: bsim1def.h:66
double value
Definition: distodef.h:66
double B1subthSlopeB
Definition: bsim1def.h:71
double B1etaB
Definition: bsim1def.h:58
double B1deltaW
Definition: bsim1def.h:330
double B1etaD
Definition: bsim1def.h:59
int B1dNodePrime
Definition: bsim1def.h:31
double d3_r3
Definition: distodef.h:78
double B1betaVddB
Definition: bsim1def.h:63
double B1ugs
Definition: bsim1def.h:65
double B1unitAreaJctCap
Definition: bsim1def.h:383
double d3_p2q
Definition: distodef.h:79
double B1vdd
Definition: bsim1def.h:371
double d2_q2
Definition: distodef.h:71
void InvDeriv(Dderivs *new, Dderivs *old)
Definition: invderiv.c:19
double B1gateSourceOverlapCap
Definition: bsim1def.h:372
double B1drainPerimeter
Definition: bsim1def.h:40
double B1sourcePerimeter
Definition: bsim1def.h:41
double d2_p2
Definition: distodef.h:70
void EqualDeriv(Dderivs *new, Dderivs *old)
Definition: equalder.c:17