epilectrik
/
pyNgSpice
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Browse Source

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

pre-master-46
Jim Monte 7 years ago
committed by Holger Vogt
parent
93ae8b41ac
commit
34c2df11bb
1 changed files with 326 additions and 325 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 651
      src/spicelib/devices/mos1/mos1load.c

651
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
* sparse matrix previously provided
/* actually load the current value into the
* 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)) ||
( (ckt->CKTmode & MODEINITFIX) && (!here->MOS1off) ) ) {
| MODEINITTRAN)) ||
( (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->CKTstate1 + here->MOS1vbs);
*(ckt->CKTstate0 + 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)));
*(ckt->CKTstate0 + here->MOS1vgs) =
*(ckt->CKTstate1 + here->MOS1vgs);
-(xfact * (*(ckt->CKTstate2 + here->MOS1vbs)));
*(ckt->CKTstate0 + 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)));
*(ckt->CKTstate0 + here->MOS1vds) =
*(ckt->CKTstate1 + here->MOS1vds);
-(xfact * (*(ckt->CKTstate2 + here->MOS1vgs)));
*(ckt->CKTstate0 + 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)));
*(ckt->CKTstate0 + here->MOS1vbd) =
*(ckt->CKTstate0 + here->MOS1vbs)-
*(ckt->CKTstate0 + here->MOS1vds);
-(xfact * (*(ckt->CKTstate2 + here->MOS1vds)));
*(ckt->CKTstate0 + here->MOS1vbd) =
*(ckt->CKTstate0 + here->MOS1vbs)-
*(ckt->CKTstate0 + here->MOS1vds);
} else { } else {
#endif /* PREDICTOR */ #endif /* PREDICTOR */
/* general iteration */ /* general iteration */
vbs = model->MOS1type * (
*(ckt->CKTrhsOld+here->MOS1bNode) -
*(ckt->CKTrhsOld+here->MOS1sNodePrime));
vgs = model->MOS1type * (
vbs = model->MOS1type * (
*(ckt->CKTrhsOld+here->MOS1bNode) -
*(ckt->CKTrhsOld+here->MOS1sNodePrime));
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) -
*(ckt->CKTstate0 + here->MOS1vds);
vgdo = *(ckt->CKTstate0 + here->MOS1vgs) -
*(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->MOS1gbd * delvbd +
here->MOS1gmbs * delvbs +
here->MOS1gm * delvgs +
here->MOS1gds * delvds ;
here->MOS1cd-
here->MOS1gbd * delvbd +
here->MOS1gmbs * delvbs +
here->MOS1gm * delvgs +
here->MOS1gds * delvds ;
} else { } else {
cdhat= cdhat=
here->MOS1cd -
( here->MOS1gbd -
here->MOS1gmbs) * delvbd -
here->MOS1gm * delvgd +
here->MOS1cd -
( here->MOS1gbd -
here->MOS1gmbs) * delvbd -
here->MOS1gm * delvgd +
here->MOS1gds * delvds ; here->MOS1gds * delvds ;
} }
cbhat= cbhat=
here->MOS1cbs +
here->MOS1cbd +
here->MOS1gbd * delvbd +
here->MOS1gbs * delvbs ;
here->MOS1cbs +
here->MOS1cbd +
here->MOS1gbd * delvbd +
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)) +
ckt->CKTabstol);
fabs(here->MOS1cbs + here->MOS1cbd)) +
ckt->CKTabstol);
if ((!(ckt->CKTmode & if ((!(ckt->CKTmode &
(MODEINITPRED|MODEINITTRAN|MODEINITSMSIG))) &&
(ckt->CKTbypass) &&
(fabs(cbhat-(here->MOS1cbs +
here->MOS1cbd)) < ckt->CKTreltol * tempv) &&
(fabs(delvbs) < (ckt->CKTreltol *
MAX(fabs(vbs),
fabs( *(ckt->CKTstate0 +
here->MOS1vbs))) +
ckt->CKTvoltTol)) &&
(fabs(delvbd) < (ckt->CKTreltol *
MAX(fabs(vbd),
fabs(*(ckt->CKTstate0 +
here->MOS1vbd))) +
ckt->CKTvoltTol)) &&
(fabs(delvgs) < (ckt->CKTreltol *
MAX(fabs(vgs),
fabs(*(ckt->CKTstate0 +
here->MOS1vgs)))+
ckt->CKTvoltTol)) &&
(fabs(delvds) < (ckt->CKTreltol *
MAX(fabs(vds),
fabs(*(ckt->CKTstate0 +
here->MOS1vds))) +
ckt->CKTvoltTol)) &&
(fabs(cdhat- here->MOS1cd) < (ckt->CKTreltol *
MAX(fabs(cdhat),
fabs(here->MOS1cd)) +
ckt->CKTabstol))) {
/* bypass code */
/* nothing interesting has changed since last
* iteration on this device, so we just
* copy all the values computed last iteration out
* and keep going
*/
vbs = *(ckt->CKTstate0 + here->MOS1vbs);
vbd = *(ckt->CKTstate0 + here->MOS1vbd);
vgs = *(ckt->CKTstate0 + here->MOS1vgs);
vds = *(ckt->CKTstate0 + here->MOS1vds);
vgd = vgs - vds;
vgb = vgs - vbs;
cdrain = here->MOS1mode * (here->MOS1cd + here->MOS1cbd);
if(ckt->CKTmode & (MODETRAN | MODETRANOP)) {
capgs = ( *(ckt->CKTstate0+here->MOS1capgs)+
*(ckt->CKTstate1+here->MOS1capgs) +
GateSourceOverlapCap );
capgd = ( *(ckt->CKTstate0+here->MOS1capgd)+
*(ckt->CKTstate1+here->MOS1capgd) +
GateDrainOverlapCap );
capgb = ( *(ckt->CKTstate0+here->MOS1capgb)+
*(ckt->CKTstate1+here->MOS1capgb) +
GateBulkOverlapCap );
if(ckt->CKTsenInfo){
here->MOS1cgs = capgs;
here->MOS1cgd = capgd;
here->MOS1cgb = capgb;
}
}
goto bypass;
}
(MODEINITPRED|MODEINITTRAN|MODEINITSMSIG))) &&
(ckt->CKTbypass) &&
(fabs(cbhat-(here->MOS1cbs +
here->MOS1cbd)) < ckt->CKTreltol * tempv) &&
(fabs(delvbs) < (ckt->CKTreltol *
MAX(fabs(vbs),
fabs( *(ckt->CKTstate0 +
here->MOS1vbs))) +
ckt->CKTvoltTol)) &&
(fabs(delvbd) < (ckt->CKTreltol *
MAX(fabs(vbd),
fabs(*(ckt->CKTstate0 +
here->MOS1vbd))) +
ckt->CKTvoltTol)) &&
(fabs(delvgs) < (ckt->CKTreltol *
MAX(fabs(vgs),
fabs(*(ckt->CKTstate0 +
here->MOS1vgs)))+
ckt->CKTvoltTol)) &&
(fabs(delvds) < (ckt->CKTreltol *
MAX(fabs(vds),
fabs(*(ckt->CKTstate0 +
here->MOS1vds))) +
ckt->CKTvoltTol)) &&
(fabs(cdhat- here->MOS1cd) < (ckt->CKTreltol *
MAX(fabs(cdhat),
fabs(here->MOS1cd)) +
ckt->CKTabstol))) {
/* bypass code */
/* nothing interesting has changed since last
* iteration on this device, so we just
* copy all the values computed last iteration out
* and keep going
*/
vbs = *(ckt->CKTstate0 + here->MOS1vbs);
vbd = *(ckt->CKTstate0 + here->MOS1vbd);
vgs = *(ckt->CKTstate0 + here->MOS1vgs);
vds = *(ckt->CKTstate0 + here->MOS1vds);
vgd = vgs - vds;
vgb = vgs - vbs;
cdrain = here->MOS1mode * (here->MOS1cd + here->MOS1cbd);
if(ckt->CKTmode & (MODETRAN | MODETRANOP)) {
capgs = ( *(ckt->CKTstate0+here->MOS1capgs)+
*(ckt->CKTstate1+here->MOS1capgs) +
GateSourceOverlapCap );
capgd = ( *(ckt->CKTstate0+here->MOS1capgd)+
*(ckt->CKTstate1+here->MOS1capgd) +
GateDrainOverlapCap );
capgb = ( *(ckt->CKTstate0+here->MOS1capgb)+
*(ckt->CKTstate1+here->MOS1capgb) +
GateBulkOverlapCap );
if(ckt->CKTsenInfo){
here->MOS1cgs = capgs;
here->MOS1cgd = capgd;
here->MOS1cgb = capgb;
}
}
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 +
here->MOS1vds)));
vds = -DEVlimvds(-vds,-(*(ckt->CKTstate0 +
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) &&
((ckt->CKTmode &
(MODETRAN|MODEDCOP|MODEDCTRANCURVE)) ||
(!(ckt->CKTmode & MODEUIC)))) {
if((vds==0) && (vgs==0) && (vbs==0) &&
((ckt->CKTmode &
(MODETRAN|MODEDCOP|MODEDCTRANCURVE)) ||
(!(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
* derivatives using the shichman-hodges model and the
* charges associated with the gate, channel and bulk for
* mosfets
*
*/
/* the following 4 variables are local to this code block until
* it is obvious that they can be made global
*/
double arg;
double betap;
double sarg;
double vgst;
/*
* this block of code evaluates the drain current and its
* derivatives using the shichman-hodges model and the
* charges associated with the gate, channel and bulk for
* mosfets
*
*/
/* the following 4 variables are local to this code block until
* it is obvious that they can be made global
*/
double arg;
double betap;
double sarg;
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*
(vds*here->MOS1mode)*
(vgst-.5*(vds*here->MOS1mode));
here->MOS1gmbs=here->MOS1gm*arg;
model->MOS1lambda*Beta*
(vds*here->MOS1mode)*
(vgst-.5*(vds*here->MOS1mode));
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){
arg=1-vbs/here->MOS1tBulkPot;
/*
* the following block looks somewhat long and messy,
* but since most users use the default grading
* coefficients of .5, and sqrt is MUCH faster than an
* exp(log()) we use this special case code to buy time.
* (as much as 10% of total job time!)
*/
if(model->MOS1bulkJctBotGradingCoeff ==
model->MOS1bulkJctSideGradingCoeff) {
if(model->MOS1bulkJctBotGradingCoeff == .5) {
sarg = sargsw = 1/sqrt(arg);
} else {
sarg = sargsw =
exp(-model->MOS1bulkJctBotGradingCoeff*
log(arg));
}
} else {
if(model->MOS1bulkJctBotGradingCoeff == .5) {
sarg = 1/sqrt(arg);
} else {
sarg = exp(-model->MOS1bulkJctBotGradingCoeff*
log(arg));
}
if(model->MOS1bulkJctSideGradingCoeff == .5) {
sargsw = 1/sqrt(arg);
} else {
sargsw =exp(-model->MOS1bulkJctSideGradingCoeff*
log(arg));
}
}
*(ckt->CKTstate0 + here->MOS1qbs) =
here->MOS1tBulkPot*(here->MOS1Cbs*
(1-arg*sarg)/(1-model->MOS1bulkJctBotGradingCoeff)
+here->MOS1Cbssw*
(1-arg*sargsw)/
(1-model->MOS1bulkJctSideGradingCoeff));
here->MOS1capbs=here->MOS1Cbs*sarg+
here->MOS1Cbssw*sargsw;
} else {
*(ckt->CKTstate0 + here->MOS1qbs) = here->MOS1f4s +
vbs*(here->MOS1f2s+vbs*(here->MOS1f3s/2));
here->MOS1capbs=here->MOS1f2s+here->MOS1f3s*vbs;
}
if (vbs < here->MOS1tDepCap){
arg=1-vbs/here->MOS1tBulkPot;
/*
* the following block looks somewhat long and messy,
* but since most users use the default grading
* coefficients of .5, and sqrt is MUCH faster than an
* exp(log()) we use this special case code to buy time.
* (as much as 10% of total job time!)
*/
if(model->MOS1bulkJctBotGradingCoeff ==
model->MOS1bulkJctSideGradingCoeff) {
if(model->MOS1bulkJctBotGradingCoeff == .5) {
sarg = sargsw = 1/sqrt(arg);
} else {
sarg = sargsw =
exp(-model->MOS1bulkJctBotGradingCoeff*
log(arg));
}
} else {
if(model->MOS1bulkJctBotGradingCoeff == .5) {
sarg = 1/sqrt(arg);
} else {
sarg = exp(-model->MOS1bulkJctBotGradingCoeff*
log(arg));
}
if(model->MOS1bulkJctSideGradingCoeff == .5) {
sargsw = 1/sqrt(arg);
} else {
sargsw =exp(-model->MOS1bulkJctSideGradingCoeff*
log(arg));
}
}
*(ckt->CKTstate0 + here->MOS1qbs) =
here->MOS1tBulkPot*(here->MOS1Cbs*
(1-arg*sarg)/(1-model->MOS1bulkJctBotGradingCoeff)
+here->MOS1Cbssw*
(1-arg*sargsw)/
(1-model->MOS1bulkJctSideGradingCoeff));
here->MOS1capbs=here->MOS1Cbs*sarg+
here->MOS1Cbssw*sargsw;
} else {
*(ckt->CKTstate0 + here->MOS1qbs) = here->MOS1f4s +
vbs*(here->MOS1f2s+vbs*(here->MOS1f3s/2));
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(*(ckt->CKTstate0+here->MOS1vbd)))+
ckt->CKTvoltTol)|| senflag)
#endif /*CAPBYPASS*/
fabs(delvbd) >= ckt->CKTreltol * MAX(fabs(vbd),
fabs(*(ckt->CKTstate0+here->MOS1vbd)))+
ckt->CKTvoltTol)|| senflag)
#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) {
arg=1-vbd/here->MOS1tBulkPot;
/*
* the following block looks somewhat long and messy,
* but since most users use the default grading
* coefficients of .5, and sqrt is MUCH faster than an
* exp(log()) we use this special case code to buy time.
* (as much as 10% of total job time!)
*/
if(model->MOS1bulkJctBotGradingCoeff == .5 &&
model->MOS1bulkJctSideGradingCoeff == .5) {
sarg = sargsw = 1/sqrt(arg);
} else {
if(model->MOS1bulkJctBotGradingCoeff == .5) {
sarg = 1/sqrt(arg);
} else {
sarg = exp(-model->MOS1bulkJctBotGradingCoeff*
log(arg));
}
if(model->MOS1bulkJctSideGradingCoeff == .5) {
sargsw = 1/sqrt(arg);
} else {
sargsw =exp(-model->MOS1bulkJctSideGradingCoeff*
log(arg));
}
}
*(ckt->CKTstate0 + here->MOS1qbd) =
here->MOS1tBulkPot*(here->MOS1Cbd*
(1-arg*sarg)
/(1-model->MOS1bulkJctBotGradingCoeff)
+here->MOS1Cbdsw*
(1-arg*sargsw)
/(1-model->MOS1bulkJctSideGradingCoeff));
here->MOS1capbd=here->MOS1Cbd*sarg+
here->MOS1Cbdsw*sargsw;
} else {
*(ckt->CKTstate0 + here->MOS1qbd) = here->MOS1f4d +
vbd * (here->MOS1f2d + vbd * here->MOS1f3d/2);
here->MOS1capbd=here->MOS1f2d + vbd * here->MOS1f3d;
}
} else {
*(ckt->CKTstate0 + here->MOS1qbd) = 0;
here->MOS1capbd = 0;
}
if (vbd < here->MOS1tDepCap) {
arg=1-vbd/here->MOS1tBulkPot;
/*
* the following block looks somewhat long and messy,
* but since most users use the default grading
* coefficients of .5, and sqrt is MUCH faster than an
* exp(log()) we use this special case code to buy time.
* (as much as 10% of total job time!)
*/
if(model->MOS1bulkJctBotGradingCoeff == .5 &&
model->MOS1bulkJctSideGradingCoeff == .5) {
sarg = sargsw = 1/sqrt(arg);
} else {
if(model->MOS1bulkJctBotGradingCoeff == .5) {
sarg = 1/sqrt(arg);
} else {
sarg = exp(-model->MOS1bulkJctBotGradingCoeff*
log(arg));
}
if(model->MOS1bulkJctSideGradingCoeff == .5) {
sargsw = 1/sqrt(arg);
} else {
sargsw =exp(-model->MOS1bulkJctSideGradingCoeff*
log(arg));
}
}
*(ckt->CKTstate0 + here->MOS1qbd) =
here->MOS1tBulkPot*(here->MOS1Cbd*
(1-arg*sarg)
/(1-model->MOS1bulkJctBotGradingCoeff)
+here->MOS1Cbdsw*
(1-arg*sargsw)
/(1-model->MOS1bulkJctSideGradingCoeff));
here->MOS1capbd=here->MOS1Cbd*sarg+
here->MOS1Cbdsw*sargsw;
} else {
*(ckt->CKTstate0 + here->MOS1qbd) = here->MOS1f4d +
vbd * (here->MOS1f2d + vbd * here->MOS1f3d/2);
here->MOS1capbd=here->MOS1f2d + vbd * here->MOS1f3d;
}
} else {
*(ckt->CKTstate0 + here->MOS1qbd) = 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) ||
(!(ckt->CKTmode & (MODEINITFIX|MODEINITSMSIG))) ){
if ( (here->MOS1off == 0) ||
(!(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->MOS1capgd),
(ckt->CKTstate0 + here->MOS1capgb),
here->MOS1tPhi,OxideCap);
(ckt->CKTstate0 + here->MOS1capgs),
(ckt->CKTstate0 + here->MOS1capgd),
(ckt->CKTstate0 + here->MOS1capgb),
here->MOS1tPhi,OxideCap);
} else { } else {
DEVqmeyer (vgd,vgs,vgb,von,vdsat, DEVqmeyer (vgd,vgs,vgb,von,vdsat,
(ckt->CKTstate0 + here->MOS1capgd),
(ckt->CKTstate0 + here->MOS1capgs),
(ckt->CKTstate0 + here->MOS1capgb),
here->MOS1tPhi,OxideCap);
(ckt->CKTstate0 + here->MOS1capgd),
(ckt->CKTstate0 + here->MOS1capgs),
(ckt->CKTstate0 + here->MOS1capgb),
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)+
GateSourceOverlapCap ;
capgd = 2 * *(ckt->CKTstate0+here->MOS1capgd)+
GateDrainOverlapCap ;
capgb = 2 * *(ckt->CKTstate0+here->MOS1capgb)+
GateBulkOverlapCap ;
capgs = 2 * *(ckt->CKTstate0+here->MOS1capgs)+
GateSourceOverlapCap ;
capgd = 2 * *(ckt->CKTstate0+here->MOS1capgd)+
GateDrainOverlapCap ;
capgb = 2 * *(ckt->CKTstate0+here->MOS1capgb)+
GateBulkOverlapCap ;
} else { } else {
capgs = ( *(ckt->CKTstate0+here->MOS1capgs)+
*(ckt->CKTstate1+here->MOS1capgs) +
GateSourceOverlapCap );
capgd = ( *(ckt->CKTstate0+here->MOS1capgd)+
*(ckt->CKTstate1+here->MOS1capgd) +
GateDrainOverlapCap );
capgb = ( *(ckt->CKTstate0+here->MOS1capgb)+
*(ckt->CKTstate1+here->MOS1capgb) +
GateBulkOverlapCap );
capgs = ( *(ckt->CKTstate0+here->MOS1capgs)+
*(ckt->CKTstate1+here->MOS1capgs) +
GateSourceOverlapCap );
capgd = ( *(ckt->CKTstate0+here->MOS1capgd)+
*(ckt->CKTstate1+here->MOS1capgd) +
GateDrainOverlapCap );
capgb = ( *(ckt->CKTstate0+here->MOS1capgb)+
*(ckt->CKTstate1+here->MOS1capgb) +
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)
- xfact * *(ckt->CKTstate2 + here->MOS1qgs);
(1+xfact) * *(ckt->CKTstate1 + here->MOS1qgs)
- xfact * *(ckt->CKTstate2 + here->MOS1qgs);
*(ckt->CKTstate0 + here->MOS1qgd) = *(ckt->CKTstate0 + here->MOS1qgd) =
(1+xfact) * *(ckt->CKTstate1 + here->MOS1qgd)
- xfact * *(ckt->CKTstate2 + here->MOS1qgd);
(1+xfact) * *(ckt->CKTstate1 + here->MOS1qgd)
- xfact * *(ckt->CKTstate2 + here->MOS1qgd);
*(ckt->CKTstate0 + here->MOS1qgb) = *(ckt->CKTstate0 + here->MOS1qgb) =
(1+xfact) * *(ckt->CKTstate1 + here->MOS1qgb)
- xfact * *(ckt->CKTstate2 + here->MOS1qgb);
(1+xfact) * *(ckt->CKTstate1 + 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)) ||
(! (ckt->CKTmode & (MODETRAN)) ) ) {
if ( (ckt->CKTmode & (MODEINITTRAN)) ||
(! (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]*
*(ckt->CKTstate0 + here->MOS1qgs);
ceqgs=ceqgs-gcgs*vgs+ckt->CKTag[0]*
*(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 *
(here->MOS1cbs-(here->MOS1gbs)*vbs);
ceqbd = model->MOS1type *
(here->MOS1cbd-(here->MOS1gbd)*vbd);
ceqbs = model->MOS1type *
(here->MOS1cbs-(here->MOS1gbs)*vbs);
ceqbd = model->MOS1type *
(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) -=
(model->MOS1type * (ceqgs + ceqgb + ceqgd));
*(ckt->CKTrhs + here->MOS1gNode) -=
(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);
*(ckt->CKTrhs + here->MOS1sNodePrime) +=
cdreq + ceqbs + model->MOS1type * ceqgs;
(ceqbd - cdreq + model->MOS1type * ceqgd);
*(ckt->CKTrhs + here->MOS1sNodePrime) +=
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->MOS1drainConductance+here->MOS1gds+
here->MOS1gbd+xrev*(here->MOS1gm+here->MOS1gmbs)+gcgd);
*(here->MOS1SPspPtr) +=
(here->MOS1sourceConductance+here->MOS1gds+
here->MOS1gbs+xnrm*(here->MOS1gm+here->MOS1gmbs)+gcgs);
*(here->MOS1DPdpPtr) +=
(here->MOS1drainConductance+here->MOS1gds+
here->MOS1gbd+xrev*(here->MOS1gm+here->MOS1gmbs)+gcgd);
*(here->MOS1SPspPtr) +=
(here->MOS1sourceConductance+here->MOS1gds+
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 */
Write Preview
Loading…
Cancel
Save