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

Go to the source code of this file.

Macros

#define EPSSIL   (11.7 * 8.854214871e-12)
 
#define CM3PM3   1e6
 
#define CM2PM2   1e4
 
#define M2PCM2   1e-4
 

Functions

static int mos_dopsetup ()
 
int MOStemp (GENmodel *inModel, CKTcircuit *ckt)
 
static int mos_dopsetup (MOSmodel *model, double vtnom, double egfet1)
 
void MOSfd (MOSmodel *model, MOSinstance *here)
 
void MOSfs (MOSmodel *model, MOSinstance *here)
 

Macro Definition Documentation

#define CM2PM2   1e4

Definition at line 25 of file mostemp.c.

#define CM3PM3   1e6

Definition at line 22 of file mostemp.c.

#define EPSSIL   (11.7 * 8.854214871e-12)

Definition at line 19 of file mostemp.c.

#define M2PCM2   1e-4

Definition at line 28 of file mostemp.c.

Function Documentation

static int mos_dopsetup ( )
static
static int mos_dopsetup ( MOSmodel model,
double  vtnom,
double  egfet1 
)
static

Definition at line 277 of file mostemp.c.

281 {
282  double wkfngs;
283  double wkfng;
284  double vfb;
285  double doping = model->MOSsubstrateDoping * CM3PM3;
286 
287  if (doping > 1.45e16) {
288  if (!model->MOSphiGiven) {
289  model->MOSphi = 2*vtnom*log(doping/1.45e16);
290  model->MOSphi = MAX(.1,model->MOSphi);
291  }
292  if (!model->MOSgateTypeGiven) {
293  model->MOSgateType = 1;
294  }
295  if (!model->MOSgammaGiven) {
296  model->MOSgamma =
297  sqrt(2*EPSSIL*CHARGE*doping)/model->MOSoxideCapFactor;
298  }
299  if (!model->MOSvt0Given) {
300 
301  wkfng = 3.2;
302  if (model->MOSgateType != 0) {
303  if (model->MOStype > 0)
304  wkfng = 3.25 + .5*egfet1*(1 - model->MOSgateType);
305  else
306  wkfng = 3.25 + .5*egfet1*(1 + model->MOSgateType);
307  }
308  if (model->MOStype > 0)
309  wkfngs = wkfng - (3.25 + .5*(egfet1 + model->MOSphi));
310  else
311  wkfngs = wkfng - (3.25 + .5*(egfet1 - model->MOSphi));
312 
313  if (!model->MOSsurfaceStateDensityGiven) {
314  model->MOSsurfaceStateDensity = 0;
315  vfb = wkfngs;
316  }
317  else
318  vfb = wkfngs -
320  model->MOSoxideCapFactor;
321 
322  if (model->MOStype > 0)
323  model->MOSvt0 = vfb +
324  (model->MOSgamma*sqrt(model->MOSphi) + model->MOSphi);
325  else
326  model->MOSvt0 = vfb -
327  (model->MOSgamma*sqrt(model->MOSphi) + model->MOSphi);
328  }
329  }
330  else {
331  model->MOSsubstrateDoping = 0;
332  (*(SPfrontEnd->IFerror))(ERR_FATAL,"%s: Nsub < Ni",
333  &(model->MOSmodName));
334  return (E_BADPARM);
335  }
336  return (OK);
337 }
double MOSgamma
Definition: mosdefs.h:286
#define EPSSIL
Definition: mostemp.c:19
#define MAX(a, b)
Definition: spdefs.h:135
double MOSsurfaceStateDensity
Definition: mosdefs.h:307
#define ERR_FATAL
Definition: ifsim.h:518
double MOSvt0
Definition: mosdefs.h:284
#define CHARGE
Definition: const.h:10
int MOSgateType
Definition: mosdefs.h:281
int MOStype
Definition: mosdefs.h:279
IFfrontEnd * SPfrontEnd
Definition: main.c:917
#define E_BADPARM
Definition: iferrmsg.h:26
double MOSoxideCapFactor
Definition: mosdefs.h:282
unsigned MOSsurfaceStateDensityGiven
Definition: mosdefs.h:381
#define OK
Definition: iferrmsg.h:17
double MOSphi
Definition: mosdefs.h:287
unsigned MOSvt0Given
Definition: mosdefs.h:358
unsigned MOSgateTypeGiven
Definition: mosdefs.h:355
#define CM2PM2
Definition: mostemp.c:25
double MOSsubstrateDoping
Definition: mosdefs.h:308
IFuid MOSmodName
Definition: mosdefs.h:278
unsigned MOSgammaGiven
Definition: mosdefs.h:360
unsigned MOSphiGiven
Definition: mosdefs.h:361
#define CM3PM3
Definition: mostemp.c:22
void MOSfd ( MOSmodel model,
MOSinstance here 
)

