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

Go to the source code of this file.

Functions

static double qggnew ()
 
int MESload (GENmodel *inModel, CKTcircuit *ckt)
 
static double qggnew (double vgs, double vgd, double phib, double vcap, double vto, double cgs, double cgd, double *cgsnew, double *cgdnew)
 

Function Documentation

int MESload ( GENmodel inModel,
CKTcircuit ckt 
)

Definition at line 26 of file mesload.c.

32 {
33  register MESmodel *model = (MESmodel*)inModel;
34  register MESinstance *here;
35  double afact;
36  double beta;
37  double betap;
38  double capgd;
39  double capgs;
40  double cd;
41  double cdhat;
42  double cdrain;
43  double cdreq;
44  double ceq;
45  double ceqgd;
46  double ceqgs;
47  double cg;
48  double cgd;
49  double cgdna,cgdnb,cgdnc,cgdnd;
50  double cghat;
51  double cgsna,cgsnb,cgsnc,cgsnd;
52  double csat;
53  double czgd;
54  double czgs;
55  double delvds;
56  double delvgd;
57  double delvgs;
58  double denom;
59  double evgd;
60  double evgs;
61  double gdpr;
62  double gds;
63  double geq;
64  double ggd;
65  double ggs;
66  double gm;
67  double gspr;
68  double invdenom;
69  double lfact;
70  double phib;
71  double prod;
72  double qgga,qggb,qggc,qggd;
73  double vcap;
74  double vcrit;
75  double vds;
76  double vgd;
77  double vgd1;
78  double vgdt;
79  double vgs;
80  double vgs1;
81  double vgst;
82  double vto;
83  double xfact;
84  int icheck;
85  int ichk1;
86  int error;
87 
88  /* loop through all the models */
89  for( ; model != NULL; model = model->MESnextModel ) {
90 
91  /* loop through all the instances of the model */
92  for (here = model->MESinstances; here != NULL ;
93  here=here->MESnextInstance) {
94 
95  /*
96  * dc model parameters
97  */
98  beta = model->MESbeta * here->MESarea;
99  gdpr = model->MESdrainConduct * here->MESarea;
100  gspr = model->MESsourceConduct * here->MESarea;
101  csat = model->MESgateSatCurrent * here->MESarea;
102  vcrit = model->MESvcrit;
103  vto = model->MESthreshold;
104  /*
105  * initialization
106  */
107  icheck = 1;
108  if( ckt->CKTmode & MODEINITSMSIG) {
109  vgs = *(ckt->CKTstate0 + here->MESvgs);
110  vgd = *(ckt->CKTstate0 + here->MESvgd);
111  } else if (ckt->CKTmode & MODEINITTRAN) {
112  vgs = *(ckt->CKTstate1 + here->MESvgs);
113  vgd = *(ckt->CKTstate1 + here->MESvgd);
114  } else if ( (ckt->CKTmode & MODEINITJCT) &&
115  (ckt->CKTmode & MODETRANOP) &&
116  (ckt->CKTmode & MODEUIC) ) {
117  vds = model->MEStype*here->MESicVDS;
118  vgs = model->MEStype*here->MESicVGS;
119  vgd = vgs-vds;
120  } else if ( (ckt->CKTmode & MODEINITJCT) &&
121  (here->MESoff == 0) ) {
122  vgs = -1;
123  vgd = -1;
124  } else if( (ckt->CKTmode & MODEINITJCT) ||
125  ((ckt->CKTmode & MODEINITFIX) && (here->MESoff))) {
126  vgs = 0;
127  vgd = 0;
128  } else {
129 #ifndef PREDICTOR
130  if(ckt->CKTmode & MODEINITPRED) {
131  xfact = ckt->CKTdelta/ckt->CKTdeltaOld[2];
132  *(ckt->CKTstate0 + here->MESvgs) =
133  *(ckt->CKTstate1 + here->MESvgs);
134  vgs = (1+xfact) * *(ckt->CKTstate1 + here->MESvgs) -
135  xfact * *(ckt->CKTstate2 + here->MESvgs);
136  *(ckt->CKTstate0 + here->MESvgd) =
137  *(ckt->CKTstate1 + here->MESvgd);
138  vgd = (1+xfact)* *(ckt->CKTstate1 + here->MESvgd) -
139  xfact * *(ckt->CKTstate2 + here->MESvgd);
140  *(ckt->CKTstate0 + here->MEScg) =
141  *(ckt->CKTstate1 + here->MEScg);
142  *(ckt->CKTstate0 + here->MEScd) =
143  *(ckt->CKTstate1 + here->MEScd);
144  *(ckt->CKTstate0 + here->MEScgd) =
145  *(ckt->CKTstate1 + here->MEScgd);
146  *(ckt->CKTstate0 + here->MESgm) =
147  *(ckt->CKTstate1 + here->MESgm);
148  *(ckt->CKTstate0 + here->MESgds) =
149  *(ckt->CKTstate1 + here->MESgds);
150  *(ckt->CKTstate0 + here->MESggs) =
151  *(ckt->CKTstate1 + here->MESggs);
152  *(ckt->CKTstate0 + here->MESggd) =
153  *(ckt->CKTstate1 + here->MESggd);
154  } else {
155 #endif /* PREDICTOR */
156  /*
157  * compute new nonlinear branch voltages
158  */
159  vgs = model->MEStype*
160  (*(ckt->CKTrhsOld+ here->MESgateNode)-
161  *(ckt->CKTrhsOld+
162  here->MESsourcePrimeNode));
163  vgd = model->MEStype*
164  (*(ckt->CKTrhsOld+here->MESgateNode)-
165  *(ckt->CKTrhsOld+
166  here->MESdrainPrimeNode));
167 #ifndef PREDICTOR
168  }
169 #endif /* PREDICTOR */
170  delvgs=vgs - *(ckt->CKTstate0 + here->MESvgs);
171  delvgd=vgd - *(ckt->CKTstate0 + here->MESvgd);
172  delvds=delvgs - delvgd;
173  cghat= *(ckt->CKTstate0 + here->MEScg) +
174  *(ckt->CKTstate0 + here->MESggd)*delvgd +
175  *(ckt->CKTstate0 + here->MESggs)*delvgs;
176  cdhat= *(ckt->CKTstate0 + here->MEScd) +
177  *(ckt->CKTstate0 + here->MESgm)*delvgs +
178  *(ckt->CKTstate0 + here->MESgds)*delvds -
179  *(ckt->CKTstate0 + here->MESggd)*delvgd;
180  /*
181  * bypass if solution has not changed
182  */
183  if((ckt->CKTbypass) &&
184  (!(ckt->CKTmode & MODEINITPRED)) &&
185  (FABS(delvgs) < ckt->CKTreltol*MAX(FABS(vgs),
186  FABS(*(ckt->CKTstate0 + here->MESvgs)))+
187  ckt->CKTvoltTol) )
188  if ( (FABS(delvgd) < ckt->CKTreltol*MAX(FABS(vgd),
189  FABS(*(ckt->CKTstate0 + here->MESvgd)))+
190  ckt->CKTvoltTol))
191  if ( (FABS(cghat-*(ckt->CKTstate0 + here->MEScg))
192  < ckt->CKTreltol*MAX(FABS(cghat),
193  FABS(*(ckt->CKTstate0 + here->MEScg)))+
194  ckt->CKTabstol) ) if ( /* hack - expression too big */
195  (FABS(cdhat-*(ckt->CKTstate0 + here->MEScd))
196  < ckt->CKTreltol*MAX(FABS(cdhat),
197  FABS(*(ckt->CKTstate0 + here->MEScd)))+
198  ckt->CKTabstol) ) {
199 
200  /* we can do a bypass */
201  vgs= *(ckt->CKTstate0 + here->MESvgs);
202  vgd= *(ckt->CKTstate0 + here->MESvgd);
203  vds= vgs-vgd;
204  cg= *(ckt->CKTstate0 + here->MEScg);
205  cd= *(ckt->CKTstate0 + here->MEScd);
206  cgd= *(ckt->CKTstate0 + here->MEScgd);
207  gm= *(ckt->CKTstate0 + here->MESgm);
208  gds= *(ckt->CKTstate0 + here->MESgds);
209  ggs= *(ckt->CKTstate0 + here->MESggs);
210  ggd= *(ckt->CKTstate0 + here->MESggd);
211  goto load;
212  }
213  /*
214  * limit nonlinear branch voltages
215  */
216  ichk1=1;
217  vgs = DEVpnjlim(vgs,*(ckt->CKTstate0 + here->MESvgs),CONSTvt0,
218  vcrit, &icheck);
219  vgd = DEVpnjlim(vgd,*(ckt->CKTstate0 + here->MESvgd),CONSTvt0,
220  vcrit,&ichk1);
221  if (ichk1 == 1) {
222  icheck=1;
223  }
224  vgs = DEVfetlim(vgs,*(ckt->CKTstate0 + here->MESvgs),
225  model->MESthreshold);
226  vgd = DEVfetlim(vgd,*(ckt->CKTstate0 + here->MESvgd),
227  model->MESthreshold);
228  }
229  /*
230  * determine dc current and derivatives
231  */
232  vds = vgs-vgd;
233  if (vgs <= -5*CONSTvt0) {
234  ggs = -csat/vgs+ckt->CKTgmin;
235  cg = ggs*vgs;
236  } else {
237  evgs = exp(vgs/CONSTvt0);
238  ggs = csat*evgs/CONSTvt0+ckt->CKTgmin;
239  cg = csat*(evgs-1)+ckt->CKTgmin*vgs;
240  }
241  if (vgd <= -5*CONSTvt0) {
242  ggd = -csat/vgd+ckt->CKTgmin;
243  cgd = ggd*vgd;
244  } else {
245  evgd = exp(vgd/CONSTvt0);
246  ggd = csat*evgd/CONSTvt0+ckt->CKTgmin;
247  cgd = csat*(evgd-1)+ckt->CKTgmin*vgd;
248  }
249  cg = cg+cgd;
250  /*
251  * compute drain current and derivitives for normal mode
252  */
253  if (vds >= 0) {
254  vgst = vgs-model->MESthreshold;
255  /*
256  * normal mode, cutoff region
257  */
258  if (vgst <= 0) {
259  cdrain = 0;
260  gm = 0;
261  gds = 0;
262  } else {
263  prod = 1 + model->MESlModulation * vds;
264  betap = beta * prod;
265  denom = 1 + model->MESb * vgst;
266  invdenom = 1 / denom;
267  if (vds >= ( 3 / model->MESalpha ) ) {
268  /*
269  * normal mode, saturation region
270  */
271  cdrain = betap * vgst * vgst * invdenom;
272  gm = betap * vgst * (1 + denom) * invdenom * invdenom;
273  gds = model->MESlModulation * beta * vgst * vgst *
274  invdenom;
275  } else {
276  /*
277  * normal mode, linear region
278  */
279  afact = 1 - model->MESalpha * vds / 3;
280  lfact = 1 - afact * afact * afact;
281  cdrain = betap * vgst * vgst * invdenom * lfact;
282  gm = betap * vgst * (1 + denom) * invdenom * invdenom *
283  lfact;
284  gds = beta * vgst * vgst * invdenom * (model->MESalpha *
285  afact * afact * prod + lfact *
286  model->MESlModulation);
287  }
288  }
289  } else {
290  /*
291  * compute drain current and derivitives for inverse mode
292  */
293  vgdt = vgd - model->MESthreshold;
294  if (vgdt <= 0) {
295  /*
296  * inverse mode, cutoff region
297  */
298  cdrain = 0;
299  gm = 0;
300  gds = 0;
301  } else {
302  /*
303  * inverse mode, saturation region
304  */
305  prod = 1 - model->MESlModulation * vds;
306  betap = beta * prod;
307  denom = 1 + model->MESb * vgdt;
308  invdenom = 1 / denom;
309  if ( -vds >= ( 3 / model->MESalpha ) ) {
310  cdrain = -betap * vgdt * vgdt * invdenom;
311  gm = -betap * vgdt * (1 + denom) * invdenom * invdenom;
312  gds = model->MESlModulation * beta * vgdt * vgdt *
313  invdenom-gm;
314  } else {
315  /*
316  * inverse mode, linear region
317  */
318  afact = 1 + model->MESalpha * vds / 3;
319  lfact = 1 - afact * afact * afact;
320  cdrain = -betap * vgdt * vgdt * invdenom * lfact;
321  gm = -betap * vgdt * (1 + denom) * invdenom *
322  invdenom * lfact;
323  gds = beta * vgdt * vgdt * invdenom * (model->MESalpha *
324  afact * afact * prod + lfact *
325  model->MESlModulation)-gm;
326  }
327  }
328  }
329  /*
330  * compute equivalent drain current source
331  */
332  cd = cdrain - cgd;
333  if ( (ckt->CKTmode & (MODETRAN|MODEINITSMSIG)) ||
334  ((ckt->CKTmode & MODETRANOP) && (ckt->CKTmode & MODEUIC)) ){
335  /*
336  * charge storage elements
337  */
338  czgs = model->MEScapGS * here->MESarea;
339  czgd = model->MEScapGD * here->MESarea;
340  phib = model->MESgatePotential;
341  vgs1 = *(ckt->CKTstate1 + here->MESvgs);
342  vgd1 = *(ckt->CKTstate1 + here->MESvgd);
343  vcap = 1 / model->MESalpha;
344 
345  qgga = qggnew(vgs,vgd,phib,vcap,vto,czgs,czgd,&cgsna,&cgdna);
346  qggb = qggnew(vgs1,vgd,phib,vcap,vto,czgs,czgd,&cgsnb,&cgdnb);
347  qggc = qggnew(vgs,vgd1,phib,vcap,vto,czgs,czgd,&cgsnc,&cgdnc);
348  qggd = qggnew(vgs1,vgd1,phib,vcap,vto,czgs,czgd,&cgsnd,&cgdnd);
349 
350  if(ckt->CKTmode & MODEINITTRAN) {
351  *(ckt->CKTstate1 + here->MESqgs) = qgga;
352  *(ckt->CKTstate1 + here->MESqgd) = qgga;
353  }
354  *(ckt->CKTstate0+here->MESqgs) = *(ckt->CKTstate1+here->MESqgs)
355  + 0.5 * (qgga-qggb + qggc-qggd);
356  *(ckt->CKTstate0+here->MESqgd) = *(ckt->CKTstate1+here->MESqgd)
357  + 0.5 * (qgga-qggc + qggb-qggd);
358  capgs = cgsna;
359  capgd = cgdna;
360 
361  /*
362  * store small-signal parameters
363  */
364  if( (!(ckt->CKTmode & MODETRANOP)) ||
365  (!(ckt->CKTmode & MODEUIC)) ) {
366  if(ckt->CKTmode & MODEINITSMSIG) {
367  *(ckt->CKTstate0 + here->MESqgs) = capgs;
368  *(ckt->CKTstate0 + here->MESqgd) = capgd;
369  continue; /*go to 1000*/
370  }
371  /*
372  * transient analysis
373  */
374  if(ckt->CKTmode & MODEINITTRAN) {
375  *(ckt->CKTstate1 + here->MESqgs) =
376  *(ckt->CKTstate0 + here->MESqgs);
377  *(ckt->CKTstate1 + here->MESqgd) =
378  *(ckt->CKTstate0 + here->MESqgd);
379  }
380  NI_INTEG(ckt,geq,ceq,capgs,here->MESqgs);
381  ggs = ggs + geq;
382  cg = cg + *(ckt->CKTstate0 + here->MEScqgs);
383  NI_INTEG(ckt,geq,ceq,capgd,here->MESqgd);
384  ggd = ggd + geq;
385  cg = cg + *(ckt->CKTstate0 + here->MEScqgd);
386  cd = cd - *(ckt->CKTstate0 + here->MEScqgd);
387  cgd = cgd + *(ckt->CKTstate0 + here->MEScqgd);
388  if (ckt->CKTmode & MODEINITTRAN) {
389  *(ckt->CKTstate1 + here->MEScqgs) =
390  *(ckt->CKTstate0 + here->MEScqgs);
391  *(ckt->CKTstate1 + here->MEScqgd) =
392  *(ckt->CKTstate0 + here->MEScqgd);
393  }
394  }
395  }
396  /*
397  * check convergence
398  */
399  if( (!(ckt->CKTmode & MODEINITFIX)) | (!(ckt->CKTmode & MODEUIC))) {
400  if( (icheck == 1)
401 #ifndef NEWCONV
402  || (FABS(cghat-cg) >= ckt->CKTreltol*
403  MAX(FABS(cghat),FABS(cg))+ckt->CKTabstol) ||
404  (FABS(cdhat-cd) > ckt->CKTreltol*
405  MAX(FABS(cdhat),FABS(cd))+ckt->CKTabstol)
406 #endif /* NEWCONV */
407  ) {
408  ckt->CKTnoncon++;
409  /* new in 3f2 */
410  ckt->CKTtroubleElt = (GENinstance *) here;
411  }
412  }
413  *(ckt->CKTstate0 + here->MESvgs) = vgs;
414  *(ckt->CKTstate0 + here->MESvgd) = vgd;
415  *(ckt->CKTstate0 + here->MEScg) = cg;
416  *(ckt->CKTstate0 + here->MEScd) = cd;
417  *(ckt->CKTstate0 + here->MEScgd) = cgd;
418  *(ckt->CKTstate0 + here->MESgm) = gm;
419  *(ckt->CKTstate0 + here->MESgds) = gds;
420  *(ckt->CKTstate0 + here->MESggs) = ggs;
421  *(ckt->CKTstate0 + here->MESggd) = ggd;
422  /*
423  * load current vector
424  */
425 load:
426  ceqgd=model->MEStype*(cgd-ggd*vgd);
427  ceqgs=model->MEStype*((cg-cgd)-ggs*vgs);
428  cdreq=model->MEStype*((cd+cgd)-gds*vds-gm*vgs);
429  *(ckt->CKTrhs + here->MESgateNode) += (-ceqgs-ceqgd);
430  *(ckt->CKTrhs + here->MESdrainPrimeNode) +=
431  (-cdreq+ceqgd);
432  *(ckt->CKTrhs + here->MESsourcePrimeNode) +=
433  (cdreq+ceqgs);
434  /*
435  * load y matrix
436  */
437  *(here->MESdrainDrainPrimePtr) += (-gdpr);
438  *(here->MESgateDrainPrimePtr) += (-ggd);
439  *(here->MESgateSourcePrimePtr) += (-ggs);
440  *(here->MESsourceSourcePrimePtr) += (-gspr);
441  *(here->MESdrainPrimeDrainPtr) += (-gdpr);
442  *(here->MESdrainPrimeGatePtr) += (gm-ggd);
443  *(here->MESdrainPrimeSourcePrimePtr) += (-gds-gm);
444  *(here->MESsourcePrimeGatePtr) += (-ggs-gm);
445  *(here->MESsourcePrimeSourcePtr) += (-gspr);
446  *(here->MESsourcePrimeDrainPrimePtr) += (-gds);
447  *(here->MESdrainDrainPtr) += (gdpr);
448  *(here->MESgateGatePtr) += (ggd+ggs);
449  *(here->MESsourceSourcePtr) += (gspr);
450  *(here->MESdrainPrimeDrainPrimePtr) += (gdpr+gds+ggd);
451  *(here->MESsourcePrimeSourcePrimePtr) += (gspr+gds+gm+ggs);
452  }
453  }
454  return(OK);
455 }
int MEStype
Definition: mesdefs.h:166
#define MODEINITPRED
Definition: cktdefs.h:161
GENinstance * CKTtroubleElt
Definition: cktdefs.h:229
#define MODETRAN
Definition: cktdefs.h:145
#define MAX(a, b)
Definition: spdefs.h:135
double CKTdelta
Definition: cktdefs.h:78
double MESlModulation
Definition: mesdefs.h:171
double * MESdrainDrainPrimePtr
Definition: mesdefs.h:35
double * MESgateSourcePrimePtr
Definition: mesdefs.h:39
double * MESdrainDrainPtr
Definition: mesdefs.h:55
#define MODEINITTRAN
Definition: cktdefs.h:160
double DEVfetlim()
MESinstance * MESinstances
Definition: mesdefs.h:163
double CKTreltol
Definition: cktdefs.h:183
double MESdrainConduct
Definition: mesdefs.h:183
struct sMESmodel * MESnextModel
Definition: mesdefs.h:161
double MEScapGS
Definition: mesdefs.h:175
double MESalpha
Definition: mesdefs.h:169
double MESsourceConduct
Definition: mesdefs.h:184
double CKTabstol
Definition: cktdefs.h:180
struct sMESinstance * MESnextInstance
Definition: mesdefs.h:22
#define OK
Definition: iferrmsg.h:17
double * CKTrhsOld
Definition: cktdefs.h:98
double DEVpnjlim()
double * MESgateGatePtr
Definition: mesdefs.h:57
int MESgateNode
Definition: mesdefs.h:28
#define NULL
Definition: spdefs.h:121
double * MESdrainPrimeDrainPtr
Definition: mesdefs.h:43
int MESdrainPrimeNode
Definition: mesdefs.h:30
double * MESsourceSourcePtr
Definition: mesdefs.h:59
double * MESsourcePrimeSourcePtr
Definition: mesdefs.h:51
#define MODEINITSMSIG
Definition: cktdefs.h:159
#define NI_INTEG(ckt, geq, ceq, cap, qcap)
Definition: devdefs.h:141
double MESgatePotential
Definition: mesdefs.h:177
double * MESdrainPrimeSourcePrimePtr
Definition: mesdefs.h:47
#define MODETRANOP
Definition: cktdefs.h:151
double MESarea
Definition: mesdefs.h:32
double * MESsourcePrimeGatePtr
Definition: mesdefs.h:49
double MESb
Definition: mesdefs.h:172
double MESthreshold
Definition: mesdefs.h:168
static char model[32]
Definition: subckt.c:76
#define MODEINITFIX
Definition: cktdefs.h:158
double * MESsourcePrimeDrainPrimePtr
Definition: mesdefs.h:53
int CKTbypass
Definition: cktdefs.h:169
#define FABS(a)
Definition: util.h:41
double MEScapGD
Definition: mesdefs.h:176
double MESicVGS
Definition: mesdefs.h:34
double * MESdrainPrimeGatePtr
Definition: mesdefs.h:45
double * MESsourcePrimeSourcePrimePtr
Definition: mesdefs.h:63
static double qggnew()
double CONSTvt0
Definition: main.c:914
double MESvcrit
Definition: mesdefs.h:189
double * MESdrainPrimeDrainPrimePtr
Definition: mesdefs.h:61
double MESicVDS
Definition: mesdefs.h:33
double CKTvoltTol
Definition: cktdefs.h:185
double CKTgmin
Definition: cktdefs.h:190
double CKTdeltaOld[7]
Definition: cktdefs.h:79
int MESoff
Definition: mesdefs.h:66
int CKTnoncon
Definition: cktdefs.h:203
int MESsourcePrimeNode
Definition: mesdefs.h:31
long CKTmode
Definition: cktdefs.h:139
double MESbeta
Definition: mesdefs.h:170
#define MODEINITJCT
Definition: cktdefs.h:157
double * CKTrhs
Definition: cktdefs.h:97
#define MODEUIC
Definition: cktdefs.h:166
double * MESsourceSourcePrimePtr
Definition: mesdefs.h:41
double MESgateSatCurrent
Definition: mesdefs.h:178
double * MESgateDrainPrimePtr
Definition: mesdefs.h:37
static double qggnew ( )
static
static double qggnew ( double  vgs,
double  vgd,
double  phib,
double  vcap,
double  vto,
double  cgs,
double  cgd,
double*  cgsnew,
double*  cgdnew 
)
static

