Jspice3
mosdset.c File Reference
#include "spice.h"
#include <stdio.h>
#include <math.h>
#include "mosdefs.h"
#include "distodef.h"
#include "const.h"
#include "sperror.h"
#include "util.h"
#include "distoext.h"
Include dependency graph for mosdset.c:

Go to the source code of this file.

Macros

#define P16   .16666666667
 
#define MOD_D_DELTA   1e-5
 

Functions

static void mos_deriv ()
 
static double mos_exec ()
 
int MOSdSetup (GENmodel *inModel, CKTcircuit *ckt)
 
static void mos_deriv (MOSmodel *model, MOSinstance *here, struct mosstuff *ms, Dderivs *cd)
 
static double mos_exec (MOSmodel *model, MOSinstance *here, struct mosstuff *ms, double dvgs, double dvbs, double dvds)
 

Macro Definition Documentation

#define MOD_D_DELTA   1e-5

Definition at line 19 of file mosdset.c.

#define P16   .16666666667

Definition at line 18 of file mosdset.c.

Function Documentation

static void mos_deriv ( )
static
static void mos_deriv ( MOSmodel model,
MOSinstance here,
struct mosstuff ms,
Dderivs cd 
)
static

Definition at line 370 of file mosdset.c.

376 {
377  double delta = MOD_D_DELTA, dd = 1.0/delta;
378 
379  double a222 = mos_exec(model,here,ms,0.0,0.0,0.0);
380 
381  double a322 = mos_exec(model,here,ms,delta,0.0,0.0);
382  double a232 = mos_exec(model,here,ms,0.0,delta,0.0);
383  double a223 = mos_exec(model,here,ms,0.0,0.0,delta);
384 
385  double a122 = mos_exec(model,here,ms,-delta,0.0,0.0);
386  double a212 = mos_exec(model,here,ms,0.0,-delta,0.0);
387  double a221 = mos_exec(model,here,ms,0.0,0.0,-delta);
388 
389  double a233 = mos_exec(model,here,ms,0.0,delta,delta);
390  double a323 = mos_exec(model,here,ms,delta,0.0,delta);
391  double a332 = mos_exec(model,here,ms,delta,delta,0.0);
392 
393  double a333 = mos_exec(model,here,ms,delta,delta,delta);
394 
395  double a123 = mos_exec(model,here,ms,-delta,0.0,delta);
396  double a132 = mos_exec(model,here,ms,-delta,delta,0.0);
397  double a213 = mos_exec(model,here,ms,0.0,-delta,delta);
398  double a312 = mos_exec(model,here,ms,delta,-delta,0.0);
399  double a321 = mos_exec(model,here,ms,delta,0.0,-delta);
400  double a231 = mos_exec(model,here,ms,0.0,delta,-delta);
401 
402 
403  double a022 = mos_exec(model,here,ms,-(delta+delta),0.0,0.0);
404  double a202 = mos_exec(model,here,ms,0.0,-(delta+delta),0.0);
405  double a220 = mos_exec(model,here,ms,0.0,0.0,-(delta+delta));
406 
407  cd->d2_p2 = ((a322 - a222)*dd - (a222 - a122)*dd)*dd;
408  cd->d2_q2 = ((a232 - a222)*dd - (a222 - a212)*dd)*dd;
409  cd->d2_r2 = ((a223 - a222)*dd - (a222 - a221)*dd)*dd;
410  cd->d2_pq = ((a332 - a322)*dd - (a232 - a222)*dd)*dd;
411  cd->d2_qr = ((a233 - a232)*dd - (a223 - a222)*dd)*dd;
412  cd->d2_pr = ((a323 - a322)*dd - (a223 - a222)*dd)*dd;
413 
414  cd->d3_p3 = (((a322 - a222)*dd - (a222 - a122)*dd)*dd -
415  ((a222 - a122)*dd - (a122 - a022)*dd)*dd)*dd;
416  cd->d3_q3 = (((a232 - a222)*dd - (a222 - a212)*dd)*dd -
417  ((a222 - a212)*dd - (a212 - a202)*dd)*dd)*dd;
418  cd->d3_r3 = (((a223 - a222)*dd - (a222 - a221)*dd)*dd -
419  ((a222 - a221)*dd - (a221 - a220)*dd)*dd)*dd;
420 
421  cd->d3_p2r = (((a323 - a223)*dd - (a223 - a123)*dd)*dd -
422  ((a322 - a222)*dd - (a222 - a122)*dd)*dd)*dd;
423 
424  cd->d3_p2q = (((a332 - a232)*dd - (a232 - a132)*dd)*dd -
425  ((a322 - a222)*dd - (a222 - a122)*dd)*dd)*dd;
426 
427  cd->d3_q2r = (((a233 - a223)*dd - (a223 - a213)*dd)*dd -
428  ((a232 - a222)*dd - (a222 - a212)*dd)*dd)*dd;
429 
430  cd->d3_pq2 = (((a332 - a232)*dd - (a322 - a222)*dd)*dd -
431  ((a322 - a222)*dd - (a312 - a212)*dd)*dd)*dd;
432 
433  cd->d3_pr2 = (((a323 - a223)*dd - (a322 - a222)*dd)*dd -
434  ((a322 - a222)*dd - (a321 - a221)*dd)*dd)*dd;
435 
436  cd->d3_qr2 = (((a233 - a223)*dd - (a232 - a222)*dd)*dd -
437  ((a232 - a222)*dd - (a231 - a221)*dd)*dd)*dd;
438 
439  cd->d3_pqr = (((a333 - a233)*dd - (a323 - a223)*dd)*dd -
440  ((a332 - a232)*dd - (a322 - a222)*dd)*dd)*dd;
441 
442 }
double d2_pr
Definition: distodef.h:75
double d3_pr2
Definition: distodef.h:83
double d3_pq2
Definition: distodef.h:81
double d3_p3
Definition: distodef.h:76
double d2_pq
Definition: distodef.h:73
double d3_pqr
Definition: distodef.h:85
double d2_r2
Definition: distodef.h:72
double d3_p2r
Definition: distodef.h:80
double d2_qr
Definition: distodef.h:74
double d3_qr2
Definition: distodef.h:84
double d3_q3
Definition: distodef.h:77
static double mos_exec()
double d3_q2r
Definition: distodef.h:82
double d3_r3
Definition: distodef.h:78
double d3_p2q
Definition: distodef.h:79
double d2_q2
Definition: distodef.h:71
#define MOD_D_DELTA
Definition: mosdset.c:19
double d2_p2
Definition: distodef.h:70
static double mos_exec ( )
static
static double mos_exec ( MOSmodel model,
MOSinstance here,
struct mosstuff ms,
double  dvgs,
double  dvbs,
double  dvds 
)
static