Definition at line 341 of file mostemp.c.

345 {
346  double arg; /* 1 - fc */
347  double sargsw; /* (1-fc) ^^ (-mjsw) */
348  double sarg; /* (1-fc) ^^ (-mj) */
349  double tmp1,tmp2;
350  double pot;
351 
352  arg = 1 - model->MOSfwdCapDepCoeff;
353  sarg = exp( (-model->MOSbulkJctBotGradingCoeff) * log(arg) );
354  sargsw = exp( (-model->MOSbulkJctSideGradingCoeff) * log(arg) );
355 
356  if (model->MOSlevel == 3)
357  pot = model->MOSbulkJctPotential;
358  else
359  pot = here->MOStBulkPot;
360 
361  tmp1 = (1 - model->MOSfwdCapDepCoeff*
362  (1 + model->MOSbulkJctBotGradingCoeff))/arg;
363  tmp2 = 1/(arg*pot);
364 
365  here->MOSf2d = (here->MOSCbd*sarg + here->MOSCbdsw*sargsw)*tmp1;
366 
367  here->MOSf3d =
368  (here->MOSCbd*model->MOSbulkJctBotGradingCoeff*sarg +
369  here->MOSCbdsw*model->MOSbulkJctSideGradingCoeff*sargsw)*tmp2;
370 
371  here->MOSf4d =
372  here->MOSCbd*pot*(1 - arg*sarg)/
373  (1 - model->MOSbulkJctBotGradingCoeff)
374  + here->MOSCbdsw*pot*(1 - arg*sargsw)/
375  (1 - model->MOSbulkJctSideGradingCoeff)
376  - here->MOStDepCap*(here->MOSf2d + .5*here->MOSf3d*here->MOStDepCap);
377 }
double MOStBulkPot
Definition: mosdefs.h:57
double MOSf4d
Definition: mosdefs.h:86
double MOSbulkJctPotential
Definition: mosdefs.h:293
double MOStDepCap
Definition: mosdefs.h:58
double MOSbulkJctBotGradingCoeff
Definition: mosdefs.h:298
double MOSCbdsw
Definition: mosdefs.h:81
double MOSf3d
Definition: mosdefs.h:85
double MOSbulkJctSideGradingCoeff
Definition: mosdefs.h:300
double MOSCbd
Definition: mosdefs.h:80
int MOSlevel
Definition: mosdefs.h:280
double MOSf2d
Definition: mosdefs.h:84
double MOSfwdCapDepCoeff
Definition: mosdefs.h:306
void MOSfs ( MOSmodel model,
MOSinstance here 
)

Definition at line 381 of file mostemp.c.

