Jspice3
jfetload.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 Thomas L. Quarles
5  1993 Stephen R. Whiteley
6 ****************************************************************************/
7 /********** new in 3f2
8 Sydney University mods Copyright(c) 1989 Anthony E. Parker, David J. Skellern
9  Laboratory for Communication Science Engineering
10  Sydney University Department of Electrical Engineering, Australia
11 **********/
12 
13 #include "spice.h"
14 #include <stdio.h>
15 #include <math.h>
16 #include "jfetdefs.h"
17 #include "const.h"
18 #include "sperror.h"
19 #include "util.h"
20 #include "niext.h"
21 
22 
23 int
24 JFETload(inModel,ckt)
25  GENmodel *inModel;
26  CKTcircuit *ckt;
27  /* actually load the current resistance value into the
28  * sparse matrix previously provided
29  */
30 {
31  register JFETmodel *model = (JFETmodel*)inModel;
32  register JFETinstance *here;
33  double beta;
34  double betap;
35  double capgd;
36  double capgs;
37  double cd;
38  double cdhat;
39  double cdrain;
40  double cdreq;
41  double ceq;
42  double ceqgd;
43  double ceqgs;
44  double cg;
45  double cgd;
46  double cghat;
47  double csat;
48  double czgd;
49  double czgdf2;
50  double czgs;
51  double czgsf2;
52  double delvds;
53  double delvgd;
54  double delvgs;
55  double evgd;
56  double evgs;
57  double fcpb2;
58  double gdpr;
59  double gds;
60  double geq;
61  double ggd;
62  double ggs;
63  double gm;
64  double gspr;
65  double sarg;
66  double twob;
67  double twop;
68  double vds;
69  double vgd;
70  double vgdt;
71  double vgs;
72  double vgst;
73  double xfact;
74  /* Modification for Sydney University JFET model */
75  double phib,vto;
76  double apart,bpart,cpart;
77  double Bfac;
78  double vgd1,vgs1;
79  /* end Sydney University mod. */
80  int icheck;
81  int ichk1;
82  int error;
83 
84  /* loop through all the models */
85  for( ; model != NULL; model = model->JFETnextModel ) {
86 
87  /* loop through all the instances of the model */
88  for (here = model->JFETinstances; here != NULL ;
89  here=here->JFETnextInstance) {
90 
91  /*
92  * dc model parameters
93  */
94  beta = model->JFETbeta * here->JFETarea;
95  gdpr=model->JFETdrainConduct*here->JFETarea;
96  gspr=model->JFETsourceConduct*here->JFETarea;
97  csat=here->JFETtSatCur*here->JFETarea;
98  /*
99  * initialization
100  */
101  icheck=1;
102  if( ckt->CKTmode & MODEINITSMSIG) {
103  vgs= *(ckt->CKTstate0 + here->JFETvgs);
104  vgd= *(ckt->CKTstate0 + here->JFETvgd);
105  } else if (ckt->CKTmode & MODEINITTRAN) {
106  vgs= *(ckt->CKTstate1 + here->JFETvgs);
107  vgd= *(ckt->CKTstate1 + here->JFETvgd);
108  } else if ( (ckt->CKTmode & MODEINITJCT) &&
109  (ckt->CKTmode & MODETRANOP) &&
110  (ckt->CKTmode & MODEUIC) ) {
111  vds=model->JFETtype*here->JFETicVDS;
112  vgs=model->JFETtype*here->JFETicVGS;
113  vgd=vgs-vds;
114  } else if ( (ckt->CKTmode & MODEINITJCT) &&
115  (here->JFEToff == 0) ) {
116  vgs = -1;
117  vgd = -1;
118  } else if( (ckt->CKTmode & MODEINITJCT) ||
119  ((ckt->CKTmode & MODEINITFIX) && (here->JFEToff))) {
120  vgs = 0;
121  vgd = 0;
122  } else {
123  if(ckt->CKTmode & MODEINITPRED) {
124  xfact=ckt->CKTdelta/ckt->CKTdeltaOld[2];
125  *(ckt->CKTstate0 + here->JFETvgs)=
126  *(ckt->CKTstate1 + here->JFETvgs);
127  vgs=(1+xfact)* *(ckt->CKTstate1 + here->JFETvgs)-xfact*
128  *(ckt->CKTstate2 + here->JFETvgs);
129  *(ckt->CKTstate0 + here->JFETvgd)=
130  *(ckt->CKTstate1 + here->JFETvgd);
131  vgd=(1+xfact)* *(ckt->CKTstate1 + here->JFETvgd)-xfact*
132  *(ckt->CKTstate2 + here->JFETvgd);
133  *(ckt->CKTstate0 + here->JFETcg)=
134  *(ckt->CKTstate1 + here->JFETcg);
135  *(ckt->CKTstate0 + here->JFETcd)=
136  *(ckt->CKTstate1 + here->JFETcd);
137  *(ckt->CKTstate0 + here->JFETcgd)=
138  *(ckt->CKTstate1 + here->JFETcgd);
139  *(ckt->CKTstate0 + here->JFETgm)=
140  *(ckt->CKTstate1 + here->JFETgm);
141  *(ckt->CKTstate0 + here->JFETgds)=
142  *(ckt->CKTstate1 + here->JFETgds);
143  *(ckt->CKTstate0 + here->JFETggs)=
144  *(ckt->CKTstate1 + here->JFETggs);
145  *(ckt->CKTstate0 + here->JFETggd)=
146  *(ckt->CKTstate1 + here->JFETggd);
147  } else {
148  /*
149  * compute new nonlinear branch voltages
150  */
151  vgs=model->JFETtype*
152  (*(ckt->CKTrhsOld+ here->JFETgateNode)-
153  *(ckt->CKTrhsOld+
154  here->JFETsourcePrimeNode));
155  vgd=model->JFETtype*
156  (*(ckt->CKTrhsOld+here->JFETgateNode)-
157  *(ckt->CKTrhsOld+
158  here->JFETdrainPrimeNode));
159  }
160  delvgs=vgs- *(ckt->CKTstate0 + here->JFETvgs);
161  delvgd=vgd- *(ckt->CKTstate0 + here->JFETvgd);
162  delvds=delvgs-delvgd;
163  cghat= *(ckt->CKTstate0 + here->JFETcg)+
164  *(ckt->CKTstate0 + here->JFETggd)*delvgd+
165  *(ckt->CKTstate0 + here->JFETggs)*delvgs;
166  cdhat= *(ckt->CKTstate0 + here->JFETcd)+
167  *(ckt->CKTstate0 + here->JFETgm)*delvgs+
168  *(ckt->CKTstate0 + here->JFETgds)*delvds-
169  *(ckt->CKTstate0 + here->JFETggd)*delvgd;
170  /*
171  * bypass if solution has not changed
172  */
173  if((ckt->CKTbypass) &&
174  (!(ckt->CKTmode & MODEINITPRED)) &&
175  (FABS(delvgs) < ckt->CKTreltol*MAX(FABS(vgs),
176  FABS(*(ckt->CKTstate0 + here->JFETvgs)))+
177  ckt->CKTvoltTol) )
178  if ( (FABS(delvgd) < ckt->CKTreltol*MAX(FABS(vgd),
179  FABS(*(ckt->CKTstate0 + here->JFETvgd)))+
180  ckt->CKTvoltTol))
181  if ( (FABS(cghat-*(ckt->CKTstate0 + here->JFETcg))
182  < ckt->CKTreltol*MAX(FABS(cghat),
183  FABS(*(ckt->CKTstate0 + here->JFETcg)))+
184  ckt->CKTabstol) ) if ( /* hack - expression too big */
185  (FABS(cdhat-*(ckt->CKTstate0 + here->JFETcd))
186  < ckt->CKTreltol*MAX(FABS(cdhat),
187  FABS(*(ckt->CKTstate0 + here->JFETcd)))+
188  ckt->CKTabstol) ) {
189 
190  /* we can do a bypass */
191  vgs= *(ckt->CKTstate0 + here->JFETvgs);
192  vgd= *(ckt->CKTstate0 + here->JFETvgd);
193  vds= vgs-vgd;
194  cg= *(ckt->CKTstate0 + here->JFETcg);
195  cd= *(ckt->CKTstate0 + here->JFETcd);
196  cgd= *(ckt->CKTstate0 + here->JFETcgd);
197  gm= *(ckt->CKTstate0 + here->JFETgm);
198  gds= *(ckt->CKTstate0 + here->JFETgds);
199  ggs= *(ckt->CKTstate0 + here->JFETggs);
200  ggd= *(ckt->CKTstate0 + here->JFETggd);
201  goto load;
202  }
203  /*
204  * limit nonlinear branch voltages
205  */
206  ichk1=1;
207  vgs = DEVpnjlim(vgs,*(ckt->CKTstate0 + here->JFETvgs),
208  (here->JFETtemp*CONSTKoverQ), here->JFETvcrit, &icheck);
209  vgd = DEVpnjlim(vgd,*(ckt->CKTstate0 + here->JFETvgd),
210  (here->JFETtemp*CONSTKoverQ), here->JFETvcrit,&ichk1);
211  if (ichk1 == 1) {
212  icheck=1;
213  }
214  vgs = DEVfetlim(vgs,*(ckt->CKTstate0 + here->JFETvgs),
215  model->JFETthreshold);
216  vgd = DEVfetlim(vgd,*(ckt->CKTstate0 + here->JFETvgd),
217  model->JFETthreshold);
218  }
219  /*
220  * determine dc current and derivatives
221  */
222  vds=vgs-vgd;
223  if (vgs <= -5*here->JFETtemp*CONSTKoverQ) {
224  ggs = -csat/vgs+ckt->CKTgmin;
225  cg = ggs*vgs;
226  } else {
227  evgs = exp(vgs/(here->JFETtemp*CONSTKoverQ));
228  ggs = csat*evgs/(here->JFETtemp*CONSTKoverQ)+ckt->CKTgmin;
229  cg = csat*(evgs-1)+ckt->CKTgmin*vgs;
230  }
231  if (vgd <= -5*(here->JFETtemp*CONSTKoverQ)) {
232  ggd = -csat/vgd+ckt->CKTgmin;
233  cgd = ggd*vgd;
234  } else {
235  evgd = exp(vgd/(here->JFETtemp*CONSTKoverQ));
236  ggd = csat*evgd/(here->JFETtemp*CONSTKoverQ)+ckt->CKTgmin;
237  cgd = csat*(evgd-1)+ckt->CKTgmin*vgd;
238  }
239  cg = cg+cgd;
240 
241  /* Modification for Sydney University JFET model */
242  vto = model->JFETthreshold;
243  if (vds >= 0) {
244  vgst = vgs - vto;
245  /*
246  * compute drain current and derivatives for normal mode
247  */
248  if (vgst <= 0) {
249  /*
250  * normal mode, cutoff region
251  */
252  cdrain = 0;
253  gm = 0;
254  gds = 0;
255  } else {
256  betap = beta*(1 + model->JFETlModulation*vds);
257  Bfac = model->JFETbFac;
258  if (vgst >= vds) {
259  /*
260  * normal mode, linear region
261  */
262  apart = 2*model->JFETb + 3*Bfac*(vgst - vds);
263  cpart = vds*(vds*(Bfac*vds - model->JFETb)+vgst*apart);
264  cdrain = betap*cpart;
265  gm = betap*vds*(apart + 3*Bfac*vgst);
266  gds = betap*(vgst - vds)*apart
267  + beta*model->JFETlModulation*cpart;
268  } else {
269  Bfac = vgst*Bfac;
270  gm = betap*vgst*(2*model->JFETb+3*Bfac);
271  /*
272  * normal mode, saturation region
273  */
274  cpart=vgst*vgst*(model->JFETb+Bfac);
275  cdrain = betap*cpart;
276  gds = model->JFETlModulation*beta*cpart;
277  }
278  }
279  } else {
280  vgdt = vgd - vto;
281  /*
282  * compute drain current and derivatives for inverse mode
283  */
284  if (vgdt <= 0) {
285  /*
286  * inverse mode, cutoff region
287  */
288  cdrain = 0;
289  gm = 0;
290  gds = 0;
291  } else {
292  betap = beta*(1 - model->JFETlModulation*vds);
293  Bfac = model->JFETbFac;
294  if (vgdt + vds >= 0) {
295  /*
296  * inverse mode, linear region
297  */
298  apart = 2*model->JFETb + 3*Bfac*(vgdt + vds);
299  cpart = vds*(-vds*(-Bfac*vds-model->JFETb)+vgdt*apart);
300  cdrain = betap*cpart;
301  gm = betap*vds*(apart + 3*Bfac*vgdt);
302  gds = betap*(vgdt + vds)*apart
303  - beta*model->JFETlModulation*cpart - gm;
304  } else {
305  Bfac = vgdt*Bfac;
306  gm = -betap*vgdt*(2*model->JFETb+3*Bfac);
307  /*
308  * inverse mode, saturation region
309  */
310  cpart=vgdt*vgdt*(model->JFETb+Bfac);
311  cdrain = - betap*cpart;
312  gds = model->JFETlModulation*beta*cpart-gm;
313  }
314  }
315  }
316 #ifdef notdef
317  /* The original section is now commented out */
318  /* end Sydney University mod */
319  /*
320  * compute drain current and derivitives for normal mode
321  */
322  if (vds >= 0) {
323  vgst=vgs-model->JFETthreshold;
324  /*
325  * normal mode, cutoff region
326  */
327  if (vgst <= 0) {
328  cdrain=0;
329  gm=0;
330  gds=0;
331  } else {
332  betap=beta*(1+model->JFETlModulation*vds);
333  twob=betap+betap;
334  if (vgst <= vds) {
335  /*
336  * normal mode, saturation region
337  */
338  cdrain=betap*vgst*vgst;
339  gm=twob*vgst;
340  gds=model->JFETlModulation*beta*vgst*vgst;
341  } else {
342  /*
343  * normal mode, linear region
344  */
345  cdrain=betap*vds*(vgst+vgst-vds);
346  gm=twob*vds;
347  gds=twob*(vgst-vds)+model->JFETlModulation*beta*
348  vds*(vgst+vgst-vds);
349  }
350  }
351  } else {
352  /*
353  * compute drain current and derivitives for inverse mode
354  */
355  vgdt=vgd-model->JFETthreshold;
356  if (vgdt <= 0) {
357  /*
358  * inverse mode, cutoff region
359  */
360  cdrain=0;
361  gm=0;
362  gds=0;
363  } else {
364  /*
365  * inverse mode, saturation region
366  */
367  betap=beta*(1-model->JFETlModulation*vds);
368  twob=betap+betap;
369  if (vgdt <= -vds) {
370  cdrain = -betap*vgdt*vgdt;
371  gm = -twob*vgdt;
372  gds = model->JFETlModulation*beta*vgdt*vgdt-gm;
373  } else {
374  /*
375  * inverse mode, linear region
376  */
377  cdrain=betap*vds*(vgdt+vgdt+vds);
378  gm=twob*vds;
379  gds=twob*vgdt-model->JFETlModulation*beta*vds*
380  (vgdt+vgdt+vds);
381  }
382  }
383  }
384  /* end of original section, now deleted (replaced w/SU mod */
385 #endif
386  /*
387  * compute equivalent drain current source
388  */
389  cd=cdrain-cgd;
390  if ( (ckt->CKTmode & (MODETRAN | MODEAC | MODEINITSMSIG) ) ||
391  ((ckt->CKTmode & MODETRANOP) && (ckt->CKTmode & MODEUIC)) ){
392  /*
393  * charge storage elements
394  */
395  czgs=here->JFETtCGS*here->JFETarea;
396  czgd=here->JFETtCGD*here->JFETarea;
397  twop=here->JFETtGatePot+here->JFETtGatePot;
398  fcpb2=here->JFETcorDepCap*here->JFETcorDepCap;
399  czgsf2=czgs/model->JFETf2;
400  czgdf2=czgd/model->JFETf2;
401  if (vgs < here->JFETcorDepCap) {
402  sarg=sqrt(1-vgs/here->JFETtGatePot);
403  *(ckt->CKTstate0 + here->JFETqgs) = twop*czgs*(1-sarg);
404  capgs=czgs/sarg;
405  } else {
406  *(ckt->CKTstate0 + here->JFETqgs) = czgs*here->JFETf1 +
407  czgsf2*(model->JFETf3 *(vgs-
408  here->JFETcorDepCap)+(vgs*vgs-fcpb2)/
409  (twop+twop));
410  capgs=czgsf2*(model->JFETf3+vgs/twop);
411  }
412  if (vgd < here->JFETcorDepCap) {
413  sarg=sqrt(1-vgd/here->JFETtGatePot);
414  *(ckt->CKTstate0 + here->JFETqgd) = twop*czgd*(1-sarg);
415  capgd=czgd/sarg;
416  } else {
417  *(ckt->CKTstate0 + here->JFETqgd) = czgd*here->JFETf1+
418  czgdf2*(model->JFETf3* (vgd-
419  here->JFETcorDepCap)+(vgd*vgd-fcpb2)/
420  (twop+twop));
421  capgd=czgdf2*(model->JFETf3+vgd/twop);
422  }
423  /*
424  * store small-signal parameters
425  */
426  if( (!(ckt->CKTmode & MODETRANOP)) ||
427  (!(ckt->CKTmode & MODEUIC)) ) {
428  if(ckt->CKTmode & MODEINITSMSIG) {
429  *(ckt->CKTstate0 + here->JFETqgs) = capgs;
430  *(ckt->CKTstate0 + here->JFETqgd) = capgd;
431  continue; /*go to 1000*/
432  }
433  /*
434  * transient analysis
435  */
436  if(ckt->CKTmode & MODEINITTRAN) {
437  *(ckt->CKTstate1 + here->JFETqgs) =
438  *(ckt->CKTstate0 + here->JFETqgs);
439  *(ckt->CKTstate1 + here->JFETqgd) =
440  *(ckt->CKTstate0 + here->JFETqgd);
441  }
442  NI_INTEG(ckt,geq,ceq,capgs,here->JFETqgs);
443  ggs = ggs + geq;
444  cg = cg + *(ckt->CKTstate0 + here->JFETcqgs);
445  NI_INTEG(ckt,geq,ceq,capgd,here->JFETqgd);
446  ggd = ggd + geq;
447  cg = cg + *(ckt->CKTstate0 + here->JFETcqgd);
448  cd = cd - *(ckt->CKTstate0 + here->JFETcqgd);
449  cgd = cgd + *(ckt->CKTstate0 + here->JFETcqgd);
450  if (ckt->CKTmode & MODEINITTRAN) {
451  *(ckt->CKTstate1 + here->JFETcqgs) =
452  *(ckt->CKTstate0 + here->JFETcqgs);
453  *(ckt->CKTstate1 + here->JFETcqgd) =
454  *(ckt->CKTstate0 + here->JFETcqgd);
455  }
456  }
457  }
458  /*
459  * check convergence
460  */
461  if( (!(ckt->CKTmode & MODEINITFIX)) | (!(ckt->CKTmode & MODEUIC))) {
462  if( (icheck == 1)
463 #ifndef NEWCONV
464  || (FABS(cghat-cg) >= ckt->CKTreltol*
465  MAX(FABS(cghat),FABS(cg))+ckt->CKTabstol) ||
466  (FABS(cdhat-cd) > ckt->CKTreltol*
467  MAX(FABS(cdhat),FABS(cd))+ckt->CKTabstol)
468 #endif /*NEWCONV*/
469  ) {
470  ckt->CKTnoncon++;
471  /* new in 3f2 */
472  ckt->CKTtroubleElt = (GENinstance *) here;
473  }
474  }
475  *(ckt->CKTstate0 + here->JFETvgs) = vgs;
476  *(ckt->CKTstate0 + here->JFETvgd) = vgd;
477  *(ckt->CKTstate0 + here->JFETcg) = cg;
478  *(ckt->CKTstate0 + here->JFETcd) = cd;
479  *(ckt->CKTstate0 + here->JFETcgd) = cgd;
480  *(ckt->CKTstate0 + here->JFETgm) = gm;
481  *(ckt->CKTstate0 + here->JFETgds) = gds;
482  *(ckt->CKTstate0 + here->JFETggs) = ggs;
483  *(ckt->CKTstate0 + here->JFETggd) = ggd;
484  /*
485  * load current vector
486  */
487 load:
488  ceqgd=model->JFETtype*(cgd-ggd*vgd);
489  ceqgs=model->JFETtype*((cg-cgd)-ggs*vgs);
490  cdreq=model->JFETtype*((cd+cgd)-gds*vds-gm*vgs);
491  *(ckt->CKTrhs + here->JFETgateNode) += (-ceqgs-ceqgd);
492  *(ckt->CKTrhs + here->JFETdrainPrimeNode) +=
493  (-cdreq+ceqgd);
494  *(ckt->CKTrhs + here->JFETsourcePrimeNode) +=
495  (cdreq+ceqgs);
496  /*
497  * load y matrix
498  */
499  *(here->JFETdrainDrainPrimePtr) += (-gdpr);
500  *(here->JFETgateDrainPrimePtr) += (-ggd);
501  *(here->JFETgateSourcePrimePtr) += (-ggs);
502  *(here->JFETsourceSourcePrimePtr) += (-gspr);
503  *(here->JFETdrainPrimeDrainPtr) += (-gdpr);
504  *(here->JFETdrainPrimeGatePtr) += (gm-ggd);
505  *(here->JFETdrainPrimeSourcePrimePtr) += (-gds-gm);
506  *(here->JFETsourcePrimeGatePtr) += (-ggs-gm);
507  *(here->JFETsourcePrimeSourcePtr) += (-gspr);
508  *(here->JFETsourcePrimeDrainPrimePtr) += (-gds);
509  *(here->JFETdrainDrainPtr) += (gdpr);
510  *(here->JFETgateGatePtr) += (ggd+ggs);
511  *(here->JFETsourceSourcePtr) += (gspr);
512  *(here->JFETdrainPrimeDrainPrimePtr) += (gdpr+gds+ggd);
513  *(here->JFETsourcePrimeSourcePrimePtr) += (gspr+gds+gm+ggs);
514  }
515  }
516  return(OK);
517 }
double * JFETdrainDrainPrimePtr
Definition: jfetdefs.h:35
#define MODEAC
Definition: cktdefs.h:146
double * JFETsourcePrimeGatePtr
Definition: jfetdefs.h:49
double JFETvcrit
Definition: jfetdefs.h:143
double JFETtCGD
Definition: jfetdefs.h:141
double JFETcorDepCap
Definition: jfetdefs.h:142
#define MODEINITPRED
Definition: cktdefs.h:161
double JFETbFac
Definition: jfetdefs.h:194
GENinstance * CKTtroubleElt
Definition: cktdefs.h:229
#define MODETRAN
Definition: cktdefs.h:145
double JFETbeta
Definition: jfetdefs.h:175
double * JFETsourceSourcePtr
Definition: jfetdefs.h:59
#define MAX(a, b)
Definition: spdefs.h:135
double JFETthreshold
Definition: jfetdefs.h:174
int JFETtype
Definition: jfetdefs.h:172
double CKTdelta
Definition: cktdefs.h:78
double JFETf1
Definition: jfetdefs.h:144
double * JFETgateGatePtr
Definition: jfetdefs.h:57
#define MODEINITTRAN
Definition: cktdefs.h:160
double DEVfetlim()
double JFETdrainConduct
Definition: jfetdefs.h:188
int JFETdrainPrimeNode
Definition: jfetdefs.h:32
int JFETgateNode
Definition: jfetdefs.h:30
JFETinstance * JFETinstances
Definition: jfetdefs.h:169
double CONSTKoverQ
Definition: main.c:915
double JFETtSatCur
Definition: jfetdefs.h:138
double CKTreltol
Definition: cktdefs.h:183
double * JFETgateDrainPrimePtr
Definition: jfetdefs.h:37
double * JFETdrainPrimeDrainPrimePtr
Definition: jfetdefs.h:61
int JFETtemp()
double JFETarea
Definition: jfetdefs.h:134
double JFETtemp
Definition: jfetdefs.h:137
double CKTabstol
Definition: cktdefs.h:180
double JFETf2
Definition: jfetdefs.h:190
#define OK
Definition: iferrmsg.h:17
double * CKTrhsOld
Definition: cktdefs.h:98
double DEVpnjlim()
double * JFETsourceSourcePrimePtr
Definition: jfetdefs.h:41
double * JFETdrainPrimeDrainPtr
Definition: jfetdefs.h:43
#define NULL
Definition: spdefs.h:121
double JFETsourceConduct
Definition: jfetdefs.h:189
double JFETtCGS
Definition: jfetdefs.h:140
double JFETicVGS
Definition: jfetdefs.h:136
double * JFETsourcePrimeSourcePrimePtr
Definition: jfetdefs.h:63
#define MODEINITSMSIG
Definition: cktdefs.h:159
#define NI_INTEG(ckt, geq, ceq, cap, qcap)
Definition: devdefs.h:141
#define MODETRANOP
Definition: cktdefs.h:151
struct sJFETmodel * JFETnextModel
Definition: jfetdefs.h:167
double JFETicVDS
Definition: jfetdefs.h:135
static char model[32]
Definition: subckt.c:76
#define MODEINITFIX
Definition: cktdefs.h:158
double * JFETdrainPrimeGatePtr
Definition: jfetdefs.h:45
int CKTbypass
Definition: cktdefs.h:169
#define FABS(a)
Definition: util.h:41
double JFETb
Definition: jfetdefs.h:193
double * JFETdrainPrimeSourcePrimePtr
Definition: jfetdefs.h:47
double * JFETgateSourcePrimePtr
Definition: jfetdefs.h:39
struct sJFETinstance * JFETnextInstance
Definition: jfetdefs.h:25
int JFETsourcePrimeNode
Definition: jfetdefs.h:33
unsigned JFEToff
Definition: jfetdefs.h:127
double CKTvoltTol
Definition: cktdefs.h:185
double JFETtGatePot
Definition: jfetdefs.h:139
double CKTgmin
Definition: cktdefs.h:190
double CKTdeltaOld[7]
Definition: cktdefs.h:79
double * JFETsourcePrimeDrainPrimePtr
Definition: jfetdefs.h:53
double JFETf3
Definition: jfetdefs.h:191
int CKTnoncon
Definition: cktdefs.h:203
double * JFETdrainDrainPtr
Definition: jfetdefs.h:55
int JFETload(GENmodel *inModel, CKTcircuit *ckt)
Definition: jfetload.c:24
long CKTmode
Definition: cktdefs.h:139
#define MODEINITJCT
Definition: cktdefs.h:157
double * JFETsourcePrimeSourcePtr
Definition: jfetdefs.h:51
double * CKTrhs
Definition: cktdefs.h:97
#define MODEUIC
Definition: cktdefs.h:166
double JFETlModulation
Definition: jfetdefs.h:176