Definition at line 446 of file mosdset.c.

452 {
453  double vgs, vbs, vds;
454 
455  vgs = ms->ms_vgs;
456  vbs = ms->ms_vbs;
457  vds = ms->ms_vds;
458 
459  ms->ms_vgs += dvgs;
460  ms->ms_vbs += dvbs;
461  ms->ms_vds += dvds;
462  ms->ms_vbd = ms->ms_vbs - ms->ms_vds;
463  ms->ms_vgd = ms->ms_vgs - ms->ms_vds;
464  ms->ms_vgb = ms->ms_vgs - ms->ms_vbs;
465 
466  if (model->MOSlevel == 1)
467  ms->ms_cdrain = MOSeq1(model,here,ms);
468  else if (model->MOSlevel == 2)
469  ms->ms_cdrain = MOSeq2(model,here,ms);
470  /* CryoMOS Luong Huynh, 1/19/95 */
471  else if (model->MOSlevel == 8)
472  ms->ms_cdrain = cryoMOSeq(model,here,ms);
473  else
474  ms->ms_cdrain = MOSeq3(model,here,ms);
475 
476  ms->ms_vgs = vgs;
477  ms->ms_vbs = vbs;
478  ms->ms_vds = vds;
479  ms->ms_vbd = ms->ms_vbs - ms->ms_vds;
480  ms->ms_vgd = ms->ms_vgs - ms->ms_vds;
481  ms->ms_vgb = ms->ms_vgs - ms->ms_vbs;
482 
483  return (ms->ms_cdrain);
484 }
double ms_vbd
Definition: mosdefs.h:612
double ms_vbs
Definition: mosdefs.h:611
double MOSeq3()
double ms_vds
Definition: mosdefs.h:610
double MOSeq2()
int MOSlevel
Definition: mosdefs.h:280
double ms_vgb
Definition: mosdefs.h:613
double ms_vgd
Definition: mosdefs.h:614
double ms_cdrain
Definition: mosdefs.h:618
double ms_vgs
Definition: mosdefs.h:609
double cryoMOSeq()
double MOSeq1()
int MOSdSetup ( GENmodel inModel,
CKTcircuit ckt 
)

Definition at line 32 of file mosdset.c.