385 {
386  double arg; /* 1 - fc */
387  double sargsw; /* (1-fc) ^^ (-mjsw) */
388  double sarg; /* (1-fc) ^^ (-mj) */
389  double tmp1,tmp2;
390  double pot;
391 
392  arg = 1 - model->MOSfwdCapDepCoeff;
393  sarg = exp( (-model->MOSbulkJctBotGradingCoeff) * log(arg) );
394  sargsw = exp( (-model->MOSbulkJctSideGradingCoeff) * log(arg) );
395 
396  if (model->MOSlevel == 3)
397  pot = model->MOSbulkJctPotential;
398  else
399  pot = here->MOStBulkPot;
400 
401  tmp1 = (1 - model->MOSfwdCapDepCoeff*
402  (1 + model->MOSbulkJctBotGradingCoeff))/arg;
403  tmp2 = 1/(arg*pot);
404 
405  here->MOSf2s = (here->MOSCbs*sarg + here->MOSCbssw*sargsw)*tmp1;
406 
407  here->MOSf3s =
408  (here->MOSCbs*model->MOSbulkJctBotGradingCoeff*sarg +
409  here->MOSCbssw*model->MOSbulkJctSideGradingCoeff*sargsw)*tmp2;
410 
411  here->MOSf4s =
412  here->MOSCbs*pot*(1 - arg*sarg)/
413  (1 - model->MOSbulkJctBotGradingCoeff)
414  + here->MOSCbssw*pot*(1 - arg*sargsw)/
415  (1 - model->MOSbulkJctSideGradingCoeff)
416  - here->MOStDepCap*(here->MOSf2s + .5*here->MOSf3s*here->MOStDepCap);
417 
418  /* UCB has this for last 2 lines in MOS3. error?
419  (here->MOS3tBulkPot*here->MOS3tBulkPot)
420  -here->MOS3tBulkPot * here->MOS3f2s;
421  */
422 }
double MOStBulkPot
Definition: mosdefs.h:57
double MOSbulkJctPotential
Definition: mosdefs.h:293
double MOStDepCap
Definition: mosdefs.h:58
double MOSbulkJctBotGradingCoeff
Definition: mosdefs.h:298
double MOSCbs
Definition: mosdefs.h:82
double MOSbulkJctSideGradingCoeff
Definition: mosdefs.h:300
double MOSCbssw
Definition: mosdefs.h:83
int MOSlevel
Definition: mosdefs.h:280
double MOSf4s
Definition: mosdefs.h:89
double MOSf2s
Definition: mosdefs.h:87
double MOSfwdCapDepCoeff
Definition: mosdefs.h:306
double MOSf3s
Definition: mosdefs.h:88
int MOStemp ( GENmodel inModel,
CKTcircuit ckt 
)

Definition at line 38 of file mostemp.c.

