luke
/
ngspice
mirror of https://git.code.sf.net/p/ngspice/ngspice
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

[PATCH 5/6] Fixed formatting for consistent nesting level indentation

This commit is contained in:
Jim Monte 2019-05-01 11:28:27 +02:00 committed by Holger Vogt
parent fdc1e32164
commit 92f512894f
1 changed files with 325 additions and 324 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

649
src/spicelib/devices/mos1/mos1load.c
View File

@ -15,8 +15,8 @@ Modified: 2000 AlansFixes
int int
MOS1load(GENmodel *inModel, CKTcircuit *ckt) MOS1load(GENmodel *inModel, CKTcircuit *ckt)
/* actually load the current value into the /* actually load the current value into the
* sparse matrix previously provided * sparse matrix previously provided
*/ */
{ {
MOS1model *model = (MOS1model *) inModel; MOS1model *model = (MOS1model *) inModel;
@ -75,13 +75,13 @@ MOS1load(GENmodel *inModel, CKTcircuit *ckt)
double capgd = 0.0; /* total gate-drain capacitance */ double capgd = 0.0; /* total gate-drain capacitance */
double capgb = 0.0; /* total gate-bulk capacitance */ double capgb = 0.0; /* total gate-bulk capacitance */
int Check; int Check;
#ifndef NOBYPASS #ifndef NOBYPASS
double tempv; double tempv;
#endif /*NOBYPASS*/ #endif /*NOBYPASS*/
int error; int error;
#ifdef CAPBYPASS #ifdef CAPBYPASS
int senflag; int senflag;
#endif /*CAPBYPASS*/ #endif /*CAPBYPASS*/
int SenCond; int SenCond;
@ -92,14 +92,14 @@ MOS1load(GENmodel *inModel, CKTcircuit *ckt)
(ckt->CKTsenInfo->SENmode & (ACSEN | TRANSEN))) { (ckt->CKTsenInfo->SENmode & (ACSEN | TRANSEN))) {
senflag = 1; senflag = 1;
} }
#endif /* CAPBYPASS */ #endif /* CAPBYPASS */
/* loop through all the MOS1 device models */ /* loop through all the MOS1 device models */
for( ; model != NULL; model = MOS1nextModel(model)) { for( ; model != NULL; model = MOS1nextModel(model)) {
/* loop through all the instances of the model */ /* loop through all the instances of the model */
for (here = MOS1instances(model); here != NULL ; for (here = MOS1instances(model); here != NULL ;
here=MOS1nextInstance(here)) { here=MOS1nextInstance(here)) {
vt = CONSTKoverQ * here->MOS1temp; vt = CONSTKoverQ * here->MOS1temp;
Check=1; Check=1;
@ -109,13 +109,13 @@ MOS1load(GENmodel *inModel, CKTcircuit *ckt)
#endif /* SENSDEBUG */ #endif /* SENSDEBUG */
if((ckt->CKTsenInfo->SENstatus == PERTURBATION)&& if((ckt->CKTsenInfo->SENstatus == PERTURBATION)&&
(here->MOS1senPertFlag == OFF))continue; (here->MOS1senPertFlag == OFF))continue;
} }
SenCond = ckt->CKTsenInfo && here->MOS1senPertFlag; SenCond = ckt->CKTsenInfo && here->MOS1senPertFlag;
/* /*
*/ */
/* first, we compute a few useful values - these could be /* first, we compute a few useful values - these could be
@ -124,30 +124,30 @@ MOS1load(GENmodel *inModel, CKTcircuit *ckt)
*/ */
EffectiveLength=here->MOS1l - 2*model->MOS1latDiff; EffectiveLength=here->MOS1l - 2*model->MOS1latDiff;
if( (here->MOS1tSatCurDens == 0) || if( (here->MOS1tSatCurDens == 0) ||
(here->MOS1drainArea == 0) || (here->MOS1drainArea == 0) ||
(here->MOS1sourceArea == 0)) { (here->MOS1sourceArea == 0)) {
DrainSatCur = here->MOS1m * here->MOS1tSatCur; DrainSatCur = here->MOS1m * here->MOS1tSatCur;
SourceSatCur = here->MOS1m * here->MOS1tSatCur; SourceSatCur = here->MOS1m * here->MOS1tSatCur;
} else { } else {
DrainSatCur = here->MOS1tSatCurDens * DrainSatCur = here->MOS1tSatCurDens *
here->MOS1m * here->MOS1drainArea; here->MOS1m * here->MOS1drainArea;
SourceSatCur = here->MOS1tSatCurDens * SourceSatCur = here->MOS1tSatCurDens *
here->MOS1m * here->MOS1sourceArea; here->MOS1m * here->MOS1sourceArea;
} }
GateSourceOverlapCap = model->MOS1gateSourceOverlapCapFactor * GateSourceOverlapCap = model->MOS1gateSourceOverlapCapFactor *
here->MOS1m * here->MOS1w; here->MOS1m * here->MOS1w;
GateDrainOverlapCap = model->MOS1gateDrainOverlapCapFactor * GateDrainOverlapCap = model->MOS1gateDrainOverlapCapFactor *
here->MOS1m * here->MOS1w; here->MOS1m * here->MOS1w;
GateBulkOverlapCap = model->MOS1gateBulkOverlapCapFactor * GateBulkOverlapCap = model->MOS1gateBulkOverlapCapFactor *
here->MOS1m * EffectiveLength; here->MOS1m * EffectiveLength;
Beta = here->MOS1tTransconductance * here->MOS1m * Beta = here->MOS1tTransconductance * here->MOS1m *
here->MOS1w/EffectiveLength; here->MOS1w/EffectiveLength;
OxideCap = model->MOS1oxideCapFactor * EffectiveLength * OxideCap = model->MOS1oxideCapFactor * EffectiveLength *
here->MOS1m * here->MOS1w; here->MOS1m * here->MOS1w;
/* /*
* ok - now to do the start-up operations * ok - now to do the start-up operations
* *
* we must get values for vbs, vds, and vgs from somewhere * we must get values for vbs, vds, and vgs from somewhere
@ -162,7 +162,7 @@ MOS1load(GENmodel *inModel, CKTcircuit *ckt)
printf("MOS1senPertFlag = ON \n"); printf("MOS1senPertFlag = ON \n");
#endif /* SENSDEBUG */ #endif /* SENSDEBUG */
if((ckt->CKTsenInfo->SENmode == TRANSEN) && if((ckt->CKTsenInfo->SENmode == TRANSEN) &&
(ckt->CKTmode & MODEINITTRAN)) { (ckt->CKTmode & MODEINITTRAN)) {
vgs = *(ckt->CKTstate1 + here->MOS1vgs); vgs = *(ckt->CKTstate1 + here->MOS1vgs);
vds = *(ckt->CKTstate1 + here->MOS1vds); vds = *(ckt->CKTstate1 + here->MOS1vds);
vbs = *(ckt->CKTstate1 + here->MOS1vbs); vbs = *(ckt->CKTstate1 + here->MOS1vbs);
@ -171,7 +171,7 @@ MOS1load(GENmodel *inModel, CKTcircuit *ckt)
vgd = vgs - vds; vgd = vgs - vds;
} }
else if (ckt->CKTsenInfo->SENmode == ACSEN){ else if (ckt->CKTsenInfo->SENmode == ACSEN){
vgb = model->MOS1type * ( vgb = model->MOS1type * (
*(ckt->CKTrhsOp+here->MOS1gNode) - *(ckt->CKTrhsOp+here->MOS1gNode) -
*(ckt->CKTrhsOp+here->MOS1bNode)); *(ckt->CKTrhsOp+here->MOS1bNode));
vbs = *(ckt->CKTstate0 + here->MOS1vbs); vbs = *(ckt->CKTstate0 + here->MOS1vbs);
@ -197,41 +197,41 @@ MOS1load(GENmodel *inModel, CKTcircuit *ckt)
if((ckt->CKTmode & (MODEINITFLOAT | MODEINITPRED | MODEINITSMSIG if((ckt->CKTmode & (MODEINITFLOAT | MODEINITPRED | MODEINITSMSIG
| MODEINITTRAN)) || | MODEINITTRAN)) ||
( (ckt->CKTmode & MODEINITFIX) && (!here->MOS1off) ) ) { ( (ckt->CKTmode & MODEINITFIX) && (!here->MOS1off) ) ) {
#ifndef PREDICTOR #ifndef PREDICTOR
if(ckt->CKTmode & (MODEINITPRED | MODEINITTRAN) ) { if(ckt->CKTmode & (MODEINITPRED | MODEINITTRAN) ) {
/* predictor step */ /* predictor step */
xfact=ckt->CKTdelta/ckt->CKTdeltaOld[1]; xfact=ckt->CKTdelta/ckt->CKTdeltaOld[1];
*(ckt->CKTstate0 + here->MOS1vbs) = *(ckt->CKTstate0 + here->MOS1vbs) =
*(ckt->CKTstate1 + here->MOS1vbs); *(ckt->CKTstate1 + here->MOS1vbs);
vbs = (1+xfact)* (*(ckt->CKTstate1 + here->MOS1vbs)) vbs = (1+xfact)* (*(ckt->CKTstate1 + here->MOS1vbs))
-(xfact * (*(ckt->CKTstate2 + here->MOS1vbs))); -(xfact * (*(ckt->CKTstate2 + here->MOS1vbs)));
*(ckt->CKTstate0 + here->MOS1vgs) = *(ckt->CKTstate0 + here->MOS1vgs) =
*(ckt->CKTstate1 + here->MOS1vgs); *(ckt->CKTstate1 + here->MOS1vgs);
vgs = (1+xfact)* (*(ckt->CKTstate1 + here->MOS1vgs)) vgs = (1+xfact)* (*(ckt->CKTstate1 + here->MOS1vgs))
-(xfact * (*(ckt->CKTstate2 + here->MOS1vgs))); -(xfact * (*(ckt->CKTstate2 + here->MOS1vgs)));
*(ckt->CKTstate0 + here->MOS1vds) = *(ckt->CKTstate0 + here->MOS1vds) =
*(ckt->CKTstate1 + here->MOS1vds); *(ckt->CKTstate1 + here->MOS1vds);
vds = (1+xfact)* (*(ckt->CKTstate1 + here->MOS1vds)) vds = (1+xfact)* (*(ckt->CKTstate1 + here->MOS1vds))
-(xfact * (*(ckt->CKTstate2 + here->MOS1vds))); -(xfact * (*(ckt->CKTstate2 + here->MOS1vds)));
*(ckt->CKTstate0 + here->MOS1vbd) = *(ckt->CKTstate0 + here->MOS1vbd) =
*(ckt->CKTstate0 + here->MOS1vbs)- *(ckt->CKTstate0 + here->MOS1vbs)-
*(ckt->CKTstate0 + here->MOS1vds); *(ckt->CKTstate0 + here->MOS1vds);
} else { } else {
#endif /* PREDICTOR */ #endif /* PREDICTOR */
/* general iteration */ /* general iteration */
vbs = model->MOS1type * ( vbs = model->MOS1type * (
*(ckt->CKTrhsOld+here->MOS1bNode) - *(ckt->CKTrhsOld+here->MOS1bNode) -
*(ckt->CKTrhsOld+here->MOS1sNodePrime)); *(ckt->CKTrhsOld+here->MOS1sNodePrime));
vgs = model->MOS1type * ( vgs = model->MOS1type * (
*(ckt->CKTrhsOld+here->MOS1gNode) - *(ckt->CKTrhsOld+here->MOS1gNode) -
*(ckt->CKTrhsOld+here->MOS1sNodePrime)); *(ckt->CKTrhsOld+here->MOS1sNodePrime));
vds = model->MOS1type * ( vds = model->MOS1type * (
*(ckt->CKTrhsOld+here->MOS1dNodePrime) - *(ckt->CKTrhsOld+here->MOS1dNodePrime) -
*(ckt->CKTrhsOld+here->MOS1sNodePrime)); *(ckt->CKTrhsOld+here->MOS1sNodePrime));
#ifndef PREDICTOR #ifndef PREDICTOR
@ -242,8 +242,8 @@ MOS1load(GENmodel *inModel, CKTcircuit *ckt)
vbd=vbs-vds; vbd=vbs-vds;
vgd=vgs-vds; vgd=vgs-vds;
vgdo = *(ckt->CKTstate0 + here->MOS1vgs) - vgdo = *(ckt->CKTstate0 + here->MOS1vgs) -
*(ckt->CKTstate0 + here->MOS1vds); *(ckt->CKTstate0 + here->MOS1vds);
delvbs = vbs - *(ckt->CKTstate0 + here->MOS1vbs); delvbs = vbs - *(ckt->CKTstate0 + here->MOS1vbs);
delvbd = vbd - *(ckt->CKTstate0 + here->MOS1vbd); delvbd = vbd - *(ckt->CKTstate0 + here->MOS1vbd);
delvgs = vgs - *(ckt->CKTstate0 + here->MOS1vgs); delvgs = vgs - *(ckt->CKTstate0 + here->MOS1vgs);
@ -254,98 +254,98 @@ MOS1load(GENmodel *inModel, CKTcircuit *ckt)
if (here->MOS1mode >= 0) { if (here->MOS1mode >= 0) {
cdhat= cdhat=
here->MOS1cd- here->MOS1cd-
here->MOS1gbd * delvbd + here->MOS1gbd * delvbd +
here->MOS1gmbs * delvbs + here->MOS1gmbs * delvbs +
here->MOS1gm * delvgs + here->MOS1gm * delvgs +
here->MOS1gds * delvds ; here->MOS1gds * delvds ;
} else { } else {
cdhat= cdhat=
here->MOS1cd - here->MOS1cd -
( here->MOS1gbd - ( here->MOS1gbd -
here->MOS1gmbs) * delvbd - here->MOS1gmbs) * delvbd -
here->MOS1gm * delvgd + here->MOS1gm * delvgd +
here->MOS1gds * delvds ; here->MOS1gds * delvds ;
} }
cbhat= cbhat=
here->MOS1cbs + here->MOS1cbs +
here->MOS1cbd + here->MOS1cbd +
here->MOS1gbd * delvbd + here->MOS1gbd * delvbd +
here->MOS1gbs * delvbs ; here->MOS1gbs * delvbs ;
/* /*
*/ */
#ifndef NOBYPASS #ifndef NOBYPASS
/* now lets see if we can bypass (ugh) */ /* now lets see if we can bypass (ugh) */
tempv = (MAX(fabs(cbhat), tempv = (MAX(fabs(cbhat),
fabs(here->MOS1cbs + here->MOS1cbd)) + fabs(here->MOS1cbs + here->MOS1cbd)) +
ckt->CKTabstol); ckt->CKTabstol);
if ((!(ckt->CKTmode & if ((!(ckt->CKTmode &
(MODEINITPRED|MODEINITTRAN|MODEINITSMSIG))) && (MODEINITPRED|MODEINITTRAN|MODEINITSMSIG))) &&
(ckt->CKTbypass) && (ckt->CKTbypass) &&
(fabs(cbhat-(here->MOS1cbs + (fabs(cbhat-(here->MOS1cbs +
here->MOS1cbd)) < ckt->CKTreltol * tempv) && here->MOS1cbd)) < ckt->CKTreltol * tempv) &&
(fabs(delvbs) < (ckt->CKTreltol * (fabs(delvbs) < (ckt->CKTreltol *
MAX(fabs(vbs), MAX(fabs(vbs),
fabs( *(ckt->CKTstate0 + fabs( *(ckt->CKTstate0 +
here->MOS1vbs))) + here->MOS1vbs))) +
ckt->CKTvoltTol)) && ckt->CKTvoltTol)) &&
(fabs(delvbd) < (ckt->CKTreltol * (fabs(delvbd) < (ckt->CKTreltol *
MAX(fabs(vbd), MAX(fabs(vbd),
fabs(*(ckt->CKTstate0 + fabs(*(ckt->CKTstate0 +
here->MOS1vbd))) + here->MOS1vbd))) +
ckt->CKTvoltTol)) && ckt->CKTvoltTol)) &&
(fabs(delvgs) < (ckt->CKTreltol * (fabs(delvgs) < (ckt->CKTreltol *
MAX(fabs(vgs), MAX(fabs(vgs),
fabs(*(ckt->CKTstate0 + fabs(*(ckt->CKTstate0 +
here->MOS1vgs)))+ here->MOS1vgs)))+
ckt->CKTvoltTol)) && ckt->CKTvoltTol)) &&
(fabs(delvds) < (ckt->CKTreltol * (fabs(delvds) < (ckt->CKTreltol *
MAX(fabs(vds), MAX(fabs(vds),
fabs(*(ckt->CKTstate0 + fabs(*(ckt->CKTstate0 +
here->MOS1vds))) + here->MOS1vds))) +
ckt->CKTvoltTol)) && ckt->CKTvoltTol)) &&
(fabs(cdhat- here->MOS1cd) < (ckt->CKTreltol * (fabs(cdhat- here->MOS1cd) < (ckt->CKTreltol *
MAX(fabs(cdhat), MAX(fabs(cdhat),
fabs(here->MOS1cd)) + fabs(here->MOS1cd)) +
ckt->CKTabstol))) { ckt->CKTabstol))) {
/* bypass code */ /* bypass code */
/* nothing interesting has changed since last /* nothing interesting has changed since last
* iteration on this device, so we just * iteration on this device, so we just
* copy all the values computed last iteration out * copy all the values computed last iteration out
* and keep going * and keep going
*/ */
vbs = *(ckt->CKTstate0 + here->MOS1vbs); vbs = *(ckt->CKTstate0 + here->MOS1vbs);
vbd = *(ckt->CKTstate0 + here->MOS1vbd); vbd = *(ckt->CKTstate0 + here->MOS1vbd);
vgs = *(ckt->CKTstate0 + here->MOS1vgs); vgs = *(ckt->CKTstate0 + here->MOS1vgs);
vds = *(ckt->CKTstate0 + here->MOS1vds); vds = *(ckt->CKTstate0 + here->MOS1vds);
vgd = vgs - vds; vgd = vgs - vds;
vgb = vgs - vbs; vgb = vgs - vbs;
cdrain = here->MOS1mode * (here->MOS1cd + here->MOS1cbd); cdrain = here->MOS1mode * (here->MOS1cd + here->MOS1cbd);
if(ckt->CKTmode & (MODETRAN | MODETRANOP)) { if(ckt->CKTmode & (MODETRAN | MODETRANOP)) {
capgs = ( *(ckt->CKTstate0+here->MOS1capgs)+ capgs = ( *(ckt->CKTstate0+here->MOS1capgs)+
*(ckt->CKTstate1+here->MOS1capgs) + *(ckt->CKTstate1+here->MOS1capgs) +
GateSourceOverlapCap ); GateSourceOverlapCap );
capgd = ( *(ckt->CKTstate0+here->MOS1capgd)+ capgd = ( *(ckt->CKTstate0+here->MOS1capgd)+
*(ckt->CKTstate1+here->MOS1capgd) + *(ckt->CKTstate1+here->MOS1capgd) +
GateDrainOverlapCap ); GateDrainOverlapCap );
capgb = ( *(ckt->CKTstate0+here->MOS1capgb)+ capgb = ( *(ckt->CKTstate0+here->MOS1capgb)+
*(ckt->CKTstate1+here->MOS1capgb) + *(ckt->CKTstate1+here->MOS1capgb) +
GateBulkOverlapCap ); GateBulkOverlapCap );
if(ckt->CKTsenInfo){ if(ckt->CKTsenInfo){
here->MOS1cgs = capgs; here->MOS1cgs = capgs;
here->MOS1cgd = capgd; here->MOS1cgd = capgd;
here->MOS1cgb = capgb; here->MOS1cgb = capgb;
} }
} }
goto bypass; goto bypass;
} }
#endif /*NOBYPASS*/ #endif /*NOBYPASS*/
/* /*
*/ */
/* ok - bypass is out, do it the hard way */ /* ok - bypass is out, do it the hard way */
@ -353,7 +353,7 @@ MOS1load(GENmodel *inModel, CKTcircuit *ckt)
von = model->MOS1type * here->MOS1von; von = model->MOS1type * here->MOS1von;
#ifndef NODELIMITING #ifndef NODELIMITING
/* /*
* limiting * limiting
* we want to keep device voltages from changing * we want to keep device voltages from changing
* so fast that the exponentials churn out overflows * so fast that the exponentials churn out overflows
@ -362,7 +362,7 @@ MOS1load(GENmodel *inModel, CKTcircuit *ckt)
if(*(ckt->CKTstate0 + here->MOS1vds) >=0) { if(*(ckt->CKTstate0 + here->MOS1vds) >=0) {
vgs = DEVfetlim(vgs,*(ckt->CKTstate0 + here->MOS1vgs) vgs = DEVfetlim(vgs,*(ckt->CKTstate0 + here->MOS1vgs)
,von); ,von);
vds = vgs - vgd; vds = vgs - vgd;
vds = DEVlimvds(vds,*(ckt->CKTstate0 + here->MOS1vds)); vds = DEVlimvds(vds,*(ckt->CKTstate0 + here->MOS1vds));
vgd = vgs - vds; vgd = vgs - vds;
@ -370,23 +370,23 @@ MOS1load(GENmodel *inModel, CKTcircuit *ckt)
vgd = DEVfetlim(vgd,vgdo,von); vgd = DEVfetlim(vgd,vgdo,von);
vds = vgs - vgd; vds = vgs - vgd;
if(!(ckt->CKTfixLimit)) { if(!(ckt->CKTfixLimit)) {
vds = -DEVlimvds(-vds,-(*(ckt->CKTstate0 + vds = -DEVlimvds(-vds,-(*(ckt->CKTstate0 +
here->MOS1vds))); here->MOS1vds)));
} }
vgs = vgd + vds; vgs = vgd + vds;
} }
if(vds >= 0) { if(vds >= 0) {
vbs = DEVpnjlim(vbs,*(ckt->CKTstate0 + here->MOS1vbs), vbs = DEVpnjlim(vbs,*(ckt->CKTstate0 + here->MOS1vbs),
vt,here->MOS1sourceVcrit,&Check); vt,here->MOS1sourceVcrit,&Check);
vbd = vbs-vds; vbd = vbs-vds;
} else { } else {
vbd = DEVpnjlim(vbd,*(ckt->CKTstate0 + here->MOS1vbd), vbd = DEVpnjlim(vbd,*(ckt->CKTstate0 + here->MOS1vbd),
vt,here->MOS1drainVcrit,&Check); vt,here->MOS1drainVcrit,&Check);
vbs = vbd + vds; vbs = vbd + vds;
} }
#endif /*NODELIMITING*/ #endif /*NODELIMITING*/
/* /*
*/ */
} else { } else {
@ -400,20 +400,20 @@ MOS1load(GENmodel *inModel, CKTcircuit *ckt)
vds= model->MOS1type * here->MOS1icVDS; vds= model->MOS1type * here->MOS1icVDS;
vgs= model->MOS1type * here->MOS1icVGS; vgs= model->MOS1type * here->MOS1icVGS;
vbs= model->MOS1type * here->MOS1icVBS; vbs= model->MOS1type * here->MOS1icVBS;
if((vds==0) && (vgs==0) && (vbs==0) && if((vds==0) && (vgs==0) && (vbs==0) &&
((ckt->CKTmode & ((ckt->CKTmode &
(MODETRAN|MODEDCOP|MODEDCTRANCURVE)) || (MODETRAN|MODEDCOP|MODEDCTRANCURVE)) ||
(!(ckt->CKTmode & MODEUIC)))) { (!(ckt->CKTmode & MODEUIC)))) {
vbs = -1; vbs = -1;
vgs = model->MOS1type * here->MOS1tVto; vgs = model->MOS1type * here->MOS1tVto;
vds = 0; vds = 0;
} }
} else { } else {
vbs=vgs=vds=0; vbs=vgs=vds=0;
} }
} }
/* /*
*/ */
/* /*
@ -457,25 +457,25 @@ next1: if(vbs <= -3*vt) {
here->MOS1mode = -1; here->MOS1mode = -1;
} }
/* /*
*/ */
{ {
/* /*
* this block of code evaluates the drain current and its * this block of code evaluates the drain current and its
* derivatives using the shichman-hodges model and the * derivatives using the shichman-hodges model and the
* charges associated with the gate, channel and bulk for * charges associated with the gate, channel and bulk for
* mosfets * mosfets
* *
*/ */
/* the following 4 variables are local to this code block until /* the following 4 variables are local to this code block until
* it is obvious that they can be made global * it is obvious that they can be made global
*/ */
double arg; double arg;
double betap; double betap;
double sarg; double sarg;
double vgst; double vgst;
if ((here->MOS1mode==1?vbs:vbd) <= 0 ) { if ((here->MOS1mode==1?vbs:vbd) <= 0 ) {
sarg=sqrt(here->MOS1tPhi-(here->MOS1mode==1?vbs:vbd)); sarg=sqrt(here->MOS1tPhi-(here->MOS1mode==1?vbs:vbd));
@ -511,17 +511,17 @@ next1: if(vbs <= -3*vt) {
here->MOS1gds=model->MOS1lambda*Beta*vgst*vgst*.5; here->MOS1gds=model->MOS1lambda*Beta*vgst*vgst*.5;
here->MOS1gmbs=here->MOS1gm*arg; here->MOS1gmbs=here->MOS1gm*arg;
} else { } else {
/* /*
* linear region * linear region
*/ */
cdrain=betap*(vds*here->MOS1mode)* cdrain=betap*(vds*here->MOS1mode)*
(vgst-.5*(vds*here->MOS1mode)); (vgst-.5*(vds*here->MOS1mode));
here->MOS1gm=betap*(vds*here->MOS1mode); here->MOS1gm=betap*(vds*here->MOS1mode);
here->MOS1gds=betap*(vgst-(vds*here->MOS1mode))+ here->MOS1gds=betap*(vgst-(vds*here->MOS1mode))+
model->MOS1lambda*Beta* model->MOS1lambda*Beta*
(vds*here->MOS1mode)* (vds*here->MOS1mode)*
(vgst-.5*(vds*here->MOS1mode)); (vgst-.5*(vds*here->MOS1mode));
here->MOS1gmbs=here->MOS1gm*arg; here->MOS1gmbs=here->MOS1gm*arg;
} }
} }
/* /*
@ -529,7 +529,7 @@ next1: if(vbs <= -3*vt) {
*/ */
} }
/* /*
*/ */
/* now deal with n vs p polarity */ /* now deal with n vs p polarity */
@ -543,7 +543,7 @@ next1: if(vbs <= -3*vt) {
here->MOS1cd=here->MOS1mode * cdrain - here->MOS1cbd; here->MOS1cd=here->MOS1mode * cdrain - here->MOS1cbd;
if (ckt->CKTmode & (MODETRAN | MODETRANOP | MODEINITSMSIG)) { if (ckt->CKTmode & (MODETRAN | MODETRANOP | MODEINITSMSIG)) {
/* /*
* now we do the hard part of the bulk-drain and bulk-source * now we do the hard part of the bulk-drain and bulk-source
* diode - we evaluate the non-linear capacitance and * diode - we evaluate the non-linear capacitance and
* charge * charge
@ -563,123 +563,123 @@ next1: if(vbs <= -3*vt) {
fabs(*(ckt->CKTstate0+here->MOS1vbs)))+ fabs(*(ckt->CKTstate0+here->MOS1vbs)))+
ckt->CKTvoltTol)|| senflag) ckt->CKTvoltTol)|| senflag)
#endif /*CAPBYPASS*/ #endif /*CAPBYPASS*/
{ {
/* can't bypass the diode capacitance calculations */ /* can't bypass the diode capacitance calculations */
if(here->MOS1Cbs != 0 || here->MOS1Cbssw != 0 ) { if(here->MOS1Cbs != 0 || here->MOS1Cbssw != 0 ) {
if (vbs < here->MOS1tDepCap){ if (vbs < here->MOS1tDepCap){
arg=1-vbs/here->MOS1tBulkPot; arg=1-vbs/here->MOS1tBulkPot;
/* /*
* the following block looks somewhat long and messy, * the following block looks somewhat long and messy,
* but since most users use the default grading * but since most users use the default grading
* coefficients of .5, and sqrt is MUCH faster than an * coefficients of .5, and sqrt is MUCH faster than an
* exp(log()) we use this special case code to buy time. * exp(log()) we use this special case code to buy time.
* (as much as 10% of total job time!) * (as much as 10% of total job time!)
*/ */
if(model->MOS1bulkJctBotGradingCoeff == if(model->MOS1bulkJctBotGradingCoeff ==
model->MOS1bulkJctSideGradingCoeff) { model->MOS1bulkJctSideGradingCoeff) {
if(model->MOS1bulkJctBotGradingCoeff == .5) { if(model->MOS1bulkJctBotGradingCoeff == .5) {
sarg = sargsw = 1/sqrt(arg); sarg = sargsw = 1/sqrt(arg);
} else { } else {
sarg = sargsw = sarg = sargsw =
exp(-model->MOS1bulkJctBotGradingCoeff* exp(-model->MOS1bulkJctBotGradingCoeff*
log(arg)); log(arg));
} }
} else { } else {
if(model->MOS1bulkJctBotGradingCoeff == .5) { if(model->MOS1bulkJctBotGradingCoeff == .5) {
sarg = 1/sqrt(arg); sarg = 1/sqrt(arg);
} else { } else {
sarg = exp(-model->MOS1bulkJctBotGradingCoeff* sarg = exp(-model->MOS1bulkJctBotGradingCoeff*
log(arg)); log(arg));
} }
if(model->MOS1bulkJctSideGradingCoeff == .5) { if(model->MOS1bulkJctSideGradingCoeff == .5) {
sargsw = 1/sqrt(arg); sargsw = 1/sqrt(arg);
} else { } else {
sargsw =exp(-model->MOS1bulkJctSideGradingCoeff* sargsw =exp(-model->MOS1bulkJctSideGradingCoeff*
log(arg)); log(arg));
} }
} }
*(ckt->CKTstate0 + here->MOS1qbs) = *(ckt->CKTstate0 + here->MOS1qbs) =
here->MOS1tBulkPot*(here->MOS1Cbs* here->MOS1tBulkPot*(here->MOS1Cbs*
(1-arg*sarg)/(1-model->MOS1bulkJctBotGradingCoeff) (1-arg*sarg)/(1-model->MOS1bulkJctBotGradingCoeff)
+here->MOS1Cbssw* +here->MOS1Cbssw*
(1-arg*sargsw)/ (1-arg*sargsw)/
(1-model->MOS1bulkJctSideGradingCoeff)); (1-model->MOS1bulkJctSideGradingCoeff));
here->MOS1capbs=here->MOS1Cbs*sarg+ here->MOS1capbs=here->MOS1Cbs*sarg+
here->MOS1Cbssw*sargsw; here->MOS1Cbssw*sargsw;
} else { } else {
*(ckt->CKTstate0 + here->MOS1qbs) = here->MOS1f4s + *(ckt->CKTstate0 + here->MOS1qbs) = here->MOS1f4s +
vbs*(here->MOS1f2s+vbs*(here->MOS1f3s/2)); vbs*(here->MOS1f2s+vbs*(here->MOS1f3s/2));
here->MOS1capbs=here->MOS1f2s+here->MOS1f3s*vbs; here->MOS1capbs=here->MOS1f2s+here->MOS1f3s*vbs;
} }
} else { } else {
*(ckt->CKTstate0 + here->MOS1qbs) = 0; *(ckt->CKTstate0 + here->MOS1qbs) = 0;
here->MOS1capbs=0; here->MOS1capbs=0;
} }
} }
#ifdef CAPBYPASS #ifdef CAPBYPASS
if(((ckt->CKTmode & (MODEINITPRED | MODEINITTRAN) ) || if(((ckt->CKTmode & (MODEINITPRED | MODEINITTRAN) ) ||
fabs(delvbd) >= ckt->CKTreltol * MAX(fabs(vbd), fabs(delvbd) >= ckt->CKTreltol * MAX(fabs(vbd),
fabs(*(ckt->CKTstate0+here->MOS1vbd)))+ fabs(*(ckt->CKTstate0+here->MOS1vbd)))+
ckt->CKTvoltTol)|| senflag) ckt->CKTvoltTol)|| senflag)
#endif /*CAPBYPASS*/ #endif /*CAPBYPASS*/
/* can't bypass the diode capacitance calculations */ /* can't bypass the diode capacitance calculations */
{ {
if(here->MOS1Cbd != 0 || here->MOS1Cbdsw != 0 ) { if(here->MOS1Cbd != 0 || here->MOS1Cbdsw != 0 ) {
if (vbd < here->MOS1tDepCap) { if (vbd < here->MOS1tDepCap) {
arg=1-vbd/here->MOS1tBulkPot; arg=1-vbd/here->MOS1tBulkPot;
/* /*
* the following block looks somewhat long and messy, * the following block looks somewhat long and messy,
* but since most users use the default grading * but since most users use the default grading
* coefficients of .5, and sqrt is MUCH faster than an * coefficients of .5, and sqrt is MUCH faster than an
* exp(log()) we use this special case code to buy time. * exp(log()) we use this special case code to buy time.
* (as much as 10% of total job time!) * (as much as 10% of total job time!)
*/ */
if(model->MOS1bulkJctBotGradingCoeff == .5 && if(model->MOS1bulkJctBotGradingCoeff == .5 &&
model->MOS1bulkJctSideGradingCoeff == .5) { model->MOS1bulkJctSideGradingCoeff == .5) {
sarg = sargsw = 1/sqrt(arg); sarg = sargsw = 1/sqrt(arg);
} else { } else {
if(model->MOS1bulkJctBotGradingCoeff == .5) { if(model->MOS1bulkJctBotGradingCoeff == .5) {
sarg = 1/sqrt(arg); sarg = 1/sqrt(arg);
} else { } else {
sarg = exp(-model->MOS1bulkJctBotGradingCoeff* sarg = exp(-model->MOS1bulkJctBotGradingCoeff*
log(arg)); log(arg));
} }
if(model->MOS1bulkJctSideGradingCoeff == .5) { if(model->MOS1bulkJctSideGradingCoeff == .5) {
sargsw = 1/sqrt(arg); sargsw = 1/sqrt(arg);
} else { } else {
sargsw =exp(-model->MOS1bulkJctSideGradingCoeff* sargsw =exp(-model->MOS1bulkJctSideGradingCoeff*
log(arg)); log(arg));
} }
} }
*(ckt->CKTstate0 + here->MOS1qbd) = *(ckt->CKTstate0 + here->MOS1qbd) =
here->MOS1tBulkPot*(here->MOS1Cbd* here->MOS1tBulkPot*(here->MOS1Cbd*
(1-arg*sarg) (1-arg*sarg)
/(1-model->MOS1bulkJctBotGradingCoeff) /(1-model->MOS1bulkJctBotGradingCoeff)
+here->MOS1Cbdsw* +here->MOS1Cbdsw*
(1-arg*sargsw) (1-arg*sargsw)
/(1-model->MOS1bulkJctSideGradingCoeff)); /(1-model->MOS1bulkJctSideGradingCoeff));
here->MOS1capbd=here->MOS1Cbd*sarg+ here->MOS1capbd=here->MOS1Cbd*sarg+
here->MOS1Cbdsw*sargsw; here->MOS1Cbdsw*sargsw;
} else { } else {
*(ckt->CKTstate0 + here->MOS1qbd) = here->MOS1f4d + *(ckt->CKTstate0 + here->MOS1qbd) = here->MOS1f4d +
vbd * (here->MOS1f2d + vbd * here->MOS1f3d/2); vbd * (here->MOS1f2d + vbd * here->MOS1f3d/2);
here->MOS1capbd=here->MOS1f2d + vbd * here->MOS1f3d; here->MOS1capbd=here->MOS1f2d + vbd * here->MOS1f3d;
} }
} else { } else {
*(ckt->CKTstate0 + here->MOS1qbd) = 0; *(ckt->CKTstate0 + here->MOS1qbd) = 0;
here->MOS1capbd = 0; here->MOS1capbd = 0;
} }
} }
/* /*
*/ */
if(SenCond && (ckt->CKTsenInfo->SENmode==TRANSEN)) goto next2; if(SenCond && (ckt->CKTsenInfo->SENmode==TRANSEN)) goto next2;
if ( (ckt->CKTmode & MODETRAN) || ( (ckt->CKTmode&MODEINITTRAN) if ( (ckt->CKTmode & MODETRAN) || ( (ckt->CKTmode&MODEINITTRAN)
&& !(ckt->CKTmode&MODEUIC)) ) { && !(ckt->CKTmode&MODEUIC)) ) {
/* (above only excludes tranop, since we're only at this /* (above only excludes tranop, since we're only at this
* point if tran or tranop ) * point if tran or tranop )
*/ */
@ -692,20 +692,20 @@ next1: if(vbs <= -3*vt) {
/* integrate the capacitors and save results */ /* integrate the capacitors and save results */
error = NIintegrate(ckt,&geq,&ceq,here->MOS1capbd, error = NIintegrate(ckt,&geq,&ceq,here->MOS1capbd,
here->MOS1qbd); here->MOS1qbd);
if(error) return(error); if(error) return(error);
here->MOS1gbd += geq; here->MOS1gbd += geq;
here->MOS1cbd += *(ckt->CKTstate0 + here->MOS1cqbd); here->MOS1cbd += *(ckt->CKTstate0 + here->MOS1cqbd);
here->MOS1cd -= *(ckt->CKTstate0 + here->MOS1cqbd); here->MOS1cd -= *(ckt->CKTstate0 + here->MOS1cqbd);
error = NIintegrate(ckt,&geq,&ceq,here->MOS1capbs, error = NIintegrate(ckt,&geq,&ceq,here->MOS1capbs,
here->MOS1qbs); here->MOS1qbs);
if(error) return(error); if(error) return(error);
here->MOS1gbs += geq; here->MOS1gbs += geq;
here->MOS1cbs += *(ckt->CKTstate0 + here->MOS1cqbs); here->MOS1cbs += *(ckt->CKTstate0 + here->MOS1cqbs);
} }
} }
/* /*
*/ */
if(SenCond) goto next2; if(SenCond) goto next2;
@ -714,26 +714,27 @@ next1: if(vbs <= -3*vt) {
/* /*
* check convergence * check convergence
*/ */
if ( (here->MOS1off == 0) || if ( (here->MOS1off == 0) ||
(!(ckt->CKTmode & (MODEINITFIX|MODEINITSMSIG))) ){ (!(ckt->CKTmode & (MODEINITFIX|MODEINITSMSIG))) ){
if (Check == 1) { if (Check == 1) {
ckt->CKTnoncon++; ckt->CKTnoncon++;
ckt->CKTtroubleElt = (GENinstance *) here; ckt->CKTtroubleElt = (GENinstance *) here;
} }
} }
/* /*
*/ */
/* save things away for next time */ /* save things away for next time */
next2: *(ckt->CKTstate0 + here->MOS1vbs) = vbs; next2:
*(ckt->CKTstate0 + here->MOS1vbs) = vbs;
*(ckt->CKTstate0 + here->MOS1vbd) = vbd; *(ckt->CKTstate0 + here->MOS1vbd) = vbd;
*(ckt->CKTstate0 + here->MOS1vgs) = vgs; *(ckt->CKTstate0 + here->MOS1vgs) = vgs;
*(ckt->CKTstate0 + here->MOS1vds) = vds; *(ckt->CKTstate0 + here->MOS1vds) = vds;
/* /*
*/ */
/* /*
@ -743,7 +744,7 @@ next1: if(vbs <= -3*vt) {
/* /*
* calculate meyer's capacitors * calculate meyer's capacitors
*/ */
/* /*
* new cmeyer - this just evaluates at the current time, * new cmeyer - this just evaluates at the current time,
* expects you to remember values from previous time * expects you to remember values from previous time
* returns 1/2 of non-constant portion of capacitance * returns 1/2 of non-constant portion of capacitance
@ -752,37 +753,37 @@ next1: if(vbs <= -3*vt) {
*/ */
if (here->MOS1mode > 0){ if (here->MOS1mode > 0){
DEVqmeyer (vgs,vgd,vgb,von,vdsat, DEVqmeyer (vgs,vgd,vgb,von,vdsat,
(ckt->CKTstate0 + here->MOS1capgs), (ckt->CKTstate0 + here->MOS1capgs),
(ckt->CKTstate0 + here->MOS1capgd), (ckt->CKTstate0 + here->MOS1capgd),
(ckt->CKTstate0 + here->MOS1capgb), (ckt->CKTstate0 + here->MOS1capgb),
here->MOS1tPhi,OxideCap); here->MOS1tPhi,OxideCap);
} else { } else {
DEVqmeyer (vgd,vgs,vgb,von,vdsat, DEVqmeyer (vgd,vgs,vgb,von,vdsat,
(ckt->CKTstate0 + here->MOS1capgd), (ckt->CKTstate0 + here->MOS1capgd),
(ckt->CKTstate0 + here->MOS1capgs), (ckt->CKTstate0 + here->MOS1capgs),
(ckt->CKTstate0 + here->MOS1capgb), (ckt->CKTstate0 + here->MOS1capgb),
here->MOS1tPhi,OxideCap); here->MOS1tPhi,OxideCap);
} }
vgs1 = *(ckt->CKTstate1 + here->MOS1vgs); vgs1 = *(ckt->CKTstate1 + here->MOS1vgs);
vgd1 = vgs1 - *(ckt->CKTstate1 + here->MOS1vds); vgd1 = vgs1 - *(ckt->CKTstate1 + here->MOS1vds);
vgb1 = vgs1 - *(ckt->CKTstate1 + here->MOS1vbs); vgb1 = vgs1 - *(ckt->CKTstate1 + here->MOS1vbs);
if(ckt->CKTmode & (MODETRANOP|MODEINITSMSIG)) { if(ckt->CKTmode & (MODETRANOP|MODEINITSMSIG)) {
capgs = 2 * *(ckt->CKTstate0+here->MOS1capgs)+ capgs = 2 * *(ckt->CKTstate0+here->MOS1capgs)+
GateSourceOverlapCap ; GateSourceOverlapCap ;
capgd = 2 * *(ckt->CKTstate0+here->MOS1capgd)+ capgd = 2 * *(ckt->CKTstate0+here->MOS1capgd)+
GateDrainOverlapCap ; GateDrainOverlapCap ;
capgb = 2 * *(ckt->CKTstate0+here->MOS1capgb)+ capgb = 2 * *(ckt->CKTstate0+here->MOS1capgb)+
GateBulkOverlapCap ; GateBulkOverlapCap ;
} else { } else {
capgs = ( *(ckt->CKTstate0+here->MOS1capgs)+ capgs = ( *(ckt->CKTstate0+here->MOS1capgs)+
*(ckt->CKTstate1+here->MOS1capgs) + *(ckt->CKTstate1+here->MOS1capgs) +
GateSourceOverlapCap ); GateSourceOverlapCap );
capgd = ( *(ckt->CKTstate0+here->MOS1capgd)+ capgd = ( *(ckt->CKTstate0+here->MOS1capgd)+
*(ckt->CKTstate1+here->MOS1capgd) + *(ckt->CKTstate1+here->MOS1capgd) +
GateDrainOverlapCap ); GateDrainOverlapCap );
capgb = ( *(ckt->CKTstate0+here->MOS1capgb)+ capgb = ( *(ckt->CKTstate0+here->MOS1capgb)+
*(ckt->CKTstate1+here->MOS1capgb) + *(ckt->CKTstate1+here->MOS1capgb) +
GateBulkOverlapCap ); GateBulkOverlapCap );
} }
if(ckt->CKTsenInfo){ if(ckt->CKTsenInfo){
here->MOS1cgs = capgs; here->MOS1cgs = capgs;
@ -790,7 +791,7 @@ next1: if(vbs <= -3*vt) {
here->MOS1cgb = capgb; here->MOS1cgb = capgb;
} }
/* /*
*/ */
/* /*
@ -799,7 +800,7 @@ next1: if(vbs <= -3*vt) {
*/ */
if(SenCond){ if(SenCond){
if((ckt->CKTsenInfo->SENmode == DCSEN)|| if((ckt->CKTsenInfo->SENmode == DCSEN)||
(ckt->CKTsenInfo->SENmode == ACSEN)){ (ckt->CKTsenInfo->SENmode == ACSEN)){
continue; continue;
} }
} }
@ -807,14 +808,14 @@ next1: if(vbs <= -3*vt) {
#ifndef PREDICTOR #ifndef PREDICTOR
if (ckt->CKTmode & (MODEINITPRED | MODEINITTRAN) ) { if (ckt->CKTmode & (MODEINITPRED | MODEINITTRAN) ) {
*(ckt->CKTstate0 + here->MOS1qgs) = *(ckt->CKTstate0 + here->MOS1qgs) =
(1+xfact) * *(ckt->CKTstate1 + here->MOS1qgs) (1+xfact) * *(ckt->CKTstate1 + here->MOS1qgs)
- xfact * *(ckt->CKTstate2 + here->MOS1qgs); - xfact * *(ckt->CKTstate2 + here->MOS1qgs);
*(ckt->CKTstate0 + here->MOS1qgd) = *(ckt->CKTstate0 + here->MOS1qgd) =
(1+xfact) * *(ckt->CKTstate1 + here->MOS1qgd) (1+xfact) * *(ckt->CKTstate1 + here->MOS1qgd)
- xfact * *(ckt->CKTstate2 + here->MOS1qgd); - xfact * *(ckt->CKTstate2 + here->MOS1qgd);
*(ckt->CKTstate0 + here->MOS1qgb) = *(ckt->CKTstate0 + here->MOS1qgb) =
(1+xfact) * *(ckt->CKTstate1 + here->MOS1qgb) (1+xfact) * *(ckt->CKTstate1 + here->MOS1qgb)
- xfact * *(ckt->CKTstate2 + here->MOS1qgb); - xfact * *(ckt->CKTstate2 + here->MOS1qgb);
} else { } else {
#endif /*PREDICTOR*/ #endif /*PREDICTOR*/
if(ckt->CKTmode & MODETRAN) { if(ckt->CKTmode & MODETRAN) {
@ -835,14 +836,14 @@ next1: if(vbs <= -3*vt) {
#endif /*PREDICTOR*/ #endif /*PREDICTOR*/
} }
#ifndef NOBYPASS #ifndef NOBYPASS
bypass: bypass:
#endif #endif
if(SenCond) continue; if(SenCond) continue;
if ( (ckt->CKTmode & (MODEINITTRAN)) || if ( (ckt->CKTmode & (MODEINITTRAN)) ||
(! (ckt->CKTmode & (MODETRAN)) ) ) { (! (ckt->CKTmode & (MODETRAN)) ) ) {
/* /*
* initialize to zero charge conductances * initialize to zero charge conductances
* and current * and current
*/ */
gcgs=0; gcgs=0;
@ -865,12 +866,12 @@ next1: if(vbs <= -3*vt) {
if(error) return(error); if(error) return(error);
error = NIintegrate(ckt,&gcgb,&ceqgb,capgb,here->MOS1qgb); error = NIintegrate(ckt,&gcgb,&ceqgb,capgb,here->MOS1qgb);
if(error) return(error); if(error) return(error);
ceqgs=ceqgs-gcgs*vgs+ckt->CKTag[0]* ceqgs=ceqgs-gcgs*vgs+ckt->CKTag[0]*
*(ckt->CKTstate0 + here->MOS1qgs); *(ckt->CKTstate0 + here->MOS1qgs);
ceqgd=ceqgd-gcgd*vgd+ckt->CKTag[0]* ceqgd=ceqgd-gcgd*vgd+ckt->CKTag[0]*
*(ckt->CKTstate0 + here->MOS1qgd); *(ckt->CKTstate0 + here->MOS1qgd);
ceqgb=ceqgb-gcgb*vgb+ckt->CKTag[0]* ceqgb=ceqgb-gcgb*vgb+ckt->CKTag[0]*
*(ckt->CKTstate0 + here->MOS1qgb); *(ckt->CKTstate0 + here->MOS1qgb);
} }
/* /*
* store charge storage info for meyer's cap in lx table * store charge storage info for meyer's cap in lx table
@ -879,29 +880,29 @@ next1: if(vbs <= -3*vt) {
/* /*
* load current vector * load current vector
*/ */
ceqbs = model->MOS1type * ceqbs = model->MOS1type *
(here->MOS1cbs-(here->MOS1gbs)*vbs); (here->MOS1cbs-(here->MOS1gbs)*vbs);
ceqbd = model->MOS1type * ceqbd = model->MOS1type *
(here->MOS1cbd-(here->MOS1gbd)*vbd); (here->MOS1cbd-(here->MOS1gbd)*vbd);
if (here->MOS1mode >= 0) { if (here->MOS1mode >= 0) {
xnrm=1; xnrm=1;
xrev=0; xrev=0;
cdreq=model->MOS1type*(cdrain-here->MOS1gds*vds- cdreq=model->MOS1type*(cdrain-here->MOS1gds*vds-
here->MOS1gm*vgs-here->MOS1gmbs*vbs); here->MOS1gm*vgs-here->MOS1gmbs*vbs);
} else { } else {
xnrm=0; xnrm=0;
xrev=1; xrev=1;
cdreq = -(model->MOS1type)*(cdrain-here->MOS1gds*(-vds)- cdreq = -(model->MOS1type)*(cdrain-here->MOS1gds*(-vds)-
here->MOS1gm*vgd-here->MOS1gmbs*vbd); here->MOS1gm*vgd-here->MOS1gmbs*vbd);
} }
*(ckt->CKTrhs + here->MOS1gNode) -= *(ckt->CKTrhs + here->MOS1gNode) -=
(model->MOS1type * (ceqgs + ceqgb + ceqgd)); (model->MOS1type * (ceqgs + ceqgb + ceqgd));
*(ckt->CKTrhs + here->MOS1bNode) -= *(ckt->CKTrhs + here->MOS1bNode) -=
(ceqbs + ceqbd - model->MOS1type * ceqgb); (ceqbs + ceqbd - model->MOS1type * ceqgb);
*(ckt->CKTrhs + here->MOS1dNodePrime) += *(ckt->CKTrhs + here->MOS1dNodePrime) +=
(ceqbd - cdreq + model->MOS1type * ceqgd); (ceqbd - cdreq + model->MOS1type * ceqgd);
*(ckt->CKTrhs + here->MOS1sNodePrime) += *(ckt->CKTrhs + here->MOS1sNodePrime) +=
cdreq + ceqbs + model->MOS1type * ceqgs; cdreq + ceqbs + model->MOS1type * ceqgs;
/* /*
* load y matrix * load y matrix
*/ */
@ -910,12 +911,12 @@ next1: if(vbs <= -3*vt) {
*(here->MOS1GgPtr) += ((gcgd+gcgs+gcgb)); *(here->MOS1GgPtr) += ((gcgd+gcgs+gcgb));
*(here->MOS1SsPtr) += (here->MOS1sourceConductance); *(here->MOS1SsPtr) += (here->MOS1sourceConductance);
*(here->MOS1BbPtr) += (here->MOS1gbd+here->MOS1gbs+gcgb); *(here->MOS1BbPtr) += (here->MOS1gbd+here->MOS1gbs+gcgb);
*(here->MOS1DPdpPtr) += *(here->MOS1DPdpPtr) +=
(here->MOS1drainConductance+here->MOS1gds+ (here->MOS1drainConductance+here->MOS1gds+
here->MOS1gbd+xrev*(here->MOS1gm+here->MOS1gmbs)+gcgd); here->MOS1gbd+xrev*(here->MOS1gm+here->MOS1gmbs)+gcgd);
*(here->MOS1SPspPtr) += *(here->MOS1SPspPtr) +=
(here->MOS1sourceConductance+here->MOS1gds+ (here->MOS1sourceConductance+here->MOS1gds+
here->MOS1gbs+xnrm*(here->MOS1gm+here->MOS1gmbs)+gcgs); here->MOS1gbs+xnrm*(here->MOS1gm+here->MOS1gmbs)+gcgs);
*(here->MOS1DdpPtr) += (-here->MOS1drainConductance); *(here->MOS1DdpPtr) += (-here->MOS1drainConductance);
*(here->MOS1GbPtr) -= gcgb; *(here->MOS1GbPtr) -= gcgb;
*(here->MOS1GdpPtr) -= gcgd; *(here->MOS1GdpPtr) -= gcgd;
@ -928,13 +929,13 @@ next1: if(vbs <= -3*vt) {
*(here->MOS1DPgPtr) += ((xnrm-xrev)*here->MOS1gm-gcgd); *(here->MOS1DPgPtr) += ((xnrm-xrev)*here->MOS1gm-gcgd);
*(here->MOS1DPbPtr) += (-here->MOS1gbd+(xnrm-xrev)*here->MOS1gmbs); *(here->MOS1DPbPtr) += (-here->MOS1gbd+(xnrm-xrev)*here->MOS1gmbs);
*(here->MOS1DPspPtr) += (-here->MOS1gds-xnrm* *(here->MOS1DPspPtr) += (-here->MOS1gds-xnrm*
(here->MOS1gm+here->MOS1gmbs)); (here->MOS1gm+here->MOS1gmbs));
*(here->MOS1SPgPtr) += (-(xnrm-xrev)*here->MOS1gm-gcgs); *(here->MOS1SPgPtr) += (-(xnrm-xrev)*here->MOS1gm-gcgs);
*(here->MOS1SPsPtr) += (-here->MOS1sourceConductance); *(here->MOS1SPsPtr) += (-here->MOS1sourceConductance);
*(here->MOS1SPbPtr) += (-here->MOS1gbs-(xnrm-xrev)*here->MOS1gmbs); *(here->MOS1SPbPtr) += (-here->MOS1gbs-(xnrm-xrev)*here->MOS1gmbs);
*(here->MOS1SPdpPtr) += (-here->MOS1gds-xrev* *(here->MOS1SPdpPtr) += (-here->MOS1gds-xrev*
(here->MOS1gm+here->MOS1gmbs)); (here->MOS1gm+here->MOS1gmbs));
} }
} }
return(OK); return(OK);
} } /* end of function MOS1load */