39 {
40  MOSmodel *model = (MOSmodel *)inModel;
41  MOSinstance *here;
42  struct mosstuff ms;
43  double arg;
44  double cdrain;
45  double evb;
46  double vgst;
47  double sarg;
48  double sargsw;
49  double lcapgs2;
50  double lcapgd2;
51  double lcapgb2;
52  double lcapgs3;
53  double lcapgd3;
54  double lcapgb3;
55  double lgbs, lgbs2, lgbs3;
56  double lgbd, lgbd2, lgbd3;
57  double lcapbs, lcapbs2, lcapbs3;
58  double lcapbd, lcapbd2, lcapbd3;
59  Dderivs cd;
60 
61  /* loop through all the MOS device models */
62  for ( ; model != NULL; model = model->MOSnextModel) {
63 
64  /* loop through all the instances of the model */
65  for (here = model->MOSinstances; here != NULL ;
66  here = here->MOSnextInstance) {
67 
68  ms.ms_vt = CONSTKoverQ * here->MOStemp;
69 
70  if (model->MOStype > 0) {
71  ms.ms_vbs = *(ckt->CKTrhsOld + here->MOSbNode) -
72  *(ckt->CKTrhsOld + here->MOSsNodePrime);
73  ms.ms_vgs = *(ckt->CKTrhsOld + here->MOSgNode) -
74  *(ckt->CKTrhsOld + here->MOSsNodePrime);
75  ms.ms_vds = *(ckt->CKTrhsOld + here->MOSdNodePrime) -
76  *(ckt->CKTrhsOld + here->MOSsNodePrime);
77  }
78  else {
79  ms.ms_vbs = *(ckt->CKTrhsOld + here->MOSsNodePrime) -
80  *(ckt->CKTrhsOld + here->MOSbNode);
81  ms.ms_vgs = *(ckt->CKTrhsOld + here->MOSsNodePrime) -
82  *(ckt->CKTrhsOld + here->MOSgNode);
83  ms.ms_vds = *(ckt->CKTrhsOld + here->MOSsNodePrime) -
84  *(ckt->CKTrhsOld + here->MOSdNodePrime);
85  }
86  ms.ms_vbd = ms.ms_vbs - ms.ms_vds;
87  ms.ms_vgd = ms.ms_vgs - ms.ms_vds;
88  ms.ms_vgb = ms.ms_vgs - ms.ms_vbs;
89 
90 
91  /*
92  * bulk-source and bulk-drain diodes
93  * here we just evaluate the ideal diode current and the
94  * corresponding derivative (conductance).
95  */
96 
97  if (ms.ms_vbs <= 0) {
98  lgbs = here->MOStSourceSatCur/ms.ms_vt + ckt->CKTgmin;
99  lgbs2 = lgbs3 = 0;
100  }
101  else {
102  evb = exp(ms.ms_vbs/ms.ms_vt);
103  lgbs = here->MOStSourceSatCur*evb/ms.ms_vt + ckt->CKTgmin;
104  if (model->MOStype > 0) {
105  lgbs2 = 0.5*(lgbs - ckt->CKTgmin)/ms.ms_vt;
106  lgbs3 = lgbs2/(ms.ms_vt*3);
107  }
108  else {
109  lgbs2 = -0.5*(lgbs - ckt->CKTgmin)/ms.ms_vt;
110  lgbs3 = -lgbs2/(ms.ms_vt*3);
111  }
112 
113  }
114  if (ms.ms_vbd <= 0) {
115  lgbd = here->MOStDrainSatCur/ms.ms_vt + ckt->CKTgmin;
116  lgbd2 = lgbd3 = 0;
117  }
118  else {
119  evb = exp(ms.ms_vbd/ms.ms_vt);
120  lgbd = here->MOStDrainSatCur*evb/ms.ms_vt + ckt->CKTgmin;
121  if (model->MOStype > 0) {
122  lgbd2 = 0.5*(lgbd - ckt->CKTgmin)/ms.ms_vt;
123  lgbd3 = lgbd2/(ms.ms_vt*3);
124  }
125  else {
126  lgbd2 = -0.5*(lgbd - ckt->CKTgmin)/ms.ms_vt;
127  lgbd3 = -lgbd2/(ms.ms_vt*3);
128  }
129  }
130 
131  /* now to determine whether the user was able to correctly
132  * identify the source and drain of his device
133  */
134  if (ms.ms_vds >= 0) {
135  /* normal mode */
136  here->MOSmode = 1;
137  }
138  else {
139  /* inverse mode */
140  here->MOSmode = -1;
141  }
142 
143  mos_deriv(model,here,&ms,&cd);
144 
145  /*
146  * charge storage elements
147  * bulk-drain and bulk-source depletion capacitances
148  */
149 
150  if (ms.ms_vbs < here->MOStDepCap) {
151  arg = 1 - ms.ms_vbs/here->MOStBulkPot;
152 
153  SARGS(arg,model->MOSbulkJctBotGradingCoeff,
154  model->MOSbulkJctSideGradingCoeff,sarg,sargsw);
155 
156  lcapbs = here->MOSCbs*sarg + here->MOSCbssw*sargsw;
157  lcapbs2 = 0.5/here->MOStBulkPot*
158  (here->MOSCbs*model->MOSbulkJctBotGradingCoeff*sarg +
159  here->MOSCbssw*model->MOSbulkJctSideGradingCoeff*sargsw)
160  /arg;
161  if (model->MOStype < 0)
162  lcapbs2 = -lcapbs2;
163  lcapbs3 = here->MOSCbs*sarg*
165  (model->MOSbulkJctBotGradingCoeff+1);
166  lcapbs3 += here->MOSCbssw*sargsw*
168  (model->MOSbulkJctSideGradingCoeff+1);
169  lcapbs3 = lcapbs3/(6*here->MOStBulkPot*
170  here->MOStBulkPot*arg*arg);
171  }
172  else {
173  lcapbs = here->MOSf2s + here->MOSf3s*ms.ms_vbs;
174  lcapbs2 = 0.5*here->MOSf3s;
175  lcapbs3 = 0;
176  }
177 
178  if (ms.ms_vbd < here->MOStDepCap) {
179  arg = 1 - ms.ms_vbd/here->MOStBulkPot;
180 
181  SARGS(arg,model->MOSbulkJctBotGradingCoeff,
182  model->MOSbulkJctSideGradingCoeff,sarg,sargsw);
183 
184  lcapbd = here->MOSCbd*sarg + here->MOSCbdsw*sargsw;
185  lcapbd2 = model->MOStype*0.5/here->MOStBulkPot*
186  (here->MOSCbd*model->MOSbulkJctBotGradingCoeff*sarg +
187  here->MOSCbdsw*model->MOSbulkJctSideGradingCoeff*sargsw)
188  /arg;
189  if (model->MOStype < 0)
190  lcapbd2 = -lcapbd2;
191  lcapbd3 = here->MOSCbd*sarg*
193  (model->MOSbulkJctBotGradingCoeff+1);
194  lcapbd3 += here->MOSCbdsw*sargsw*
196  (model->MOSbulkJctSideGradingCoeff+1);
197  lcapbd3 = lcapbd3/(6*here->MOStBulkPot*
198  here->MOStBulkPot*arg*arg);
199  }
200  else {
201  lcapbd = here->MOSf2d + ms.ms_vbd * here->MOSf3d;
202  lcapbd2 = 0.5*here->MOSf3d;
203  lcapbd3 = 0;
204  }
205 
206  /*
207  * meyer's capacitor model
208  */
209 
210  /* von, vgst and vdsat have already been adjusted for
211  * possible source-drain interchange
212  */
213  lcapgb2 = 0;
214  lcapgb3 = 0;
215  lcapgs2 = 0;
216  lcapgs3 = 0;
217  lcapgd2 = 0;
218  lcapgd3 = 0;
219 
220  if (here->MOSmode > 0)
221  vgst = ms.ms_vgs - ms.ms_von;
222  else
223  vgst = ms.ms_vgd - ms.ms_von;
224 
225  if (vgst > -here->MOStPhi) {
226 
227  if (vgst <= -.5*here->MOStPhi) {
228  lcapgb2 = -here->MOSoxideCap/(4*here->MOStPhi);
229  }
230  else if (vgst <= 0) {
231  lcapgb2 = -here->MOSoxideCap/(4*here->MOStPhi);
232  lcapgs2 = here->MOSoxideCap/(3*here->MOStPhi);
233  }
234  else {
235  double vds;
236 
237  if (here->MOSmode > 0)
238  vds = ms.ms_vds;
239  else
240  vds = -ms.ms_vds;
241 
242  if (ms.ms_vdsat > vds) {
243  double vddif, vddif1, vddif2, x1, x2;
244 
245  vddif = 2.0*ms.ms_vdsat - vds;
246  vddif1 = ms.ms_vdsat - vds;
247  vddif2 = vddif*vddif;
248  x1 = 1/(3*vddif*vddif2);
249  x2 = 1/(9*vddif2*vddif2);
250 
251  lcapgd2 = -ms.ms_vdsat*vds*here->MOSoxideCap*x1;
252  lcapgd3 = -vds*
253  here->MOSoxideCap*(vddif - 6*ms.ms_vdsat)*x2;
254  lcapgs2 = -vddif1*vds*here->MOSoxideCap*x1;
255  lcapgs3 = -vds*
256  here->MOSoxideCap*(vddif - 6*vddif1)*x2;
257  }
258  }
259  if (model->MOStype < 0) {
260  lcapgb2 = -lcapgb2;
261  lcapgs2 = -lcapgs2;
262  lcapgd2 = -lcapgd2;
263  }
264  }
265 
266  /* the b-s and b-d diodes need no processing ... */
267  here->capbs2 = lcapbs2;
268  here->capbs3 = lcapbs3;
269  here->capbd2 = lcapbd2;
270  here->capbd3 = lcapbd3;
271  here->gbs2 = lgbs2;
272  here->gbs3 = lgbs3;
273  here->gbd2 = lgbd2;
274  here->gbd3 = lgbd3;
275  here->capgb2 = lcapgb2;
276  here->capgb3 = lcapgb3;
277 
278  /*
279  * process to get Taylor coefficients, taking into
280  * account type and mode.
281  */
282 
283  if (here->MOSmode == 1) {
284  /* normal mode - no source-drain interchange */
285 
286  here->capgs2 = lcapgs2;
287  here->capgs3 = lcapgs3;
288  here->capgd2 = lcapgd2;
289  here->capgd3 = lcapgd3;
290 
291  if (model->MOStype > 0) {
292  here->cdr_x2 = .5*cd.d2_p2;
293  here->cdr_y2 = .5*cd.d2_q2;
294  here->cdr_z2 = .5*cd.d2_r2;
295  here->cdr_xy = cd.d2_pq;
296  here->cdr_yz = cd.d2_qr;
297  here->cdr_xz = cd.d2_pr;
298  }
299  else {
300  here->cdr_x2 = -.5*cd.d2_p2;
301  here->cdr_y2 = -.5*cd.d2_q2;
302  here->cdr_z2 = -.5*cd.d2_r2;
303  here->cdr_xy = -cd.d2_pq;
304  here->cdr_yz = -cd.d2_qr;
305  here->cdr_xz = -cd.d2_pr;
306  }
307  here->cdr_x3 = cd.d3_p3*P16;
308  here->cdr_y3 = cd.d3_q3*P16;
309  here->cdr_z3 = cd.d3_r3*P16;
310  here->cdr_x2z = .5*cd.d3_p2r;
311  here->cdr_x2y = .5*cd.d3_p2q;
312  here->cdr_y2z = .5*cd.d3_q2r;
313  here->cdr_xy2 = .5*cd.d3_pq2;
314  here->cdr_xz2 = .5*cd.d3_pr2;
315  here->cdr_yz2 = .5*cd.d3_qr2;
316  here->cdr_xyz = cd.d3_pqr;
317 
318 
319  }
320  else {
321  /* inverse mode - source and drain interchanged */
322  here->capgs2 = lcapgd2;
323  here->capgs3 = lcapgd3;
324  here->capgd2 = lcapgs2;
325  here->capgd3 = lcapgs3;
326 
327  if (model->MOStype > 0) {
328  here->cdr_x2 = -.5*cd.d2_p2;
329  here->cdr_y2 = -.5*cd.d2_q2;
330  here->cdr_z2 = -.5*(cd.d2_p2 + cd.d2_q2 + cd.d2_r2 +
331  2*(cd.d2_pq + cd.d2_pr + cd.d2_qr));
332  here->cdr_xy = -cd.d2_pq;
333  here->cdr_yz = cd.d2_pq + cd.d2_q2 + cd.d2_qr;
334  here->cdr_xz = cd.d2_p2 + cd.d2_pq + cd.d2_pr;
335  }
336  else {
337  here->cdr_x2 = .5*cd.d2_p2;
338  here->cdr_y2 = .5*cd.d2_q2;
339  here->cdr_z2 = .5*(cd.d2_p2 + cd.d2_q2 + cd.d2_r2 +
340  2*(cd.d2_pq + cd.d2_pr + cd.d2_qr));
341  here->cdr_xy = cd.d2_pq;
342  here->cdr_yz = -(cd.d2_pq + cd.d2_q2 + cd.d2_qr);
343  here->cdr_xz = -(cd.d2_p2 + cd.d2_pq + cd.d2_pr);
344  }
345 
346  here->cdr_x3 = -P16*cd.d3_p3;
347  here->cdr_y3 = -P16*cd.d3_q3;
348  here->cdr_z3 = P16*(cd.d3_p3 + cd.d3_q3 + cd.d3_r3 +
349  3*(cd.d3_p2q + cd.d3_p2r + cd.d3_pq2 +
350  cd.d3_q2r + cd.d3_pr2 + cd.d3_qr2) +
351  6*cd.d3_pqr);
352  here->cdr_x2z = .5*(cd.d3_p3 + cd.d3_p2q + cd.d3_p2r);
353  here->cdr_x2y = -.5*cd.d3_p2q;
354  here->cdr_y2z = .5*(cd.d3_pq2 + cd.d3_q3 + cd.d3_q2r);
355  here->cdr_xy2 = -.5*cd.d3_pq2;
356  here->cdr_xz2 = -.5*(cd.d3_p3 + 2*(cd.d3_p2q + cd.d3_p2r +
357  cd.d3_pqr) + cd.d3_pq2 + cd.d3_pr2);
358  here->cdr_yz2 = -.5*(cd.d3_q3 + 2*(cd.d3_pq2 + cd.d3_q2r +
359  cd.d3_pqr) + cd.d3_p2q + cd.d3_qr2);
360  here->cdr_xyz = cd.d3_p2q + cd.d3_pq2 + cd.d3_pqr;
361 
362  }
363  }
364  }
365  return(OK);
366 }
double d2_pr
Definition: distodef.h:75
double d3_pr2
Definition: distodef.h:83
struct sMOSmodel * MOSnextModel
Definition: mosdefs.h:274
double MOStBulkPot
Definition: mosdefs.h:57
MOSinstance * MOSinstances
Definition: mosdefs.h:276
double MOStemp
Definition: mosdefs.h:44
double d3_pq2
Definition: distodef.h:81
double d3_p3
Definition: distodef.h:76
double d2_pq
Definition: distodef.h:73
double MOStDepCap
Definition: mosdefs.h:58
double MOSbulkJctBotGradingCoeff
Definition: mosdefs.h:298
int MOStype
Definition: mosdefs.h:279
double MOSCbs
Definition: mosdefs.h:82
double d3_pqr
Definition: distodef.h:85
double CONSTKoverQ
Definition: main.c:915
int MOSdNodePrime
Definition: mosdefs.h:29
double d2_r2
Definition: distodef.h:72
double MOSCbdsw
Definition: mosdefs.h:81
double MOSf3d
Definition: mosdefs.h:85
double MOSbulkJctSideGradingCoeff
Definition: mosdefs.h:300
#define SARGS(arg, bot, side, sarg, sargsw)
Definition: mosdefs.h:651
double MOStDrainSatCur
Definition: mosdefs.h:60
#define OK
Definition: iferrmsg.h:17
double * CKTrhsOld
Definition: cktdefs.h:98
double d3_p2r
Definition: distodef.h:80
#define P16
Definition: mosdset.c:18
int MOSgNode
Definition: mosdefs.h:26
double d2_qr
Definition: distodef.h:74
#define NULL
Definition: spdefs.h:121
double d3_qr2
Definition: distodef.h:84
double MOSCbd
Definition: mosdefs.h:80
double d3_q3
Definition: distodef.h:77
double MOSCbssw
Definition: mosdefs.h:83
int MOSsNodePrime
Definition: mosdefs.h:30
double MOSoxideCap
Definition: mosdefs.h:96
double MOStSourceSatCur
Definition: mosdefs.h:61
double MOStPhi
Definition: mosdefs.h:49
static char model[32]
Definition: subckt.c:76
int MOSmode
Definition: mosdefs.h:32
double MOSf2d
Definition: mosdefs.h:84
double d3_q2r
Definition: distodef.h:82
double MOSf2s
Definition: mosdefs.h:87
int MOSbNode
Definition: mosdefs.h:28
double CKTgmin
Definition: cktdefs.h:190
double d3_r3
Definition: distodef.h:78
double d3_p2q
Definition: distodef.h:79
double d2_q2
Definition: distodef.h:71
struct sMOSinstance * MOSnextInstance
Definition: mosdefs.h:20
double MOSf3s
Definition: mosdefs.h:88
static void mos_deriv()
double d2_p2
Definition: distodef.h:70