42 {
43  MOSmodel *model = (MOSmodel *)inModel;
44  MOSinstance *here;
45  double egfet,egfet1;
46  double fact1,fact2;
47  double vt,vtnom;
48  double pbfact,pbfact1,pbo;
49  double ratio;
50  double gmanew,gmaold;
51  double capfact;
52  double tmp;
53  int error;
54 
55 
56  /* loop through all the resistor models */
57  for ( ; model != NULL; model = model->MOSnextModel) {
58 
59  /* perform model defaulting */
60 
61  if (!model->MOStnomGiven) {
62  model->MOStnom = ckt->CKTnomTemp;
63  }
64  fact1 = model->MOStnom/REFTEMP;
65  vtnom = model->MOStnom*CONSTKoverQ;
66  egfet1 = 1.16 - (7.02e-4*model->MOStnom*model->MOStnom)/
67  (model->MOStnom + 1108);
68  tmp = model->MOStnom*CONSTboltz;
69  tmp = -egfet1/(tmp+tmp) + 1.1150877/(CONSTboltz*(REFTEMP+REFTEMP));
70  pbfact1= -2*vtnom*(1.5*log(fact1) + CHARGE*tmp);
71 
72 
73  if (!model->MOSoxideThicknessGiven ||
74  model->MOSoxideThickness == 0) {
75 
76  if (model->MOSlevel == 1 || model->MOSlevel == 6) {
77  model->MOSoxideCapFactor = 0;
78  goto l1skip;
79  }
80  model->MOSoxideThickness = 1e-7;
81  }
82  model->MOSoxideCapFactor = 3.9 * 8.854214871e-12/
83  model->MOSoxideThickness;
84 
85  if (!model->MOSsurfaceMobilityGiven)
86  model->MOSsurfaceMobility = 600;
87 
88  if (model->MOSlevel == 6) {
89  if (!model->MOSkcGiven) {
90  model->MOSkc = .5*model->MOSsurfaceMobility *
91  model->MOSoxideCapFactor * M2PCM2;
92  }
93  }
94  else {
95  if (!model->MOStransconductanceGiven) {
96  model->MOStransconductance = model->MOSsurfaceMobility *
97  model->MOSoxideCapFactor * M2PCM2;
98  }
99  }
100 
101  if (model->MOSsubstrateDopingGiven) {
102 
103  error = mos_dopsetup(model,vtnom,egfet1);
104  if (error) return (error);
105 
106  if (model->MOSlevel == 2) {
107  model->MOSxd = sqrt((EPSSIL+EPSSIL)/
108  (CHARGE*model->MOSsubstrateDoping*CM3PM3));
109  }
110  else if (model->MOSlevel == 3) {
111  model->MOSalpha = (EPSSIL+EPSSIL)/
113  model->MOSxd = sqrt(model->MOSalpha);
114  }
115  }
116 l1skip:
117 
118  if (model->MOSlevel == 2) {
119  if (!model->MOSbulkCapFactorGiven) {
120  model->MOSbulkCapFactor = sqrt(EPSSIL*CHARGE*
122  /(2*model->MOSbulkJctPotential));
123  }
124  }
125  else if (model->MOSlevel == 3) {
126  model->MOSnarrowFactor =
127  model->MOSdelta * 0.5 * M_PI * EPSSIL /
128  model->MOSoxideCapFactor ;
129  }
130 
131  /* loop through all instances of the model */
132  for (here = model->MOSinstances; here!= NULL;
133  here = here->MOSnextInstance) {
134 
135  fact2 = here->MOStemp/REFTEMP;
136  vt = here->MOStemp * CONSTKoverQ;
137  ratio = here->MOStemp/model->MOStnom;
138  egfet = 1.16- (7.02e-4*here->MOStemp*here->MOStemp)/
139  (here->MOStemp + 1108);
140  tmp = here->MOStemp * CONSTboltz;
141  tmp = -egfet/(tmp+tmp) + 1.1150877/(CONSTboltz*(REFTEMP+REFTEMP));
142  pbfact= -2*vt*(1.5*log(fact2) + CHARGE*tmp);
143 
144  tmp = 1/(ratio*sqrt(ratio));
145  if (model->MOSlevel == 6)
146  here->MOStTransconductance = model->MOSkc*tmp;
147  else
148  here->MOStTransconductance = model->MOStransconductance*tmp;
149  here->MOStSurfMob = model->MOSsurfaceMobility*tmp;
150 
151  tmp = (model->MOSphi - pbfact1)/fact1;
152  here->MOStPhi = fact2*tmp + pbfact;
153 
154  if (model->MOStype > 0) {
155  here->MOStVbi =
156  model->MOSvt0 - model->MOSgamma*sqrt(model->MOSphi) +
157  .5*(egfet1 - egfet + here->MOStPhi - model->MOSphi);
158  here->MOStVto =
159  here->MOStVbi + model->MOSgamma*sqrt(here->MOStPhi);
160  }
161  else {
162  here->MOStVbi =
163  model->MOSvt0 + model->MOSgamma*sqrt(model->MOSphi) +
164  .5*(egfet1 - egfet - (here->MOStPhi - model->MOSphi));
165  here->MOStVto =
166  here->MOStVbi - model->MOSgamma*sqrt(here->MOStPhi);
167  }
168 
169  tmp = exp(-egfet/vt + egfet1/vtnom);
170  here->MOStSatCur = model->MOSjctSatCur*tmp;
171  here->MOStSatCurDens = model->MOSjctSatCurDensity*tmp;
172 
173  pbo = (model->MOSbulkJctPotential - pbfact1)/fact1;
174  gmaold = (model->MOSbulkJctPotential - pbo)/pbo;
175  capfact = 1/(1 + model->MOSbulkJctBotGradingCoeff*
176  (4e-4*(model->MOStnom - REFTEMP) - gmaold));
177  here->MOStCbd = model->MOScapBD * capfact;
178  here->MOStCbs = model->MOScapBS * capfact;
179  here->MOStCj = model->MOSbulkCapFactor * capfact;
180 
181  capfact = 1/(1 + model->MOSbulkJctSideGradingCoeff*
182  (4e-4*(model->MOStnom - REFTEMP) - gmaold));
183  here->MOStCjsw = model->MOSsideWallCapFactor * capfact;
184  here->MOStBulkPot = fact2*pbo + pbfact;
185 
186  gmanew = (here->MOStBulkPot-pbo)/pbo;
187  capfact = (1 + model->MOSbulkJctBotGradingCoeff*
188  (4e-4*(here->MOStemp - REFTEMP) - gmanew));
189  here->MOStCbd *= capfact;
190  here->MOStCbs *= capfact;
191  here->MOStCj *= capfact;
192  capfact = (1 + model->MOSbulkJctSideGradingCoeff*
193  (4e-4*(here->MOStemp - REFTEMP) - gmanew));
194  here->MOStCjsw *= capfact;
195  here->MOStDepCap = model->MOSfwdCapDepCoeff * here->MOStBulkPot;
196 
197  if ( (here->MOStSatCurDens == 0) ||
198  (here->MOSdrainArea == 0) ||
199  (here->MOSsourceArea == 0) ) {
200  here->MOSsourceVcrit = here->MOSdrainVcrit =
201  vt*log(vt/(CONSTroot2*here->MOStSatCur));
202  here->MOStDrainSatCur = here->MOStSatCur;
203  here->MOStSourceSatCur = here->MOStSatCur;
204  }
205  else {
206  here->MOStDrainSatCur =
207  here->MOStSatCurDens*here->MOSdrainArea;
208  here->MOStSourceSatCur =
209  here->MOStSatCurDens*here->MOSsourceArea;
210  here->MOSdrainVcrit =
211  vt*log(vt/(CONSTroot2*here->MOStDrainSatCur));
212  here->MOSsourceVcrit =
213  vt*log(vt/(CONSTroot2*here->MOStSourceSatCur));
214  }
215 
216  if (model->MOScapBDGiven) {
217  here->MOSCbd = here->MOStCbd;
218  }
219  else {
220  if (model->MOSbulkCapFactorGiven) {
221  here->MOSCbd = here->MOStCj*here->MOSdrainArea;
222  }
223  else {
224  here->MOSCbd = 0;
225  }
226  }
227  if (model->MOSsideWallCapFactorGiven) {
228  here->MOSCbdsw = here->MOStCjsw*here->MOSdrainPerimeter;
229  }
230  else {
231  here->MOSCbdsw = 0;
232  }
233 
234  if (model->MOScapBSGiven) {
235  here->MOSCbs = here->MOStCbs;
236  }
237  else {
238  if(model->MOSbulkCapFactorGiven) {
239  here->MOSCbs = here->MOStCj*here->MOSsourceArea;
240  }
241  else {
242  here->MOSCbs = 0;
243  }
244  }
245  if (model->MOSsideWallCapFactorGiven) {
246  here->MOSCbssw = here->MOStCjsw*here->MOSsourcePerimeter;
247  }
248  else {
249  here->MOSCbssw = 0;
250  }
251 
252  MOSfd(model,here);
253  MOSfs(model,here);
254 
255 
256  /* cache a few useful parameters */
257 
259  model->MOSgateSourceOverlapCapFactor * here->MOSw;
260  here->MOSgateDrainOverlapCap =
261  model->MOSgateDrainOverlapCapFactor * here->MOSw;
262  here->MOSgateBulkOverlapCap =
264  here->MOSbeta = here->MOStTransconductance *
265  here->MOSw/here->MOSeffectiveLength;
266  here->MOSoxideCap =
267  model->MOSoxideCapFactor * here->MOSeffectiveLength *
268  here->MOSw;
269 
270  }
271  }
272  return (OK);
273 }
double MOSbeta
Definition: mosdefs.h:95
double MOSgamma
Definition: mosdefs.h:286
struct sMOSmodel * MOSnextModel
Definition: mosdefs.h:274
double MOStBulkPot
Definition: mosdefs.h:57
double MOSdrainArea
Definition: mosdefs.h:36
double MOSgateBulkOverlapCap
Definition: mosdefs.h:94
MOSinstance * MOSinstances
Definition: mosdefs.h:276
double MOStemp
Definition: mosdefs.h:44
double MOSbulkJctPotential
Definition: mosdefs.h:293
#define EPSSIL
Definition: mostemp.c:19
double CONSTroot2
Definition: main.c:913
double MOSxd
Definition: mosdefs.h:325
double MOSoxideThickness
Definition: mosdefs.h:302
unsigned MOSoxideThicknessGiven
Definition: mosdefs.h:376
double MOStVto
Definition: mosdefs.h:50
double MOStDepCap
Definition: mosdefs.h:58
unsigned MOSkcGiven
Definition: mosdefs.h:409
double MOStransconductance
Definition: mosdefs.h:285
unsigned MOSbulkCapFactorGiven
Definition: mosdefs.h:371
double MOSvt0
Definition: mosdefs.h:284
double CKTnomTemp
Definition: cktdefs.h:81
#define M_PI
Definition: spice.h:132
#define CHARGE
Definition: const.h:10
double MOStSurfMob
Definition: mosdefs.h:48
double MOSbulkJctBotGradingCoeff
Definition: mosdefs.h:298
double MOSkc
Definition: mosdefs.h:337
static double e
Definition: vectors.c:17
double MOSsourcePerimeter
Definition: mosdefs.h:41
int MOStype
Definition: mosdefs.h:279
double MOSCbs
Definition: mosdefs.h:82
unsigned MOSsubstrateDopingGiven
Definition: mosdefs.h:382
unsigned MOSsurfaceMobilityGiven
Definition: mosdefs.h:379
double CONSTKoverQ
Definition: main.c:915
double MOSoxideCapFactor
Definition: mosdefs.h:282
double MOSCbdsw
Definition: mosdefs.h:81
double MOStSatCurDens
Definition: mosdefs.h:52
double MOSbulkJctSideGradingCoeff
Definition: mosdefs.h:300
double MOSgateSourceOverlapCap
Definition: mosdefs.h:92
double MOSnarrowFactor
Definition: mosdefs.h:322
unsigned MOScapBSGiven
Definition: mosdefs.h:365
double MOStCjsw
Definition: mosdefs.h:56
void MOSfd(MOSmodel *model, MOSinstance *here)
Definition: mostemp.c:341
double MOSw
Definition: mosdefs.h:35
double MOStCj
Definition: mosdefs.h:55
double MOStDrainSatCur
Definition: mosdefs.h:60
unsigned MOStransconductanceGiven
Definition: mosdefs.h:359
#define OK
Definition: iferrmsg.h:17
double MOSphi
Definition: mosdefs.h:287
#define CONSTboltz
Definition: const.h:12
double MOSjctSatCurDensity
Definition: mosdefs.h:301
double MOScapBD
Definition: mosdefs.h:290
double MOSdrainVcrit
Definition: mosdefs.h:69
#define NULL
Definition: spdefs.h:121
double MOSCbd
Definition: mosdefs.h:80
double MOStnom
Definition: mosdefs.h:283
double MOSdrainPerimeter
Definition: mosdefs.h:40
double MOSsourceVcrit
Definition: mosdefs.h:68
double MOScapBS
Definition: mosdefs.h:291
double MOSsubstrateDoping
Definition: mosdefs.h:308
#define M2PCM2
Definition: mostemp.c:28
double MOSCbssw
Definition: mosdefs.h:83
int MOSlevel
Definition: mosdefs.h:280
double MOSsideWallCapFactor
Definition: mosdefs.h:299
static int mos_dopsetup()
double MOStSatCur
Definition: mosdefs.h:51
double MOSjctSatCur
Definition: mosdefs.h:292
double MOSoxideCap
Definition: mosdefs.h:96
unsigned MOStnomGiven
Definition: mosdefs.h:357
double MOSalpha
Definition: mosdefs.h:332
double MOStSourceSatCur
Definition: mosdefs.h:61
double MOStCbd
Definition: mosdefs.h:53
double MOStPhi
Definition: mosdefs.h:49
unsigned MOSsideWallCapFactorGiven
Definition: mosdefs.h:373
static char model[32]
Definition: subckt.c:76
double MOStVbi
Definition: mosdefs.h:59
double MOStCbs
Definition: mosdefs.h:54
double MOSgateSourceOverlapCapFactor
Definition: mosdefs.h:294
double MOSgateDrainOverlapCap
Definition: mosdefs.h:93
double MOSeffectiveLength
Definition: mosdefs.h:91
double MOSbulkCapFactor
Definition: mosdefs.h:297
double MOSgateBulkOverlapCapFactor
Definition: mosdefs.h:296
double MOSsurfaceMobility
Definition: mosdefs.h:305
double MOSgateDrainOverlapCapFactor
Definition: mosdefs.h:295
double MOSsourceArea
Definition: mosdefs.h:37
double MOSdelta
Definition: mosdefs.h:331
double MOSfwdCapDepCoeff
Definition: mosdefs.h:306
double MOStTransconductance
Definition: mosdefs.h:47
struct sMOSinstance * MOSnextInstance
Definition: mosdefs.h:20
void MOSfs(MOSmodel *model, MOSinstance *here)
Definition: mostemp.c:381
#define CM3PM3
Definition: mostemp.c:22
#define REFTEMP
Definition: const.h:13
unsigned MOScapBDGiven
Definition: mosdefs.h:364