Jspice3
b1ld.c File Reference
#include "spice.h"
#include <stdio.h>
#include <math.h>
#include "bsim1def.h"
#include "const.h"
#include "sperror.h"
#include "util.h"
#include "niext.h"
Include dependency graph for b1ld.c:

Go to the source code of this file.

Functions

int B1load (GENmodel *inModel, CKTcircuit *ckt)
 

Function Documentation

int B1load ( GENmodel inModel,
CKTcircuit ckt 
)

Definition at line 19 of file b1ld.c.

27 {
28  register B1model *model = (B1model*)inModel;
29  register B1instance *here;
30  double DrainSatCurrent = 0.0;
31  double EffectiveLength = 0.0;
32  double GateBulkOverlapCap = 0.0;
33  double GateDrainOverlapCap = 0.0;
34  double GateSourceOverlapCap = 0.0;
35  double SourceSatCurrent = 0.0;
36  double DrainArea = 0.0;
37  double SourceArea = 0.0;
38  double DrainPerimeter = 0.0;
39  double SourcePerimeter = 0.0;
40  double arg = 0.0;
41  double capbd = 0.0;
42  double capbs = 0.0;
43  double cbd = 0.0;
44  double cbhat = 0.0;
45  double cbs = 0.0;
46  double cd = 0.0;
47  double cdrain = 0.0;
48  double cdhat = 0.0;
49  double cdreq = 0.0;
50  double ceq = 0.0;
51  double ceqbd = 0.0;
52  double ceqbs = 0.0;
53  double ceqqb = 0.0;
54  double ceqqd = 0.0;
55  double ceqqg = 0.0;
56  double czbd = 0.0;
57  double czbdsw = 0.0;
58  double czbs = 0.0;
59  double czbssw = 0.0;
60  double delvbd = 0.0;
61  double delvbs = 0.0;
62  double delvds = 0.0;
63  double delvgd = 0.0;
64  double delvgs = 0.0;
65  double evbd = 0.0;
66  double evbs = 0.0;
67  double gbd = 0.0;
68  double gbs = 0.0;
69  double gcbdb = 0.0;
70  double gcbgb = 0.0;
71  double gcbsb = 0.0;
72  double gcddb = 0.0;
73  double gcdgb = 0.0;
74  double gcdsb = 0.0;
75  double gcgdb = 0.0;
76  double gcggb = 0.0;
77  double gcgsb = 0.0;
78  double gcsdb = 0.0;
79  double gcsgb = 0.0;
80  double gcssb = 0.0;
81  double gds = 0.0;
82  double geq = 0.0;
83  double gm = 0.0;
84  double gmbs = 0.0;
85  double sarg = 0.0;
86  double sargsw = 0.0;
87  double tol = 0.0;
88  double vbd = 0.0;
89  double vbs = 0.0;
90  double vcrit = 0.0;
91  double vds = 0.0;
92  double vdsat = 0.0;
93  double vgb = 0.0;
94  double vgd = 0.0;
95  double vgdo = 0.0;
96  double vgs = 0.0;
97  double von = 0.0;
98  double xfact = 0.0;
99  double xnrm = 0.0;
100  double xrev = 0.0;
101  int Check = 0;
102  double cgdb = 0.0;
103  double cgsb = 0.0;
104  double cbdb = 0.0;
105  double cdgb = 0.0;
106  double cddb = 0.0;
107  double cdsb = 0.0;
108  double cggb = 0.0;
109  double cbgb = 0.0;
110  double cbsb = 0.0;
111  double csgb = 0.0;
112  double cssb = 0.0;
113  double csdb = 0.0;
114  double PhiB = 0.0;
115  double PhiBSW = 0.0;
116  double MJ = 0.0;
117  double MJSW = 0.0;
118  double argsw = 0.0;
119  double qgate = 0.0;
120  double qbulk = 0.0;
121  double qdrn = 0.0;
122  double qsrc = 0.0;
123  double cqgate = 0.0;
124  double cqbulk = 0.0;
125  double cqdrn = 0.0;
126  double vt0 = 0.0;
127  double args[8];
128  int ByPass = 0;
129 #ifndef NOBYPASS
130  double tempv = 0.0;
131 #endif /*NOBYPASS*/
132  int error = 0;
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  von = model->B1type * here->B1von;
157  vdsat = model->B1type * here->B1vdsat;
158  vt0 = model->B1type * here->B1vt0;
159 
160  Check=1;
161  ByPass = 0;
162  if((ckt->CKTmode & MODEINITSMSIG)) {
163  vbs= *(ckt->CKTstate0 + here->B1vbs);
164  vgs= *(ckt->CKTstate0 + here->B1vgs);
165  vds= *(ckt->CKTstate0 + here->B1vds);
166  } else if ((ckt->CKTmode & MODEINITTRAN)) {
167  vbs= *(ckt->CKTstate1 + here->B1vbs);
168  vgs= *(ckt->CKTstate1 + here->B1vgs);
169  vds= *(ckt->CKTstate1 + here->B1vds);
170  } else if((ckt->CKTmode & MODEINITJCT) && !here->B1off) {
171  vds= model->B1type * here->B1icVDS;
172  vgs= model->B1type * here->B1icVGS;
173  vbs= model->B1type * here->B1icVBS;
174  if((vds==0) && (vgs==0) && (vbs==0) &&
175  ((ckt->CKTmode &
177  (!(ckt->CKTmode & MODEUIC)))) {
178  vbs = -1;
179  vgs = vt0;
180  vds = 0;
181  }
182  } else if((ckt->CKTmode & (MODEINITJCT | MODEINITFIX) ) &&
183  (here->B1off)) {
184  vbs=vgs=vds=0;
185  } else {
186 #ifndef PREDICTOR
187  if((ckt->CKTmode & MODEINITPRED)) {
188  xfact=ckt->CKTdelta/ckt->CKTdeltaOld[1];
189  *(ckt->CKTstate0 + here->B1vbs) =
190  *(ckt->CKTstate1 + here->B1vbs);
191  vbs = (1+xfact)* (*(ckt->CKTstate1 + here->B1vbs))
192  -(xfact * (*(ckt->CKTstate2 + here->B1vbs)));
193  *(ckt->CKTstate0 + here->B1vgs) =
194  *(ckt->CKTstate1 + here->B1vgs);
195  vgs = (1+xfact)* (*(ckt->CKTstate1 + here->B1vgs))
196  -(xfact * (*(ckt->CKTstate2 + here->B1vgs)));
197  *(ckt->CKTstate0 + here->B1vds) =
198  *(ckt->CKTstate1 + here->B1vds);
199  vds = (1+xfact)* (*(ckt->CKTstate1 + here->B1vds))
200  -(xfact * (*(ckt->CKTstate2 + here->B1vds)));
201  *(ckt->CKTstate0 + here->B1vbd) =
202  *(ckt->CKTstate0 + here->B1vbs)-
203  *(ckt->CKTstate0 + here->B1vds);
204  *(ckt->CKTstate0 + here->B1cd) =
205  *(ckt->CKTstate1 + here->B1cd);
206  *(ckt->CKTstate0 + here->B1cbs) =
207  *(ckt->CKTstate1 + here->B1cbs);
208  *(ckt->CKTstate0 + here->B1cbd) =
209  *(ckt->CKTstate1 + here->B1cbd);
210  *(ckt->CKTstate0 + here->B1gm) =
211  *(ckt->CKTstate1 + here->B1gm);
212  *(ckt->CKTstate0 + here->B1gds) =
213  *(ckt->CKTstate1 + here->B1gds);
214  *(ckt->CKTstate0 + here->B1gmbs) =
215  *(ckt->CKTstate1 + here->B1gmbs);
216  *(ckt->CKTstate0 + here->B1gbd) =
217  *(ckt->CKTstate1 + here->B1gbd);
218  *(ckt->CKTstate0 + here->B1gbs) =
219  *(ckt->CKTstate1 + here->B1gbs);
220  *(ckt->CKTstate0 + here->B1cggb) =
221  *(ckt->CKTstate1 + here->B1cggb);
222  *(ckt->CKTstate0 + here->B1cbgb) =
223  *(ckt->CKTstate1 + here->B1cbgb);
224  *(ckt->CKTstate0 + here->B1cbsb) =
225  *(ckt->CKTstate1 + here->B1cbsb);
226  *(ckt->CKTstate0 + here->B1cgdb) =
227  *(ckt->CKTstate1 + here->B1cgdb);
228  *(ckt->CKTstate0 + here->B1cgsb) =
229  *(ckt->CKTstate1 + here->B1cgsb);
230  *(ckt->CKTstate0 + here->B1cbdb) =
231  *(ckt->CKTstate1 + here->B1cbdb);
232  *(ckt->CKTstate0 + here->B1cdgb) =
233  *(ckt->CKTstate1 + here->B1cdgb);
234  *(ckt->CKTstate0 + here->B1cddb) =
235  *(ckt->CKTstate1 + here->B1cddb);
236  *(ckt->CKTstate0 + here->B1cdsb) =
237  *(ckt->CKTstate1 + here->B1cdsb);
238  } else {
239 #endif /* PREDICTOR */
240  vbs = model->B1type * (
241  *(ckt->CKTrhsOld+here->B1bNode) -
242  *(ckt->CKTrhsOld+here->B1sNodePrime));
243  vgs = model->B1type * (
244  *(ckt->CKTrhsOld+here->B1gNode) -
245  *(ckt->CKTrhsOld+here->B1sNodePrime));
246  vds = model->B1type * (
247  *(ckt->CKTrhsOld+here->B1dNodePrime) -
248  *(ckt->CKTrhsOld+here->B1sNodePrime));
249 #ifndef PREDICTOR
250  }
251 #endif /* PREDICTOR */
252  vbd=vbs-vds;
253  vgd=vgs-vds;
254  vgdo = *(ckt->CKTstate0 + here->B1vgs) -
255  *(ckt->CKTstate0 + here->B1vds);
256  delvbs = vbs - *(ckt->CKTstate0 + here->B1vbs);
257  delvbd = vbd - *(ckt->CKTstate0 + here->B1vbd);
258  delvgs = vgs - *(ckt->CKTstate0 + here->B1vgs);
259  delvds = vds - *(ckt->CKTstate0 + here->B1vds);
260  delvgd = vgd-vgdo;
261 
262  if (here->B1mode >= 0) {
263  cdhat=
264  *(ckt->CKTstate0 + here->B1cd) -
265  *(ckt->CKTstate0 + here->B1gbd) * delvbd +
266  *(ckt->CKTstate0 + here->B1gmbs) * delvbs +
267  *(ckt->CKTstate0 + here->B1gm) * delvgs +
268  *(ckt->CKTstate0 + here->B1gds) * delvds ;
269  } else {
270  cdhat=
271  *(ckt->CKTstate0 + here->B1cd) -
272  ( *(ckt->CKTstate0 + here->B1gbd) -
273  *(ckt->CKTstate0 + here->B1gmbs)) * delvbd -
274  *(ckt->CKTstate0 + here->B1gm) * delvgd +
275  *(ckt->CKTstate0 + here->B1gds) * delvds;
276  }
277  cbhat=
278  *(ckt->CKTstate0 + here->B1cbs) +
279  *(ckt->CKTstate0 + here->B1cbd) +
280  *(ckt->CKTstate0 + here->B1gbd) * delvbd +
281  *(ckt->CKTstate0 + here->B1gbs) * delvbs ;
282 
283 #ifndef NOBYPASS
284  /* now lets see if we can bypass (ugh) */
285 
286  /* following should be one big if connected by && all over
287  * the place, but some C compilers can't handle that, so
288  * we split it up here to let them digest it in stages
289  */
290  tempv = MAX(FABS(cbhat),FABS(*(ckt->CKTstate0 + here->B1cbs)
291  + *(ckt->CKTstate0 + here->B1cbd)))+ckt->CKTabstol;
292  if((!(ckt->CKTmode & MODEINITPRED)) && (ckt->CKTbypass) )
293  if( (FABS(delvbs) < (ckt->CKTreltol * MAX(FABS(vbs),
294  FABS(*(ckt->CKTstate0+here->B1vbs)))+
295  ckt->CKTvoltTol)) )
296  if ( (FABS(delvbd) < (ckt->CKTreltol * MAX(FABS(vbd),
297  FABS(*(ckt->CKTstate0+here->B1vbd)))+
298  ckt->CKTvoltTol)) )
299  if( (FABS(delvgs) < (ckt->CKTreltol * MAX(FABS(vgs),
300  FABS(*(ckt->CKTstate0+here->B1vgs)))+
301  ckt->CKTvoltTol)))
302  if ( (FABS(delvds) < (ckt->CKTreltol * MAX(FABS(vds),
303  FABS(*(ckt->CKTstate0+here->B1vds)))+
304  ckt->CKTvoltTol)) )
305  if( (FABS(cdhat- *(ckt->CKTstate0 + here->B1cd)) <
306  ckt->CKTreltol * MAX(FABS(cdhat),FABS(*(ckt->CKTstate0 +
307  here->B1cd))) + ckt->CKTabstol) )
308  if ( (FABS(cbhat-(*(ckt->CKTstate0 + here->B1cbs) +
309  *(ckt->CKTstate0 + here->B1cbd))) < ckt->CKTreltol *
310  tempv)) {
311  /* bypass code */
312  vbs = *(ckt->CKTstate0 + here->B1vbs);
313  vbd = *(ckt->CKTstate0 + here->B1vbd);
314  vgs = *(ckt->CKTstate0 + here->B1vgs);
315  vds = *(ckt->CKTstate0 + here->B1vds);
316  vgd = vgs - vds;
317  vgb = vgs - vbs;
318  cd = *(ckt->CKTstate0 + here->B1cd);
319  cbs = *(ckt->CKTstate0 + here->B1cbs);
320  cbd = *(ckt->CKTstate0 + here->B1cbd);
321  cdrain = here->B1mode * (cd + cbd);
322  gm = *(ckt->CKTstate0 + here->B1gm);
323  gds = *(ckt->CKTstate0 + here->B1gds);
324  gmbs = *(ckt->CKTstate0 + here->B1gmbs);
325  gbd = *(ckt->CKTstate0 + here->B1gbd);
326  gbs = *(ckt->CKTstate0 + here->B1gbs);
327  if((ckt->CKTmode & (MODETRAN | MODEAC)) ||
328  ((ckt->CKTmode & MODETRANOP) &&
329  (ckt->CKTmode & MODEUIC))) {
330  cggb = *(ckt->CKTstate0 + here->B1cggb);
331  cgdb = *(ckt->CKTstate0 + here->B1cgdb);
332  cgsb = *(ckt->CKTstate0 + here->B1cgsb);
333  cbgb = *(ckt->CKTstate0 + here->B1cbgb);
334  cbdb = *(ckt->CKTstate0 + here->B1cbdb);
335  cbsb = *(ckt->CKTstate0 + here->B1cbsb);
336  cdgb = *(ckt->CKTstate0 + here->B1cdgb);
337  cddb = *(ckt->CKTstate0 + here->B1cddb);
338  cdsb = *(ckt->CKTstate0 + here->B1cdsb);
339  capbs = *(ckt->CKTstate0 + here->B1capbs);
340  capbd = *(ckt->CKTstate0 + here->B1capbd);
341  ByPass = 1;
342  goto line755;
343  } else {
344  goto line850;
345  }
346  }
347 #endif /*NOBYPASS*/
348 
349  von = model->B1type * here->B1von;
350  if(*(ckt->CKTstate0 + here->B1vds) >=0) {
351  vgs = DEVfetlim(vgs,*(ckt->CKTstate0 + here->B1vgs)
352  ,von);
353  vds = vgs - vgd;
354  vds = DEVlimvds(vds,*(ckt->CKTstate0 + here->B1vds));
355  vgd = vgs - vds;
356  } else {
357  vgd = DEVfetlim(vgd,vgdo,von);
358  vds = vgs - vgd;
359  vds = -DEVlimvds(-vds,-(*(ckt->CKTstate0 + here->B1vds)));
360  vgs = vgd + vds;
361  }
362  if(vds >= 0) {
363  vcrit =CONSTvt0*log(CONSTvt0/(CONSTroot2*SourceSatCurrent));
364  vbs = DEVpnjlim(vbs,*(ckt->CKTstate0 + here->B1vbs),
365  CONSTvt0,vcrit,&Check); /* B1 test */
366  vbd = vbs-vds;
367  } else {
368  vcrit = CONSTvt0*log(CONSTvt0/(CONSTroot2*DrainSatCurrent));
369  vbd = DEVpnjlim(vbd,*(ckt->CKTstate0 + here->B1vbd),
370  CONSTvt0,vcrit,&Check); /* B1 test*/
371  vbs = vbd + vds;
372  }
373  }
374 
375  /* determine DC current and derivatives */
376  vbd = vbs - vds;
377  vgd = vgs - vds;
378  vgb = vgs - vbs;
379 
380 
381  if(vbs <= 0.0 ) {
382  gbs = SourceSatCurrent / CONSTvt0 + ckt->CKTgmin;
383  cbs = gbs * vbs ;
384  } else {
385  evbs = exp(vbs/CONSTvt0);
386  gbs = SourceSatCurrent*evbs/CONSTvt0 + ckt->CKTgmin;
387  cbs = SourceSatCurrent * (evbs-1) + ckt->CKTgmin * vbs ;
388  }
389  if(vbd <= 0.0) {
390  gbd = DrainSatCurrent / CONSTvt0 + ckt->CKTgmin;
391  cbd = gbd * vbd ;
392  } else {
393  evbd = exp(vbd/CONSTvt0);
394  gbd = DrainSatCurrent*evbd/CONSTvt0 +ckt->CKTgmin;
395  cbd = DrainSatCurrent *(evbd-1)+ckt->CKTgmin*vbd;
396  }
397  /* line 400 */
398  if(vds >= 0) {
399  /* normal mode */
400  here->B1mode = 1;
401  } else {
402  /* inverse mode */
403  here->B1mode = -1;
404  }
405  /* call B1evaluate to calculate drain current and its
406  * derivatives and charge and capacitances related to gate
407  * drain, and bulk
408  */
409  if( vds >= 0 ) {
410  B1evaluate(vds,vbs,vgs,here,model,&gm,&gds,&gmbs,&qgate,
411  &qbulk,&qdrn,&cggb,&cgdb,&cgsb,&cbgb,&cbdb,&cbsb,&cdgb,
412  &cddb,&cdsb,&cdrain,&von,&vdsat,ckt);
413  } else {
414  B1evaluate(-vds,vbd,vgd,here,model,&gm,&gds,&gmbs,&qgate,
415  &qbulk,&qsrc,&cggb,&cgsb,&cgdb,&cbgb,&cbsb,&cbdb,&csgb,
416  &cssb,&csdb,&cdrain,&von,&vdsat,ckt);
417  }
418 
419  here->B1von = model->B1type * von;
420  here->B1vdsat = model->B1type * vdsat;
421 
422 
423 
424  /*
425  * COMPUTE EQUIVALENT DRAIN CURRENT SOURCE
426  */
427  cd=here->B1mode * cdrain - cbd;
428  if ((ckt->CKTmode & (MODETRAN | MODEAC | MODEINITSMSIG)) ||
429  ((ckt->CKTmode & MODETRANOP ) &&
430  (ckt->CKTmode & MODEUIC))) {
431  /*
432  * charge storage elements
433  *
434  * bulk-drain and bulk-source depletion capacitances
435  * czbd : zero bias drain junction capacitance
436  * czbs : zero bias source junction capacitance
437  * czbdsw:zero bias drain junction sidewall capacitance
438  * czbssw:zero bias source junction sidewall capacitance
439  */
440 
441  czbd = model->B1unitAreaJctCap * DrainArea;
442  czbs = model->B1unitAreaJctCap * SourceArea;
443  czbdsw= model->B1unitLengthSidewallJctCap * DrainPerimeter;
444  czbssw= model->B1unitLengthSidewallJctCap * SourcePerimeter;
445  PhiB = model->B1bulkJctPotential;
446  PhiBSW = model->B1sidewallJctPotential;
447  MJ = model->B1bulkJctBotGradingCoeff;
448  MJSW = model->B1bulkJctSideGradingCoeff;
449 
450  /* Source Bulk Junction */
451  if( vbs < 0 ) {
452  arg = 1 - vbs / PhiB;
453  argsw = 1 - vbs / PhiBSW;
454  sarg = exp(-MJ*log(arg));
455  sargsw = exp(-MJSW*log(argsw));
456  *(ckt->CKTstate0 + here->B1qbs) =
457  PhiB * czbs * (1-arg*sarg)/(1-MJ) + PhiBSW *
458  czbssw * (1-argsw*sargsw)/(1-MJSW);
459  capbs = czbs * sarg + czbssw * sargsw ;
460  } else {
461  *(ckt->CKTstate0+here->B1qbs) =
462  vbs*(czbs+czbssw)+ vbs*vbs*(czbs*MJ*0.5/PhiB
463  + czbssw * MJSW * 0.5/PhiBSW);
464  capbs = czbs + czbssw + vbs *(czbs*MJ/PhiB+
465  czbssw * MJSW / PhiBSW );
466  }
467 
468  /* Drain Bulk Junction */
469  if( vbd < 0 ) {
470  arg = 1 - vbd / PhiB;
471  argsw = 1 - vbd / PhiBSW;
472  sarg = exp(-MJ*log(arg));
473  sargsw = exp(-MJSW*log(argsw));
474  *(ckt->CKTstate0 + here->B1qbd) =
475  PhiB * czbd * (1-arg*sarg)/(1-MJ) + PhiBSW *
476  czbdsw * (1-argsw*sargsw)/(1-MJSW);
477  capbd = czbd * sarg + czbdsw * sargsw ;
478  } else {
479  *(ckt->CKTstate0+here->B1qbd) =
480  vbd*(czbd+czbdsw)+ vbd*vbd*(czbd*MJ*0.5/PhiB
481  + czbdsw * MJSW * 0.5/PhiBSW);
482  capbd = czbd + czbdsw + vbd *(czbd*MJ/PhiB+
483  czbdsw * MJSW / PhiBSW );
484  }
485 
486  }
487 
488 
489 
490 
491  /*
492  * check convergence
493  */
494  /* troubleElts new in 3f2 */
495  if ( (here->B1off == 0) || (!(ckt->CKTmode & MODEINITFIX)) ){
496  if (Check == 1) {
497  ckt->CKTnoncon++;
498  ckt->CKTtroubleElt = (GENinstance *) here;
499 #ifndef NEWCONV
500  } else {
501  tol=ckt->CKTreltol*MAX(FABS(cdhat),FABS(cd))+ckt->CKTabstol;
502  if (FABS(cdhat-cd) >= tol) {
503  ckt->CKTnoncon++;
504  ckt->CKTtroubleElt = (GENinstance *) here;
505  } else {
506  tol=ckt->CKTreltol*MAX(FABS(cbhat),FABS(cbs+cbd))+
507  ckt->CKTabstol;
508  if (FABS(cbhat-(cbs+cbd)) > tol) {
509  ckt->CKTnoncon++;
510  ckt->CKTtroubleElt = (GENinstance *) here;
511  }
512  }
513 #endif /* NEWCONV */
514  }
515  }
516  *(ckt->CKTstate0 + here->B1vbs) = vbs;
517  *(ckt->CKTstate0 + here->B1vbd) = vbd;
518  *(ckt->CKTstate0 + here->B1vgs) = vgs;
519  *(ckt->CKTstate0 + here->B1vds) = vds;
520  *(ckt->CKTstate0 + here->B1cd) = cd;
521  *(ckt->CKTstate0 + here->B1cbs) = cbs;
522  *(ckt->CKTstate0 + here->B1cbd) = cbd;
523  *(ckt->CKTstate0 + here->B1gm) = gm;
524  *(ckt->CKTstate0 + here->B1gds) = gds;
525  *(ckt->CKTstate0 + here->B1gmbs) = gmbs;
526  *(ckt->CKTstate0 + here->B1gbd) = gbd;
527  *(ckt->CKTstate0 + here->B1gbs) = gbs;
528 
529  *(ckt->CKTstate0 + here->B1cggb) = cggb;
530  *(ckt->CKTstate0 + here->B1cgdb) = cgdb;
531  *(ckt->CKTstate0 + here->B1cgsb) = cgsb;
532 
533  *(ckt->CKTstate0 + here->B1cbgb) = cbgb;
534  *(ckt->CKTstate0 + here->B1cbdb) = cbdb;
535  *(ckt->CKTstate0 + here->B1cbsb) = cbsb;
536 
537  *(ckt->CKTstate0 + here->B1cdgb) = cdgb;
538  *(ckt->CKTstate0 + here->B1cddb) = cddb;
539  *(ckt->CKTstate0 + here->B1cdsb) = cdsb;
540 
541  *(ckt->CKTstate0 + here->B1capbs) = capbs;
542  *(ckt->CKTstate0 + here->B1capbd) = capbd;
543 
544  /* bulk and channel charge plus overlaps */
545 
546  if((!(ckt->CKTmode & (MODETRAN | MODEAC))) &&
547  ((!(ckt->CKTmode & MODETRANOP)) ||
548  (!(ckt->CKTmode & MODEUIC))) && (!(ckt->CKTmode
549  & MODEINITSMSIG))) goto line850;
550 
551 line755:
552  /* new 3f2 */
553  if( here->B1mode > 0 ) {
554 
555  args[0] = GateDrainOverlapCap;
556  args[1] = GateSourceOverlapCap;
557  args[2] = GateBulkOverlapCap;
558  args[3] = capbd;
559  args[4] = capbs;
560  args[5] = cggb;
561  args[6] = cgdb;
562  args[7] = cgsb;
563 
564  B1mosCap(ckt,vgd,vgs,vgb,
565  args,
566  /*
567  GateDrainOverlapCap,
568  GateSourceOverlapCap,GateBulkOverlapCap,
569  capbd,capbs,
570  cggb,cgdb,cgsb,
571  */
572  cbgb,cbdb,cbsb,
573  cdgb,cddb,cdsb,
574  &gcggb,&gcgdb,&gcgsb,
575  &gcbgb,&gcbdb,&gcbsb,
576  &gcdgb,&gcddb,&gcdsb,&gcsgb,&gcsdb,&gcssb,
577  &qgate,&qbulk,
578  &qdrn,&qsrc);
579  } else {
580 
581  args[0] = GateSourceOverlapCap;
582  args[1] = GateDrainOverlapCap;
583  args[2] = GateBulkOverlapCap;
584  args[3] = capbs;
585  args[4] = capbd;
586  args[5] = cggb;
587  args[6] = cgsb;
588  args[7] = cgdb;
589 
590  B1mosCap(ckt,vgs,vgd,vgb,
591  args,
592  /*
593  GateSourceOverlapCap,
594  GateDrainOverlapCap,GateBulkOverlapCap,
595  capbs,capbd,
596  cggb,cgsb,cgdb,
597  */
598  cbgb,cbsb,cbdb,
599  csgb,cssb,csdb,
600  &gcggb,&gcgsb,&gcgdb,
601  &gcbgb,&gcbsb,&gcbdb,
602  &gcsgb,&gcssb,&gcsdb,&gcdgb,&gcdsb,&gcddb,
603  &qgate,&qbulk,
604  &qsrc,&qdrn);
605  }
606 
607  /* old 3e2
608  if( here->B1mode > 0 ) {
609  B1mosCap(ckt,vgd,vgs,vgb,GateDrainOverlapCap,
610  GateSourceOverlapCap,GateBulkOverlapCap,capbd,capbs
611  ,cggb,cgdb,cgsb,cbgb,cbdb,cbsb,cdgb,cddb,cdsb
612  ,&gcggb,&gcgdb,&gcgsb,&gcbgb,&gcbdb,&gcbsb,&gcdgb
613  ,&gcddb,&gcdsb,&gcsgb,&gcsdb,&gcssb,&qgate,&qbulk
614  ,&qdrn,&qsrc);
615  } else {
616  B1mosCap(ckt,vgs,vgd,vgb,GateSourceOverlapCap,
617  GateDrainOverlapCap,GateBulkOverlapCap,capbs,capbd
618  ,cggb,cgsb,cgdb,cbgb,cbsb,cbdb,csgb,cssb,csdb
619  ,&gcggb,&gcgsb,&gcgdb,&gcbgb,&gcbsb,&gcbdb,&gcsgb
620  ,&gcssb,&gcsdb,&gcdgb,&gcdsb,&gcddb,&qgate,&qbulk
621  ,&qsrc,&qdrn);
622  }
623  */
624 
625  if(ByPass) goto line860;
626  *(ckt->CKTstate0 + here->B1qg) = qgate;
627  *(ckt->CKTstate0 + here->B1qd) = qdrn -
628  *(ckt->CKTstate0 + here->B1qbd);
629  *(ckt->CKTstate0 + here->B1qb) = qbulk +
630  *(ckt->CKTstate0 + here->B1qbd) +
631  *(ckt->CKTstate0 + here->B1qbs);
632 
633  /* store small signal parameters */
634  if((!(ckt->CKTmode & (MODEAC | MODETRAN))) &&
635  (ckt->CKTmode & MODETRANOP ) && (ckt->CKTmode &
636  MODEUIC )) goto line850;
637  if(ckt->CKTmode & MODEINITSMSIG ) {
638  *(ckt->CKTstate0+here->B1cggb) = cggb;
639  *(ckt->CKTstate0+here->B1cgdb) = cgdb;
640  *(ckt->CKTstate0+here->B1cgsb) = cgsb;
641  *(ckt->CKTstate0+here->B1cbgb) = cbgb;
642  *(ckt->CKTstate0+here->B1cbdb) = cbdb;
643  *(ckt->CKTstate0+here->B1cbsb) = cbsb;
644  *(ckt->CKTstate0+here->B1cdgb) = cdgb;
645  *(ckt->CKTstate0+here->B1cddb) = cddb;
646  *(ckt->CKTstate0+here->B1cdsb) = cdsb;
647  *(ckt->CKTstate0+here->B1capbd) = capbd;
648  *(ckt->CKTstate0+here->B1capbs) = capbs;
649 
650  goto line1000;
651  }
652 
653  if(ckt->CKTmode & MODEINITTRAN ) {
654  *(ckt->CKTstate1+here->B1qb) =
655  *(ckt->CKTstate0+here->B1qb) ;
656  *(ckt->CKTstate1+here->B1qg) =
657  *(ckt->CKTstate0+here->B1qg) ;
658  *(ckt->CKTstate1+here->B1qd) =
659  *(ckt->CKTstate0+here->B1qd) ;
660  }
661 
662 
663  NI_INTEG(ckt,geq,ceq,0.0,here->B1qb);
664  NI_INTEG(ckt,geq,ceq,0.0,here->B1qg);
665  NI_INTEG(ckt,geq,ceq,0.0,here->B1qd);
666 
667  goto line860;
668 
669 line850:
670  /* initialize to zero charge conductance and current */
671  ceqqg = ceqqb = ceqqd = 0.0;
672  gcdgb = gcddb = gcdsb = 0.0;
673  gcsgb = gcsdb = gcssb = 0.0;
674  gcggb = gcgdb = gcgsb = 0.0;
675  gcbgb = gcbdb = gcbsb = 0.0;
676  goto line900;
677 
678 line860:
679  /* evaluate equivalent charge current */
680  cqgate = *(ckt->CKTstate0 + here->B1iqg);
681  cqbulk = *(ckt->CKTstate0 + here->B1iqb);
682  cqdrn = *(ckt->CKTstate0 + here->B1iqd);
683  ceqqg = cqgate - gcggb * vgb + gcgdb * vbd + gcgsb * vbs;
684  ceqqb = cqbulk - gcbgb * vgb + gcbdb * vbd + gcbsb * vbs;
685  ceqqd = cqdrn - gcdgb * vgb + gcddb * vbd + gcdsb * vbs;
686 
687  if(ckt->CKTmode & MODEINITTRAN ) {
688  *(ckt->CKTstate1 + here->B1iqb) =
689  *(ckt->CKTstate0 + here->B1iqb);
690  *(ckt->CKTstate1 + here->B1iqg) =
691  *(ckt->CKTstate0 + here->B1iqg);
692  *(ckt->CKTstate1 + here->B1iqd) =
693  *(ckt->CKTstate0 + here->B1iqd);
694  }
695 
696  /*
697  * load current vector
698  */
699 line900:
700 
701  ceqbs = model->B1type * (cbs-(gbs-ckt->CKTgmin)*vbs);
702  ceqbd = model->B1type * (cbd-(gbd-ckt->CKTgmin)*vbd);
703 
704  ceqqg = model->B1type * ceqqg;
705  ceqqb = model->B1type * ceqqb;
706  ceqqd = model->B1type * ceqqd;
707  if (here->B1mode >= 0) {
708  xnrm=1;
709  xrev=0;
710  cdreq=model->B1type*(cdrain-gds*vds-gm*vgs-gmbs*vbs);
711  } else {
712  xnrm=0;
713  xrev=1;
714  cdreq = -(model->B1type)*(cdrain+gds*vds-gm*vgd-gmbs*vbd);
715  }
716 
717  *(ckt->CKTrhs + here->B1gNode) -= ceqqg;
718  *(ckt->CKTrhs + here->B1bNode) -=(ceqbs+ceqbd+ceqqb);
719  *(ckt->CKTrhs + here->B1dNodePrime) +=
720  (ceqbd-cdreq-ceqqd);
721  *(ckt->CKTrhs + here->B1sNodePrime) +=
722  (cdreq+ceqbs+ceqqg+ceqqb+ceqqd);
723 
724  /*
725  * load y matrix
726  */
727 
728  *(here->B1DdPtr) += (here->B1drainConductance);
729  *(here->B1GgPtr) += (gcggb);
730  *(here->B1SsPtr) += (here->B1sourceConductance);
731  *(here->B1BbPtr) += (gbd+gbs-gcbgb-gcbdb-gcbsb);
732  *(here->B1DPdpPtr) +=
733  (here->B1drainConductance+gds+gbd+xrev*(gm+gmbs)+gcddb);
734  *(here->B1SPspPtr) +=
735  (here->B1sourceConductance+gds+gbs+xnrm*(gm+gmbs)+gcssb);
736  *(here->B1DdpPtr) += (-here->B1drainConductance);
737  *(here->B1GbPtr) += (-gcggb-gcgdb-gcgsb);
738  *(here->B1GdpPtr) += (gcgdb);
739  *(here->B1GspPtr) += (gcgsb);
740  *(here->B1SspPtr) += (-here->B1sourceConductance);
741  *(here->B1BgPtr) += (gcbgb);
742  *(here->B1BdpPtr) += (-gbd+gcbdb);
743  *(here->B1BspPtr) += (-gbs+gcbsb);
744  *(here->B1DPdPtr) += (-here->B1drainConductance);
745  *(here->B1DPgPtr) += ((xnrm-xrev)*gm+gcdgb);
746  *(here->B1DPbPtr) += (-gbd+(xnrm-xrev)*gmbs-gcdgb-gcddb-gcdsb);
747  *(here->B1DPspPtr) += (-gds-xnrm*(gm+gmbs)+gcdsb);
748  *(here->B1SPgPtr) += (-(xnrm-xrev)*gm+gcsgb);
749  *(here->B1SPsPtr) += (-here->B1sourceConductance);
750  *(here->B1SPbPtr) += (-gbs-(xnrm-xrev)*gmbs-gcsgb-gcsdb-gcssb);
751  *(here->B1SPdpPtr) += (-gds-xrev*(gm+gmbs)+gcsdb);
752 
753 
754 line1000: ;
755 
756  } /* End of Mosfet Instance */
757 
758  } /* End of Model Instance */
759  return(OK);
760 }
double * B1SPbPtr
Definition: bsim1def.h:141
double B1von
Definition: bsim1def.h:48
double B1bulkJctPotential
Definition: bsim1def.h:379
#define MODEAC
Definition: cktdefs.h:146
double B1icVBS
Definition: bsim1def.h:45
double * B1GbPtr
Definition: bsim1def.h:114
double * B1DdpPtr
Definition: bsim1def.h:112
void B1mosCap()
double DEVlimvds()
#define MODEINITPRED
Definition: cktdefs.h:161
double CONSTroot2
Definition: main.c:913
GENinstance * CKTtroubleElt
Definition: cktdefs.h:229
#define MODETRAN
Definition: cktdefs.h:145
#define MODEDCTRANCURVE
Definition: cktdefs.h:152
#define MAX(a, b)
Definition: spdefs.h:135
double CKTdelta
Definition: cktdefs.h:78
double * B1BbPtr
Definition: bsim1def.h:106
double * B1DPdpPtr
Definition: bsim1def.h:108
double * B1DPdPtr
Definition: bsim1def.h:128
int B1type
Definition: bsim1def.h:306
#define MODEINITTRAN
Definition: cktdefs.h:160
double DEVfetlim()
double B1deltaL
Definition: bsim1def.h:329
double * B1GdpPtr
Definition: bsim1def.h:116
static double e
Definition: vectors.c:17
double CKTreltol
Definition: cktdefs.h:183
int B1sNodePrime
Definition: bsim1def.h:32
double * B1BgPtr
Definition: bsim1def.h:130
double B1sourceConductance
Definition: bsim1def.h:42
double * B1GspPtr
Definition: bsim1def.h:118
double B1vt0
Definition: bsim1def.h:76
double * B1SPdpPtr
Definition: bsim1def.h:143
double * B1DPspPtr
Definition: bsim1def.h:126
double B1drainConductance
Definition: bsim1def.h:43
double CKTabstol
Definition: cktdefs.h:180
#define OK
Definition: iferrmsg.h:17
double B1drainArea
Definition: bsim1def.h:36
double B1vdsat
Definition: bsim1def.h:49
double * CKTrhsOld
Definition: cktdefs.h:98
double * B1BdpPtr
Definition: bsim1def.h:122
double DEVpnjlim()
double B1icVGS
Definition: bsim1def.h:47
double B1unitLengthSidewallJctCap
Definition: bsim1def.h:384
double B1icVDS
Definition: bsim1def.h:46
#define NULL
Definition: spdefs.h:121
double B1jctSatCurDensity
Definition: bsim1def.h:378
B1instance * B1instances
Definition: bsim1def.h:303
double * B1BspPtr
Definition: bsim1def.h:124
#define MODEINITSMSIG
Definition: cktdefs.h:159
#define NI_INTEG(ckt, geq, ceq, cap, qcap)
Definition: devdefs.h:141
double B1sourceArea
Definition: bsim1def.h:37
#define MODETRANOP
Definition: cktdefs.h:151
double * B1SPgPtr
Definition: bsim1def.h:135
double B1w
Definition: bsim1def.h:35
double * B1DPbPtr
Definition: bsim1def.h:139
double B1gateBulkOverlapCap
Definition: bsim1def.h:374
double * B1SPsPtr
Definition: bsim1def.h:137
double * B1SspPtr
Definition: bsim1def.h:120
double * B1GgPtr
Definition: bsim1def.h:102
static char model[32]
Definition: subckt.c:76
#define MODEINITFIX
Definition: cktdefs.h:158
double B1sidewallJctPotential
Definition: bsim1def.h:382
int CKTbypass
Definition: cktdefs.h:169
#define FABS(a)
Definition: util.h:41
struct sBSIM1model * B1nextModel
Definition: bsim1def.h:301
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 B1l
Definition: bsim1def.h:34
double CONSTvt0
Definition: main.c:914
double CKTvoltTol
Definition: cktdefs.h:185
double CKTgmin
Definition: cktdefs.h:190
void B1evaluate()
double CKTdeltaOld[7]
Definition: cktdefs.h:79
int B1dNodePrime
Definition: bsim1def.h:31
double * B1DPgPtr
Definition: bsim1def.h:132
double B1unitAreaJctCap
Definition: bsim1def.h:383
int CKTnoncon
Definition: cktdefs.h:203
#define MODEDCOP
Definition: cktdefs.h:150
double B1gateSourceOverlapCap
Definition: bsim1def.h:372
double * B1SsPtr
Definition: bsim1def.h:104
double * B1DdPtr
Definition: bsim1def.h:100
long CKTmode
Definition: cktdefs.h:139
double B1drainPerimeter
Definition: bsim1def.h:40
double B1sourcePerimeter
Definition: bsim1def.h:41
#define MODEINITJCT
Definition: cktdefs.h:157
double * CKTrhs
Definition: cktdefs.h:97
#define MODEUIC
Definition: cktdefs.h:166
double * B1SPspPtr
Definition: bsim1def.h:110