Definition at line 460 of file mesload.c.

462 {
463  double veroot,veff1,veff2,del,vnroot,vnew1,vnew3,vmax,ext;
464  double qroot,qggval,par1,cfact,cplus,cminus;
465 
466  veroot = sqrt( (vgs - vgd) * (vgs - vgd) + vcap*vcap );
467  veff1 = 0.5 * (vgs + vgd + veroot);
468  veff2 = veff1 - veroot;
469  del = 0.2;
470  vnroot = sqrt( (veff1 - vto)*(veff1 - vto) + del * del );
471  vnew1 = 0.5 * (veff1 + vto + vnroot);
472  vnew3 = vnew1;
473  vmax = 0.5;
474  if ( vnew1 < vmax ) {
475  ext=0;
476  } else {
477  vnew1 = vmax;
478  ext = (vnew3 - vmax)/sqrt(1 - vmax/phib);
479  }
480 
481  qroot = sqrt(1 - vnew1/phib);
482  qggval = cgs * (2*phib*(1-qroot) + ext) + cgd*veff2;
483  par1 = 0.5 * ( 1 + (veff1-vto)/vnroot);
484  cfact = (vgs- vgd)/veroot;
485  cplus = 0.5 * (1 + cfact);
486  cminus = cplus - cfact;
487  *cgsnew = cgs/qroot*par1*cplus + cgd*cminus;
488  *cgdnew = cgs/qroot*par1*cminus + cgd*cplus;
489  return(qggval);
490 }