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

mos1...3: formatting and white spaces

This commit is contained in:
dwarning 2024-01-23 17:01:05 +01:00
parent 1381d71cb1
commit 89c7b83954
12 changed files with 365 additions and 365 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
src/spicelib/devices/mos1/mos1mask.c
View File

@ -109,10 +109,10 @@ MOS1mAsk(CKTcircuit *ckt, GENmodel *inst, int which, IFvalue *value)
value->iValue = model->MOS1nlev;
return(OK);
case MOS1_MOD_TYPE:
if (model->MOS1type > 0)
value->sValue = "nmos";
else
value->sValue = "pmos";
if (model->MOS1type > 0)
value->sValue = "nmos";
else
value->sValue = "pmos";
return(OK);
default:
return(E_BADPARM);

24
src/spicelib/devices/mos1/mos1mpar.c
View File

@ -139,18 +139,18 @@ MOS1mParam(int param, IFvalue *value, GENmodel *inModel)
model->MOS1typeGiven = TRUE;
}
break;
case MOS1_MOD_KF:
model->MOS1fNcoef = value->rValue;
model->MOS1fNcoefGiven = TRUE;
break;
case MOS1_MOD_AF:
model->MOS1fNexp = value->rValue;
model->MOS1fNexpGiven = TRUE;
break;
case MOS1_MOD_NLEV:
model->MOS1nlev = value->iValue;
model->MOS1nlevGiven = TRUE;
break;
case MOS1_MOD_KF:
model->MOS1fNcoef = value->rValue;
model->MOS1fNcoefGiven = TRUE;
break;
case MOS1_MOD_AF:
model->MOS1fNexp = value->rValue;
model->MOS1fNexpGiven = TRUE;
break;
case MOS1_MOD_NLEV:
model->MOS1nlev = value->iValue;
model->MOS1nlevGiven = TRUE;
break;
default:
return(E_BADPARM);
}

120
src/spicelib/devices/mos1/mos1noi.c
View File

@ -24,7 +24,7 @@ Modified: 2000 AlansFixes
int
MOS1noise(int mode, int operation, GENmodel * genmodel, CKTcircuit * ckt,
Ndata * data, double * OnDens) {
NOISEAN * job = (NOISEAN * ) ckt -> CKTcurJob;
NOISEAN * job = (NOISEAN * ) ckt->CKTcurJob;
MOS1model * firstModel = (MOS1model * ) genmodel;
MOS1model * model;
@ -56,10 +56,10 @@ MOS1noise(int mode, int operation, GENmodel * genmodel, CKTcircuit * ckt,
/* Oxide capacitance can be zero in MOS level 1. Since this will give us problems in our 1/f */
/* noise model, we ASSUME an actual "tox" of 1e-7 */
if (model -> MOS1oxideCapFactor == 0.0) {
if (model->MOS1oxideCapFactor == 0.0) {
coxSquared = 3.9 * 8.854214871e-12 / 1e-7;
} else {
coxSquared = model -> MOS1oxideCapFactor;
coxSquared = model->MOS1oxideCapFactor;
}
coxSquared *= coxSquared;
for (inst = MOS1instances(model); inst != NULL; inst = MOS1nextInstance(inst)) {
@ -71,19 +71,19 @@ MOS1noise(int mode, int operation, GENmodel * genmodel, CKTcircuit * ckt,
/* see if we have to to produce a summary report */
/* if so, name all the noise generators */
if (job -> NStpsSm != 0) {
if (job->NStpsSm != 0) {
switch (mode) {
case N_DENS:
for (i = 0; i < MOS1NSRCS; i++) {
NOISE_ADD_OUTVAR(ckt, data, "onoise_%s%s", inst -> MOS1name, MOS1nNames[i]);
NOISE_ADD_OUTVAR(ckt, data, "onoise_%s%s", inst->MOS1name, MOS1nNames[i]);
}
break;
case INT_NOIZ:
for (i = 0; i < MOS1NSRCS; i++) {
NOISE_ADD_OUTVAR(ckt, data, "onoise_total_%s%s", inst -> MOS1name, MOS1nNames[i]);
NOISE_ADD_OUTVAR(ckt, data, "inoise_total_%s%s", inst -> MOS1name, MOS1nNames[i]);
NOISE_ADD_OUTVAR(ckt, data, "onoise_total_%s%s", inst->MOS1name, MOS1nNames[i]);
NOISE_ADD_OUTVAR(ckt, data, "inoise_total_%s%s", inst->MOS1name, MOS1nNames[i]);
}
break;
}
@ -95,54 +95,54 @@ MOS1noise(int mode, int operation, GENmodel * genmodel, CKTcircuit * ckt,
case N_DENS:
NevalSrc( & noizDens[MOS1RDNOIZ], & lnNdens[MOS1RDNOIZ],
ckt, THERMNOISE, inst -> MOS1dNodePrime, inst -> MOS1dNode,
inst -> MOS1drainConductance);
ckt, THERMNOISE, inst->MOS1dNodePrime, inst->MOS1dNode,
inst->MOS1drainConductance);
NevalSrc( & noizDens[MOS1RSNOIZ], & lnNdens[MOS1RSNOIZ],
ckt, THERMNOISE, inst -> MOS1sNodePrime, inst -> MOS1sNode,
inst -> MOS1sourceConductance);
ckt, THERMNOISE, inst->MOS1sNodePrime, inst->MOS1sNode,
inst->MOS1sourceConductance);
NevalSrc( & noizDens[MOS1IDNOIZ], & lnNdens[MOS1IDNOIZ],
ckt, THERMNOISE, inst -> MOS1dNodePrime, inst -> MOS1sNodePrime,
(2.0 / 3.0 * fabs(inst -> MOS1gm)));
ckt, THERMNOISE, inst->MOS1dNodePrime, inst->MOS1sNodePrime,
(2.0 / 3.0 * fabs(inst->MOS1gm)));
NevalSrc( & noizDens[MOS1FLNOIZ], NULL, ckt,
N_GAIN, inst -> MOS1dNodePrime, inst -> MOS1sNodePrime,
N_GAIN, inst->MOS1dNodePrime, inst->MOS1sNodePrime,
(double) 0.0);
if (newcompat.s3) {
noizDens[MOS1FLNOIZ] *= model -> MOS1fNcoef *
exp(model -> MOS1fNexp *
log(MAX(fabs(inst -> MOS1cd), N_MINLOG))) /
(data -> freq *
inst -> MOS1w *
(inst -> MOS1l - 2 * model -> MOS1latDiff) *
noizDens[MOS1FLNOIZ] *= model->MOS1fNcoef *
exp(model->MOS1fNexp *
log(MAX(fabs(inst->MOS1cd), N_MINLOG))) /
(data->freq *
inst->MOS1w *
(inst->MOS1l - 2 * model->MOS1latDiff) *
coxSquared);
} else {
switch (model -> MOS1nlev) {
switch (model->MOS1nlev) {
case 0:
noizDens[MOS1FLNOIZ] *= model -> MOS1fNcoef *
exp(model -> MOS1fNexp *
log(MAX(fabs(inst -> MOS1cd), N_MINLOG))) /
(data -> freq *
(inst -> MOS1l - 2 * model -> MOS1latDiff) *
(inst -> MOS1l - 2 * model -> MOS1latDiff) *
noizDens[MOS1FLNOIZ] *= model->MOS1fNcoef *
exp(model->MOS1fNexp *
log(MAX(fabs(inst->MOS1cd), N_MINLOG))) /
(data->freq *
(inst->MOS1l - 2 * model->MOS1latDiff) *
(inst->MOS1l - 2 * model->MOS1latDiff) *
sqrt(coxSquared));
break;
case 1:
noizDens[MOS1FLNOIZ] *= model -> MOS1fNcoef *
exp(model -> MOS1fNexp *
log(MAX(fabs(inst -> MOS1cd), N_MINLOG))) /
(data -> freq *
inst -> MOS1w *
(inst -> MOS1l - 2 * model -> MOS1latDiff) *
noizDens[MOS1FLNOIZ] *= model->MOS1fNcoef *
exp(model->MOS1fNexp *
log(MAX(fabs(inst->MOS1cd), N_MINLOG))) /
(data->freq *
inst->MOS1w *
(inst->MOS1l - 2 * model->MOS1latDiff) *
sqrt(coxSquared));
break;
case 2: case 3:
noizDens[MOS1FLNOIZ] *= model -> MOS1fNcoef *
inst -> MOS1gm * inst -> MOS1gm /
(pow(data -> freq, model -> MOS1fNexp) *
inst -> MOS1w *
(inst -> MOS1l - 2 * model -> MOS1latDiff) *
noizDens[MOS1FLNOIZ] *= model->MOS1fNcoef *
inst->MOS1gm * inst->MOS1gm /
(pow(data->freq, model->MOS1fNexp) *
inst->MOS1w *
(inst->MOS1l - 2 * model->MOS1latDiff) *
sqrt(coxSquared));
break;
}
@ -159,21 +159,21 @@ MOS1noise(int mode, int operation, GENmodel * genmodel, CKTcircuit * ckt,
* OnDens += noizDens[MOS1TOTNOIZ];
if (data -> delFreq == 0.0) {
if (data->delFreq == 0.0) {
/* if we haven't done any previous integration, we need to */
/* initialize our "history" variables */
for (i = 0; i < MOS1NSRCS; i++) {
inst -> MOS1nVar[LNLSTDENS][i] = lnNdens[i];
inst->MOS1nVar[LNLSTDENS][i] = lnNdens[i];
}
/* clear out our integration variables if it's the first pass */
if (data -> freq == job -> NstartFreq) {
if (data->freq == job->NstartFreq) {
for (i = 0; i < MOS1NSRCS; i++) {
inst -> MOS1nVar[OUTNOIZ][i] = 0.0;
inst -> MOS1nVar[INNOIZ][i] = 0.0;
inst->MOS1nVar[OUTNOIZ][i] = 0.0;
inst->MOS1nVar[INNOIZ][i] = 0.0;
}
}
} else {
@ -181,37 +181,37 @@ MOS1noise(int mode, int operation, GENmodel * genmodel, CKTcircuit * ckt,
for (i = 0; i < MOS1NSRCS; i++) {
if (i != MOS1TOTNOIZ) {
tempOnoise = Nintegrate(noizDens[i], lnNdens[i],
inst -> MOS1nVar[LNLSTDENS][i], data);
tempInoise = Nintegrate(noizDens[i] * data -> GainSqInv,
lnNdens[i] + data -> lnGainInv,
inst -> MOS1nVar[LNLSTDENS][i] + data -> lnGainInv,
inst->MOS1nVar[LNLSTDENS][i], data);
tempInoise = Nintegrate(noizDens[i] * data->GainSqInv,
lnNdens[i] + data->lnGainInv,
inst->MOS1nVar[LNLSTDENS][i] + data->lnGainInv,
data);
inst -> MOS1nVar[LNLSTDENS][i] = lnNdens[i];
data -> outNoiz += tempOnoise;
data -> inNoise += tempInoise;
if (job -> NStpsSm != 0) {
inst -> MOS1nVar[OUTNOIZ][i] += tempOnoise;
inst -> MOS1nVar[OUTNOIZ][MOS1TOTNOIZ] += tempOnoise;
inst -> MOS1nVar[INNOIZ][i] += tempInoise;
inst -> MOS1nVar[INNOIZ][MOS1TOTNOIZ] += tempInoise;
inst->MOS1nVar[LNLSTDENS][i] = lnNdens[i];
data->outNoiz += tempOnoise;
data->inNoise += tempInoise;
if (job->NStpsSm != 0) {
inst->MOS1nVar[OUTNOIZ][i] += tempOnoise;
inst->MOS1nVar[OUTNOIZ][MOS1TOTNOIZ] += tempOnoise;
inst->MOS1nVar[INNOIZ][i] += tempInoise;
inst->MOS1nVar[INNOIZ][MOS1TOTNOIZ] += tempInoise;
}
}
}
}
if (data -> prtSummary) {
if (data->prtSummary) {
for (i = 0; i < MOS1NSRCS; i++) {
/* print a summary report */
data -> outpVector[data -> outNumber++] = noizDens[i];
data->outpVector[data->outNumber++] = noizDens[i];
}
}
break;
case INT_NOIZ:
/* already calculated, just output */
if (job -> NStpsSm != 0) {
if (job->NStpsSm != 0) {
for (i = 0; i < MOS1NSRCS; i++) {
data -> outpVector[data -> outNumber++] = inst -> MOS1nVar[OUTNOIZ][i];
data -> outpVector[data -> outNumber++] = inst -> MOS1nVar[INNOIZ][i];
data->outpVector[data->outNumber++] = inst->MOS1nVar[OUTNOIZ][i];
data->outpVector[data->outNumber++] = inst->MOS1nVar[INNOIZ][i];
}
} /* if */
break;

82
src/spicelib/devices/mos1/mos1set.c
View File

@ -4,8 +4,8 @@ Author: 1985 Thomas L. Quarles
Modified: 2000 AlansFixes
**********/
/* load the MOS1 device structure with those pointers needed later
* for fast matrix loading
/* load the MOS1 device structure with those pointers needed later
* for fast matrix loading
*/
#include "ngspice/ngspice.h"
@ -81,15 +81,15 @@ MOS1setup(SMPmatrix *matrix, GENmodel *inModel, CKTcircuit *ckt,
if(!model->MOS1gammaGiven) {
model->MOS1gamma = 0;
}
if(!model->MOS1fNcoefGiven) {
model->MOS1fNcoef = 0;
}
if(!model->MOS1fNexpGiven) {
model->MOS1fNexp = 1;
}
if(!model->MOS1nlevGiven) {
model->MOS1nlev = 2;
}
if(!model->MOS1fNcoefGiven) {
model->MOS1fNcoef = 0;
}
if(!model->MOS1fNexpGiven) {
model->MOS1fNexp = 1;
}
if(!model->MOS1nlevGiven) {
model->MOS1nlev = 2;
}
/* loop through all the instances of the model */
for (here = MOS1instances(model); here != NULL ;
@ -124,34 +124,34 @@ MOS1setup(SMPmatrix *matrix, GENmodel *inModel, CKTcircuit *ckt,
if(!here->MOS1vonGiven) {
here->MOS1von = 0;
}
if(!here->MOS1drainSquaresGiven) {
here->MOS1drainSquares=1;
}
if(!here->MOS1sourceSquaresGiven) {
here->MOS1sourceSquares=1;
}
if(!here->MOS1drainSquaresGiven) {
here->MOS1drainSquares=1;
}
if(!here->MOS1sourceSquaresGiven) {
here->MOS1sourceSquares=1;
}
if ((model->MOS1drainResistance != 0
|| (model->MOS1sheetResistance != 0
|| (model->MOS1sheetResistance != 0
&& here->MOS1drainSquares != 0) )) {
if (here->MOS1dNodePrime == 0) {
error = CKTmkVolt(ckt,&tmp,here->MOS1name,"drain");
if(error) return(error);
here->MOS1dNodePrime = tmp->number;
if (ckt->CKTcopyNodesets) {
CKTnode *tmpNode;
IFuid tmpName;
CKTnode *tmpNode;
IFuid tmpName;
if (CKTinst2Node(ckt,here,1,&tmpNode,&tmpName)==OK) {
if (tmpNode->nsGiven) {
tmp->nodeset=tmpNode->nodeset;
tmp->nsGiven=tmpNode->nsGiven;
tmp->nodeset=tmpNode->nodeset;
tmp->nsGiven=tmpNode->nsGiven;
}
}
}
}
} else {
here->MOS1dNodePrime = here->MOS1dNode;
}
@ -163,19 +163,19 @@ MOS1setup(SMPmatrix *matrix, GENmodel *inModel, CKTcircuit *ckt,
error = CKTmkVolt(ckt,&tmp,here->MOS1name,"source");
if(error) return(error);
here->MOS1sNodePrime = tmp->number;
if (ckt->CKTcopyNodesets) {
CKTnode *tmpNode;
IFuid tmpName;
CKTnode *tmpNode;
IFuid tmpName;
if (CKTinst2Node(ckt,here,3,&tmpNode,&tmpName)==OK) {
if (tmpNode->nsGiven) {
tmp->nodeset=tmpNode->nodeset;
tmp->nsGiven=tmpNode->nsGiven;
tmp->nodeset=tmpNode->nodeset;
tmp->nsGiven=tmpNode->nsGiven;
}
}
}
}
} else {
here->MOS1sNodePrime = here->MOS1sNode;
@ -221,21 +221,21 @@ MOS1unsetup(GENmodel *inModel, CKTcircuit *ckt)
MOS1instance *here;
for (model = (MOS1model *)inModel; model != NULL;
model = MOS1nextModel(model))
model = MOS1nextModel(model))
{
for (here = MOS1instances(model); here != NULL;
here=MOS1nextInstance(here))
{
if (here->MOS1sNodePrime > 0
&& here->MOS1sNodePrime != here->MOS1sNode)
CKTdltNNum(ckt, here->MOS1sNodePrime);
here->MOS1sNodePrime= 0;
{
if (here->MOS1sNodePrime > 0
&& here->MOS1sNodePrime != here->MOS1sNode)
CKTdltNNum(ckt, here->MOS1sNodePrime);
here->MOS1sNodePrime= 0;
if (here->MOS1dNodePrime > 0
&& here->MOS1dNodePrime != here->MOS1dNode)
CKTdltNNum(ckt, here->MOS1dNodePrime);
here->MOS1dNodePrime= 0;
}
if (here->MOS1dNodePrime > 0
&& here->MOS1dNodePrime != here->MOS1dNode)
CKTdltNNum(ckt, here->MOS1dNodePrime);
here->MOS1dNodePrime= 0;
}
}
return OK;
}

30
src/spicelib/devices/mos2/mos2mask.c
View File

@ -124,21 +124,21 @@ MOS2mAsk(CKTcircuit *ckt, GENmodel *inModel, int param,
case MOS2_MOD_UCRIT:
value->rValue = model->MOS2critField;
break;
case MOS2_MOD_KF:
value->rValue = model->MOS2fNcoef;
break;
case MOS2_MOD_AF:
value->rValue = model->MOS2fNexp;
break;
case MOS2_MOD_NLEV:
value->iValue = model->MOS2nlev;
break;
case MOS2_MOD_TYPE:
if (model->MOS2type > 0)
value->sValue = "nmos";
else
value->sValue = "pmos";
break;
case MOS2_MOD_KF:
value->rValue = model->MOS2fNcoef;
break;
case MOS2_MOD_AF:
value->rValue = model->MOS2fNexp;
break;
case MOS2_MOD_NLEV:
value->iValue = model->MOS2nlev;
break;
case MOS2_MOD_TYPE:
if (model->MOS2type > 0)
value->sValue = "nmos";
else
value->sValue = "pmos";
break;
default:
return(E_BADPARM);
}

24
src/spicelib/devices/mos2/mos2mpar.c
View File

@ -170,18 +170,18 @@ MOS2mParam(int param, IFvalue *value, GENmodel *inModel)
model->MOS2typeGiven = TRUE;
}
break;
case MOS2_MOD_KF:
model->MOS2fNcoef = value->rValue;
model->MOS2fNcoefGiven = TRUE;
break;
case MOS2_MOD_AF:
model->MOS2fNexp = value->rValue;
model->MOS2fNexpGiven = TRUE;
break;
case MOS2_MOD_NLEV:
model->MOS2nlev = value->iValue;
model->MOS2nlevGiven = TRUE;
break;
case MOS2_MOD_KF:
model->MOS2fNcoef = value->rValue;
model->MOS2fNcoefGiven = TRUE;
break;
case MOS2_MOD_AF:
model->MOS2fNexp = value->rValue;
model->MOS2fNexpGiven = TRUE;
break;
case MOS2_MOD_NLEV:
model->MOS2nlev = value->iValue;
model->MOS2nlevGiven = TRUE;
break;
default:
return(E_BADPARM);
}

124
src/spicelib/devices/mos2/mos2noi.c
View File

@ -24,7 +24,7 @@ Modified: 2000 AlansFixes
int
MOS2noise(int mode, int operation, GENmodel * genmodel, CKTcircuit * ckt,
Ndata * data, double * OnDens) {
NOISEAN * job = (NOISEAN * ) ckt -> CKTcurJob;
NOISEAN * job = (NOISEAN * ) ckt->CKTcurJob;
MOS2model * firstModel = (MOS2model * ) genmodel;
MOS2model * model;
@ -60,19 +60,19 @@ MOS2noise(int mode, int operation, GENmodel * genmodel, CKTcircuit * ckt,
/* see if we have to to produce a summary report */
/* if so, name all the noise generators */
if (job -> NStpsSm != 0) {
if (job->NStpsSm != 0) {
switch (mode) {
case N_DENS:
for (i = 0; i < MOS2NSRCS; i++) {
NOISE_ADD_OUTVAR(ckt, data, "onoise_%s%s", inst -> MOS2name, MOS2nNames[i]);
NOISE_ADD_OUTVAR(ckt, data, "onoise_%s%s", inst->MOS2name, MOS2nNames[i]);
}
break;
case INT_NOIZ:
for (i = 0; i < MOS2NSRCS; i++) {
NOISE_ADD_OUTVAR(ckt, data, "onoise_total_%s%s", inst -> MOS2name, MOS2nNames[i]);
NOISE_ADD_OUTVAR(ckt, data, "inoise_total_%s%s", inst -> MOS2name, MOS2nNames[i]);
NOISE_ADD_OUTVAR(ckt, data, "onoise_total_%s%s", inst->MOS2name, MOS2nNames[i]);
NOISE_ADD_OUTVAR(ckt, data, "inoise_total_%s%s", inst->MOS2name, MOS2nNames[i]);
}
break;
}
@ -84,55 +84,55 @@ MOS2noise(int mode, int operation, GENmodel * genmodel, CKTcircuit * ckt,
case N_DENS:
NevalSrc( & noizDens[MOS2RDNOIZ], & lnNdens[MOS2RDNOIZ],
ckt, THERMNOISE, inst -> MOS2dNodePrime, inst -> MOS2dNode,
inst -> MOS2drainConductance);
ckt, THERMNOISE, inst->MOS2dNodePrime, inst->MOS2dNode,
inst->MOS2drainConductance);
NevalSrc( & noizDens[MOS2RSNOIZ], & lnNdens[MOS2RSNOIZ],
ckt, THERMNOISE, inst -> MOS2sNodePrime, inst -> MOS2sNode,
inst -> MOS2sourceConductance);
ckt, THERMNOISE, inst->MOS2sNodePrime, inst->MOS2sNode,
inst->MOS2sourceConductance);
NevalSrc( & noizDens[MOS2IDNOIZ], & lnNdens[MOS2IDNOIZ],
ckt, THERMNOISE, inst -> MOS2dNodePrime, inst -> MOS2sNodePrime,
(2.0 / 3.0 * fabs(inst -> MOS2gm)));
ckt, THERMNOISE, inst->MOS2dNodePrime, inst->MOS2sNodePrime,
(2.0 / 3.0 * fabs(inst->MOS2gm)));
NevalSrc( & noizDens[MOS2FLNOIZ], NULL, ckt,
N_GAIN, inst -> MOS2dNodePrime, inst -> MOS2sNodePrime,
N_GAIN, inst->MOS2dNodePrime, inst->MOS2sNodePrime,
(double) 0.0);
if (newcompat.s3) {
noizDens[MOS2FLNOIZ] *= model -> MOS2fNcoef *
exp(model -> MOS2fNexp *
log(MAX(fabs(inst -> MOS2cd), N_MINLOG))) /
(data -> freq *
inst -> MOS2w *
(inst -> MOS2l - 2 * model -> MOS2latDiff) *
model -> MOS2oxideCapFactor * model -> MOS2oxideCapFactor);
noizDens[MOS2FLNOIZ] *= model->MOS2fNcoef *
exp(model->MOS2fNexp *
log(MAX(fabs(inst->MOS2cd), N_MINLOG))) /
(data->freq *
inst->MOS2w *
(inst->MOS2l - 2 * model->MOS2latDiff) *
model->MOS2oxideCapFactor * model->MOS2oxideCapFactor);
} else {
switch (model -> MOS2nlev) {
switch (model->MOS2nlev) {
case 0:
noizDens[MOS2FLNOIZ] *= model -> MOS2fNcoef *
exp(model -> MOS2fNexp *
log(MAX(fabs(inst -> MOS2cd), N_MINLOG))) /
(data -> freq *
(inst -> MOS2l - 2 * model -> MOS2latDiff) *
(inst -> MOS2l - 2 * model -> MOS2latDiff) *
model -> MOS2oxideCapFactor);
noizDens[MOS2FLNOIZ] *= model->MOS2fNcoef *
exp(model->MOS2fNexp *
log(MAX(fabs(inst->MOS2cd), N_MINLOG))) /
(data->freq *
(inst->MOS2l - 2 * model->MOS2latDiff) *
(inst->MOS2l - 2 * model->MOS2latDiff) *
model->MOS2oxideCapFactor);
break;
case 1:
noizDens[MOS2FLNOIZ] *= model -> MOS2fNcoef *
exp(model -> MOS2fNexp *
log(MAX(fabs(inst -> MOS2cd), N_MINLOG))) /
(data -> freq *
inst -> MOS2w *
(inst -> MOS2l - 2 * model -> MOS2latDiff) *
model -> MOS2oxideCapFactor);
noizDens[MOS2FLNOIZ] *= model->MOS2fNcoef *
exp(model->MOS2fNexp *
log(MAX(fabs(inst->MOS2cd), N_MINLOG))) /
(data->freq *
inst->MOS2w *
(inst->MOS2l - 2 * model->MOS2latDiff) *
model->MOS2oxideCapFactor);
break;
case 2: case 3:
noizDens[MOS2FLNOIZ] *= model -> MOS2fNcoef *
inst -> MOS2gm * inst -> MOS2gm /
(pow(data -> freq, model -> MOS2fNexp) *
inst -> MOS2w *
(inst -> MOS2l - 2 * model -> MOS2latDiff) *
model -> MOS2oxideCapFactor);
noizDens[MOS2FLNOIZ] *= model->MOS2fNcoef *
inst->MOS2gm * inst->MOS2gm /
(pow(data->freq, model->MOS2fNexp) *
inst->MOS2w *
(inst->MOS2l - 2 * model->MOS2latDiff) *
model->MOS2oxideCapFactor);
break;
}
}
@ -148,21 +148,21 @@ MOS2noise(int mode, int operation, GENmodel * genmodel, CKTcircuit * ckt,
* OnDens += noizDens[MOS2TOTNOIZ];
if (data -> delFreq == 0.0) {
if (data->delFreq == 0.0) {
/* if we haven't done any previous integration, we need to */
/* initialize our "history" variables */
for (i = 0; i < MOS2NSRCS; i++) {
inst -> MOS2nVar[LNLSTDENS][i] = lnNdens[i];
inst->MOS2nVar[LNLSTDENS][i] = lnNdens[i];
}
/* clear out our integration variables if it's the first pass */
if (data -> freq == job -> NstartFreq) {
if (data->freq == job->NstartFreq) {
for (i = 0; i < MOS2NSRCS; i++) {
inst -> MOS2nVar[OUTNOIZ][i] = 0.0;
inst -> MOS2nVar[INNOIZ][i] = 0.0;
inst->MOS2nVar[OUTNOIZ][i] = 0.0;
inst->MOS2nVar[INNOIZ][i] = 0.0;
}
}
} else {
@ -170,37 +170,37 @@ MOS2noise(int mode, int operation, GENmodel * genmodel, CKTcircuit * ckt,
for (i = 0; i < MOS2NSRCS; i++) {
if (i != MOS2TOTNOIZ) {
tempOnoise = Nintegrate(noizDens[i], lnNdens[i],
inst -> MOS2nVar[LNLSTDENS][i], data);
tempInoise = Nintegrate(noizDens[i] * data -> GainSqInv,
lnNdens[i] + data -> lnGainInv,
inst -> MOS2nVar[LNLSTDENS][i] + data -> lnGainInv,
inst->MOS2nVar[LNLSTDENS][i], data);
tempInoise = Nintegrate(noizDens[i] * data->GainSqInv,
lnNdens[i] + data->lnGainInv,
inst->MOS2nVar[LNLSTDENS][i] + data->lnGainInv,
data);
inst -> MOS2nVar[LNLSTDENS][i] = lnNdens[i];
data -> outNoiz += tempOnoise;
data -> inNoise += tempInoise;
if (job -> NStpsSm != 0) {
inst -> MOS2nVar[OUTNOIZ][i] += tempOnoise;
inst -> MOS2nVar[OUTNOIZ][MOS2TOTNOIZ] += tempOnoise;
inst -> MOS2nVar[INNOIZ][i] += tempInoise;
inst -> MOS2nVar[INNOIZ][MOS2TOTNOIZ] += tempInoise;
inst->MOS2nVar[LNLSTDENS][i] = lnNdens[i];
data->outNoiz += tempOnoise;
data->inNoise += tempInoise;
if (job->NStpsSm != 0) {
inst->MOS2nVar[OUTNOIZ][i] += tempOnoise;
inst->MOS2nVar[OUTNOIZ][MOS2TOTNOIZ] += tempOnoise;
inst->MOS2nVar[INNOIZ][i] += tempInoise;
inst->MOS2nVar[INNOIZ][MOS2TOTNOIZ] += tempInoise;
}
}
}
}
if (data -> prtSummary) {
if (data->prtSummary) {
for (i = 0; i < MOS2NSRCS; i++) {
/* print a summary report */
data -> outpVector[data -> outNumber++] = noizDens[i];
data->outpVector[data->outNumber++] = noizDens[i];
}
}
break;
case INT_NOIZ:
/* already calculated, just output */
if (job -> NStpsSm != 0) {
if (job->NStpsSm != 0) {
for (i = 0; i < MOS2NSRCS; i++) {
data -> outpVector[data -> outNumber++] = inst -> MOS2nVar[OUTNOIZ][i];
data -> outpVector[data -> outNumber++] = inst -> MOS2nVar[INNOIZ][i];
data->outpVector[data->outNumber++] = inst->MOS2nVar[OUTNOIZ][i];
data->outpVector[data->outNumber++] = inst->MOS2nVar[INNOIZ][i];
}
} /* if */
break;

84
src/spicelib/devices/mos2/mos2set.c
View File

@ -14,8 +14,8 @@ Modified: 2000 AlansFixes
int
MOS2setup(SMPmatrix *matrix, GENmodel *inModel, CKTcircuit *ckt, int *states)
/* load the MOS2 device structure with those pointers needed later
* for fast matrix loading
/* load the MOS2 device structure with those pointers needed later
* for fast matrix loading
*/
{
MOS2model *model = (MOS2model *)inModel;
@ -110,23 +110,23 @@ MOS2setup(SMPmatrix *matrix, GENmodel *inModel, CKTcircuit *ckt, int *states)
if(!model->MOS2fastSurfaceStateDensityGiven) {
model->MOS2fastSurfaceStateDensity = 0;
}
if(!model->MOS2fNcoefGiven) {
model->MOS2fNcoef = 0;
}
if(!model->MOS2fNexpGiven) {
model->MOS2fNexp = 1;
}
if(!model->MOS2nlevGiven) {
model->MOS2nlev = 2;
}
if(!model->MOS2fNcoefGiven) {
model->MOS2fNcoef = 0;
}
if(!model->MOS2fNexpGiven) {
model->MOS2fNexp = 1;
}
if(!model->MOS2nlevGiven) {
model->MOS2nlev = 2;
}
/* loop through all the instances of the model */
for (here = MOS2instances(model); here != NULL ;
here=MOS2nextInstance(here)) {
CKTnode *tmpNode;
IFuid tmpName;
CKTnode *tmpNode;
IFuid tmpName;
/* allocate a chunk of the state vector */
here->MOS2states = *states;
*states += MOS2numStates;
@ -153,52 +153,52 @@ MOS2setup(SMPmatrix *matrix, GENmodel *inModel, CKTcircuit *ckt, int *states)
if(!here->MOS2vdsatGiven) {
here->MOS2vdsat = 0;
}
if (!here->MOS2drainSquaresGiven) {
here->MOS2drainSquares=1;
}
if (!here->MOS2sourceSquaresGiven) {
here->MOS2sourceSquares=1;
}
if (!here->MOS2drainSquaresGiven) {
here->MOS2drainSquares=1;
}
if (!here->MOS2sourceSquaresGiven) {
here->MOS2sourceSquares=1;
}
if ((model->MOS2drainResistance != 0
|| (here->MOS2drainSquares != 0
&& model->MOS2sheetResistance != 0))) {
&& model->MOS2sheetResistance != 0))) {
if (here->MOS2dNodePrime == 0) {
error = CKTmkVolt(ckt,&tmp,here->MOS2name,"internal#drain");
if(error) return(error);
here->MOS2dNodePrime = tmp->number;
if (ckt->CKTcopyNodesets) {
if (CKTinst2Node(ckt,here,1,&tmpNode,&tmpName)==OK) {
if (tmpNode->nsGiven) {
tmp->nodeset=tmpNode->nodeset;
tmp->nsGiven=tmpNode->nsGiven;
tmp->nodeset=tmpNode->nodeset;
tmp->nsGiven=tmpNode->nsGiven;
}
}
}
}
} else {
here->MOS2dNodePrime = here->MOS2dNode;
}
if( ( (model->MOS2sourceResistance != 0) ||
if( ( (model->MOS2sourceResistance != 0) ||
((here->MOS2sourceSquares != 0) &&
(model->MOS2sheetResistance != 0)) )) {
if (here->MOS2sNodePrime == 0) {
error = CKTmkVolt(ckt,&tmp,here->MOS2name,"internal#source");
if(error) return(error);
here->MOS2sNodePrime = tmp->number;
if (ckt->CKTcopyNodesets) {
if (CKTinst2Node(ckt,here,3,&tmpNode,&tmpName)==OK) {
if (tmpNode->nsGiven) {
tmp->nodeset=tmpNode->nodeset;
tmp->nsGiven=tmpNode->nsGiven;
tmp->nodeset=tmpNode->nodeset;
tmp->nsGiven=tmpNode->nsGiven;
}
}
}
}
} else {
here->MOS2sNodePrime = here->MOS2sNode;
}
@ -244,21 +244,21 @@ MOS2unsetup(GENmodel *inModel, CKTcircuit *ckt)
MOS2instance *here;
for (model = (MOS2model *)inModel; model != NULL;
model = MOS2nextModel(model))
model = MOS2nextModel(model))
{
for (here = MOS2instances(model); here != NULL;
here=MOS2nextInstance(here))
{
if (here->MOS2sNodePrime > 0
&& here->MOS2sNodePrime != here->MOS2sNode)
CKTdltNNum(ckt, here->MOS2sNodePrime);
here->MOS2sNodePrime = 0;
{
if (here->MOS2sNodePrime > 0
&& here->MOS2sNodePrime != here->MOS2sNode)
CKTdltNNum(ckt, here->MOS2sNodePrime);
here->MOS2sNodePrime = 0;
if (here->MOS2dNodePrime > 0
&& here->MOS2dNodePrime != here->MOS2dNode)
CKTdltNNum(ckt, here->MOS2dNodePrime);
here->MOS2dNodePrime = 0;
}
if (here->MOS2dNodePrime > 0
&& here->MOS2dNodePrime != here->MOS2dNode)
CKTdltNNum(ckt, here->MOS2dNodePrime);
here->MOS2dNodePrime = 0;
}
}
return OK;
}

20
src/spicelib/devices/mos3/mos3mask.c
View File

@ -99,7 +99,7 @@ MOS3mAsk(CKTcircuit *ckt, GENmodel *inst, int which, IFvalue *value)
return(OK);
case MOS3_MOD_DELVTO:
value->rValue = here->MOS3delvt0;
return(OK);
return(OK);
case MOS3_MOD_RSH:
value->rValue = here->MOS3sheetResistance;
return(OK);
@ -147,22 +147,22 @@ MOS3mAsk(CKTcircuit *ckt, GENmodel *inst, int which, IFvalue *value)
return(OK);
case MOS3_MOD_KAPPA:
value->rValue = here->MOS3kappa;
return(OK);
return(OK);
case MOS3_MOD_KF:
value->rValue = here->MOS3fNcoef;
return(OK);
case MOS3_MOD_AF:
value->rValue = here->MOS3fNexp;
return(OK);
return(OK);
case MOS3_MOD_NLEV:
value->iValue = here->MOS3nlev;
return(OK);
case MOS3_MOD_TYPE:
if (here->MOS3type > 0)
value->sValue = "nmos";
else
value->sValue = "pmos";
return(OK);
return(OK);
case MOS3_MOD_TYPE:
if (here->MOS3type > 0)
value->sValue = "nmos";
else
value->sValue = "pmos";
return(OK);
default:
return(E_BADPARM);
}

26
src/spicelib/devices/mos3/mos3mpar.c
View File

@ -118,7 +118,7 @@ MOS3mParam(int param, IFvalue *value, GENmodel *inModel)
case MOS3_MOD_DELVTO:
model->MOS3delvt0 = value->rValue;
model->MOS3delvt0Given = TRUE;
break;
break;
case MOS3_MOD_U0:
model->MOS3surfaceMobility = value->rValue;
model->MOS3surfaceMobilityGiven = TRUE;
@ -183,18 +183,18 @@ MOS3mParam(int param, IFvalue *value, GENmodel *inModel)
model->MOS3tnom = value->rValue+CONSTCtoK;
model->MOS3tnomGiven = TRUE;
break;
case MOS3_MOD_KF:
model->MOS3fNcoef = value->rValue;
model->MOS3fNcoefGiven = TRUE;
break;
case MOS3_MOD_AF:
model->MOS3fNexp = value->rValue;
model->MOS3fNexpGiven = TRUE;
break;
case MOS3_MOD_NLEV:
model->MOS3nlev = value->iValue;
model->MOS3nlevGiven = TRUE;
break;
case MOS3_MOD_KF:
model->MOS3fNcoef = value->rValue;
model->MOS3fNcoefGiven = TRUE;
break;
case MOS3_MOD_AF:
model->MOS3fNexp = value->rValue;
model->MOS3fNexpGiven = TRUE;
break;
case MOS3_MOD_NLEV:
model->MOS3nlev = value->iValue;
model->MOS3nlevGiven = TRUE;
break;
default:
return(E_BADPARM);
}

124
src/spicelib/devices/mos3/mos3noi.c
View File

@ -24,7 +24,7 @@ Modified: 2000 AlansFixes
int
MOS3noise(int mode, int operation, GENmodel * genmodel, CKTcircuit * ckt,
Ndata * data, double * OnDens) {
NOISEAN * job = (NOISEAN * ) ckt -> CKTcurJob;
NOISEAN * job = (NOISEAN * ) ckt->CKTcurJob;
MOS3model * firstModel = (MOS3model * ) genmodel;
MOS3model * model;
@ -60,19 +60,19 @@ MOS3noise(int mode, int operation, GENmodel * genmodel, CKTcircuit * ckt,
/* see if we have to to produce a summary report */
/* if so, name all the noise generators */
if (job -> NStpsSm != 0) {
if (job->NStpsSm != 0) {
switch (mode) {
case N_DENS:
for (i = 0; i < MOS3NSRCS; i++) {
NOISE_ADD_OUTVAR(ckt, data, "onoise_%s%s", inst -> MOS3name, MOS3nNames[i]);
NOISE_ADD_OUTVAR(ckt, data, "onoise_%s%s", inst->MOS3name, MOS3nNames[i]);
}
break;
case INT_NOIZ:
for (i = 0; i < MOS3NSRCS; i++) {
NOISE_ADD_OUTVAR(ckt, data, "onoise_total_%s%s", inst -> MOS3name, MOS3nNames[i]);
NOISE_ADD_OUTVAR(ckt, data, "inoise_total_%s%s", inst -> MOS3name, MOS3nNames[i]);
NOISE_ADD_OUTVAR(ckt, data, "onoise_total_%s%s", inst->MOS3name, MOS3nNames[i]);
NOISE_ADD_OUTVAR(ckt, data, "inoise_total_%s%s", inst->MOS3name, MOS3nNames[i]);
}
break;
}
@ -84,55 +84,55 @@ MOS3noise(int mode, int operation, GENmodel * genmodel, CKTcircuit * ckt,
case N_DENS:
NevalSrc( & noizDens[MOS3RDNOIZ], & lnNdens[MOS3RDNOIZ],
ckt, THERMNOISE, inst -> MOS3dNodePrime, inst -> MOS3dNode,
inst -> MOS3drainConductance);
ckt, THERMNOISE, inst->MOS3dNodePrime, inst->MOS3dNode,
inst->MOS3drainConductance);
NevalSrc( & noizDens[MOS3RSNOIZ], & lnNdens[MOS3RSNOIZ],
ckt, THERMNOISE, inst -> MOS3sNodePrime, inst -> MOS3sNode,
inst -> MOS3sourceConductance);
ckt, THERMNOISE, inst->MOS3sNodePrime, inst->MOS3sNode,
inst->MOS3sourceConductance);
NevalSrc( & noizDens[MOS3IDNOIZ], & lnNdens[MOS3IDNOIZ],
ckt, THERMNOISE, inst -> MOS3dNodePrime, inst -> MOS3sNodePrime,
(2.0 / 3.0 * fabs(inst -> MOS3gm)));
ckt, THERMNOISE, inst->MOS3dNodePrime, inst->MOS3sNodePrime,
(2.0 / 3.0 * fabs(inst->MOS3gm)));
NevalSrc( & noizDens[MOS3FLNOIZ], NULL, ckt,
N_GAIN, inst -> MOS3dNodePrime, inst -> MOS3sNodePrime,
N_GAIN, inst->MOS3dNodePrime, inst->MOS3sNodePrime,
(double) 0.0);
if (newcompat.s3) {
noizDens[MOS3FLNOIZ] *= model -> MOS3fNcoef *
exp(model -> MOS3fNexp *
log(MAX(fabs(inst -> MOS3cd), N_MINLOG))) /
(data -> freq *
(inst -> MOS3w - 2 * model -> MOS3widthNarrow) *
(inst -> MOS3l - 2 * model -> MOS3latDiff) *
model -> MOS3oxideCapFactor * model -> MOS3oxideCapFactor);
noizDens[MOS3FLNOIZ] *= model->MOS3fNcoef *
exp(model->MOS3fNexp *
log(MAX(fabs(inst->MOS3cd), N_MINLOG))) /
(data->freq *
(inst->MOS3w - 2 * model->MOS3widthNarrow) *
(inst->MOS3l - 2 * model->MOS3latDiff) *
model->MOS3oxideCapFactor * model->MOS3oxideCapFactor);
} else {
switch (model -> MOS3nlev) {
switch (model->MOS3nlev) {
case 0:
noizDens[MOS3FLNOIZ] *= model -> MOS3fNcoef *
exp(model -> MOS3fNexp *
log(MAX(fabs(inst -> MOS3cd), N_MINLOG))) /
(data -> freq *
(inst -> MOS3l - 2 * model -> MOS3latDiff) *
(inst -> MOS3l - 2 * model -> MOS3latDiff) *
model -> MOS3oxideCapFactor);
noizDens[MOS3FLNOIZ] *= model->MOS3fNcoef *
exp(model->MOS3fNexp *
log(MAX(fabs(inst->MOS3cd), N_MINLOG))) /
(data->freq *
(inst->MOS3l - 2 * model->MOS3latDiff) *
(inst->MOS3l - 2 * model->MOS3latDiff) *
model->MOS3oxideCapFactor);
break;
case 1:
noizDens[MOS3FLNOIZ] *= model -> MOS3fNcoef *
exp(model -> MOS3fNexp *
log(MAX(fabs(inst -> MOS3cd), N_MINLOG))) /
(data -> freq *
(inst -> MOS3w - 2 * model -> MOS3widthNarrow) *
(inst -> MOS3l - 2 * model -> MOS3latDiff) *
model -> MOS3oxideCapFactor);
noizDens[MOS3FLNOIZ] *= model->MOS3fNcoef *
exp(model->MOS3fNexp *
log(MAX(fabs(inst->MOS3cd), N_MINLOG))) /
(data->freq *
(inst->MOS3w - 2 * model->MOS3widthNarrow) *
(inst->MOS3l - 2 * model->MOS3latDiff) *
model->MOS3oxideCapFactor);
break;
case 2: case 3:
noizDens[MOS3FLNOIZ] *= model -> MOS3fNcoef *
inst -> MOS3gm * inst -> MOS3gm /
(pow(data -> freq, model -> MOS3fNexp) *
(inst -> MOS3w - 2 * model -> MOS3widthNarrow) *
(inst -> MOS3l - 2 * model -> MOS3latDiff) *
model -> MOS3oxideCapFactor);
noizDens[MOS3FLNOIZ] *= model->MOS3fNcoef *
inst->MOS3gm * inst->MOS3gm /
(pow(data->freq, model->MOS3fNexp) *
(inst->MOS3w - 2 * model->MOS3widthNarrow) *
(inst->MOS3l - 2 * model->MOS3latDiff) *
model->MOS3oxideCapFactor);
break;
}
}
@ -148,21 +148,21 @@ MOS3noise(int mode, int operation, GENmodel * genmodel, CKTcircuit * ckt,
* OnDens += noizDens[MOS3TOTNOIZ];
if (data -> delFreq == 0.0) {
if (data->delFreq == 0.0) {
/* if we haven't done any previous integration, we need to */
/* initialize our "history" variables */
for (i = 0; i < MOS3NSRCS; i++) {
inst -> MOS3nVar[LNLSTDENS][i] = lnNdens[i];
inst->MOS3nVar[LNLSTDENS][i] = lnNdens[i];
}
/* clear out our integration variables if it's the first pass */
if (data -> freq == job -> NstartFreq) {
if (data->freq == job->NstartFreq) {
for (i = 0; i < MOS3NSRCS; i++) {
inst -> MOS3nVar[OUTNOIZ][i] = 0.0;
inst -> MOS3nVar[INNOIZ][i] = 0.0;
inst->MOS3nVar[OUTNOIZ][i] = 0.0;
inst->MOS3nVar[INNOIZ][i] = 0.0;
}
}
} else {
@ -170,37 +170,37 @@ MOS3noise(int mode, int operation, GENmodel * genmodel, CKTcircuit * ckt,
for (i = 0; i < MOS3NSRCS; i++) {
if (i != MOS3TOTNOIZ) {
tempOnoise = Nintegrate(noizDens[i], lnNdens[i],
inst -> MOS3nVar[LNLSTDENS][i], data);
tempInoise = Nintegrate(noizDens[i] * data -> GainSqInv,
lnNdens[i] + data -> lnGainInv,
inst -> MOS3nVar[LNLSTDENS][i] + data -> lnGainInv,
inst->MOS3nVar[LNLSTDENS][i], data);
tempInoise = Nintegrate(noizDens[i] * data->GainSqInv,
lnNdens[i] + data->lnGainInv,
inst->MOS3nVar[LNLSTDENS][i] + data->lnGainInv,
data);
inst -> MOS3nVar[LNLSTDENS][i] = lnNdens[i];
data -> outNoiz += tempOnoise;
data -> inNoise += tempInoise;
if (job -> NStpsSm != 0) {
inst -> MOS3nVar[OUTNOIZ][i] += tempOnoise;
inst -> MOS3nVar[OUTNOIZ][MOS3TOTNOIZ] += tempOnoise;
inst -> MOS3nVar[INNOIZ][i] += tempInoise;
inst -> MOS3nVar[INNOIZ][MOS3TOTNOIZ] += tempInoise;
inst->MOS3nVar[LNLSTDENS][i] = lnNdens[i];
data->outNoiz += tempOnoise;
data->inNoise += tempInoise;
if (job->NStpsSm != 0) {
inst->MOS3nVar[OUTNOIZ][i] += tempOnoise;
inst->MOS3nVar[OUTNOIZ][MOS3TOTNOIZ] += tempOnoise;
inst->MOS3nVar[INNOIZ][i] += tempInoise;
inst->MOS3nVar[INNOIZ][MOS3TOTNOIZ] += tempInoise;
}
}
}
}
if (data -> prtSummary) {
if (data->prtSummary) {
for (i = 0; i < MOS3NSRCS; i++) {
/* print a summary report */
data -> outpVector[data -> outNumber++] = noizDens[i];
data->outpVector[data->outNumber++] = noizDens[i];
}
}
break;
case INT_NOIZ:
/* already calculated, just output */
if (job -> NStpsSm != 0) {
if (job->NStpsSm != 0) {
for (i = 0; i < MOS3NSRCS; i++) {
data -> outpVector[data -> outNumber++] = inst -> MOS3nVar[OUTNOIZ][i];
data -> outpVector[data -> outNumber++] = inst -> MOS3nVar[INNOIZ][i];
data->outpVector[data->outNumber++] = inst->MOS3nVar[OUTNOIZ][i];
data->outpVector[data->outNumber++] = inst->MOS3nVar[INNOIZ][i];
}
} /* if */
break;

64
src/spicelib/devices/mos3/mos3set.c
View File

@ -17,8 +17,8 @@ Modified: 2000 AlansFixes
int
MOS3setup(SMPmatrix *matrix, GENmodel *inModel, CKTcircuit *ckt, int *states)
/* load the MOS3 device structure with those pointers needed later
* for fast matrix loading
/* load the MOS3 device structure with those pointers needed later
* for fast matrix loading
*/
{
@ -48,7 +48,7 @@ MOS3setup(SMPmatrix *matrix, GENmodel *inModel, CKTcircuit *ckt, int *states)
}
if(!model->MOS3delvt0Given) {
model->MOS3delvt0 = 0;
}
}
if(!model->MOS3jctSatCurDensityGiven) {
model->MOS3jctSatCurDensity = 0;
}
@ -132,24 +132,24 @@ MOS3setup(SMPmatrix *matrix, GENmodel *inModel, CKTcircuit *ckt, int *states)
}
if(!model->MOS3oxideThicknessGiven) {
model->MOS3oxideThickness = 1e-7;
}
if(!model->MOS3fNcoefGiven) {
model->MOS3fNcoef = 0;
}
if(!model->MOS3fNexpGiven) {
model->MOS3fNexp = 1;
}
if(!model->MOS3nlevGiven) {
model->MOS3nlev = 2;
}
}
if(!model->MOS3fNcoefGiven) {
model->MOS3fNcoef = 0;
}
if(!model->MOS3fNexpGiven) {
model->MOS3fNexp = 1;
}
if(!model->MOS3nlevGiven) {
model->MOS3nlev = 2;
}
/* loop through all the instances of the model */
for (here = MOS3instances(model); here != NULL ;
here=MOS3nextInstance(here)) {
CKTnode *tmpNode;
IFuid tmpName;
CKTnode *tmpNode;
IFuid tmpName;
/* allocate a chunk of the state vector */
here->MOS3states = *states;
*states += MOS3NUMSTATES;
@ -198,8 +198,8 @@ MOS3setup(SMPmatrix *matrix, GENmodel *inModel, CKTcircuit *ckt, int *states)
if (ckt->CKTcopyNodesets) {
if (CKTinst2Node(ckt,here,1,&tmpNode,&tmpName)==OK) {
if (tmpNode->nsGiven) {
tmp->nodeset=tmpNode->nodeset;
tmp->nsGiven=tmpNode->nsGiven;
tmp->nodeset=tmpNode->nodeset;
tmp->nsGiven=tmpNode->nsGiven;
}
}
}
@ -209,7 +209,7 @@ MOS3setup(SMPmatrix *matrix, GENmodel *inModel, CKTcircuit *ckt, int *states)
}
if((model->MOS3sourceResistance != 0 ||
(model->MOS3sheetResistance != 0 &&
(model->MOS3sheetResistance != 0 &&
here->MOS3sourceSquares != 0 ) )) {
if (here->MOS3sNodePrime == 0) {
error = CKTmkVolt(ckt,&tmp,here->MOS3name,"internal#source");
@ -218,8 +218,8 @@ MOS3setup(SMPmatrix *matrix, GENmodel *inModel, CKTcircuit *ckt, int *states)
if (ckt->CKTcopyNodesets) {
if (CKTinst2Node(ckt,here,3,&tmpNode,&tmpName)==OK) {
if (tmpNode->nsGiven) {
tmp->nodeset=tmpNode->nodeset;
tmp->nsGiven=tmpNode->nsGiven;
tmp->nodeset=tmpNode->nodeset;
tmp->nsGiven=tmpNode->nsGiven;
}
}
}
@ -269,21 +269,21 @@ MOS3unsetup(GENmodel *inModel, CKTcircuit *ckt)
MOS3instance *here;
for (model = (MOS3model *)inModel; model != NULL;
model = MOS3nextModel(model))
model = MOS3nextModel(model))
{
for (here = MOS3instances(model); here != NULL;
here=MOS3nextInstance(here))
{
if (here->MOS3sNodePrime > 0
&& here->MOS3sNodePrime != here->MOS3sNode)
CKTdltNNum(ckt, here->MOS3sNodePrime);
here->MOS3sNodePrime= 0;
{
if (here->MOS3sNodePrime > 0
&& here->MOS3sNodePrime != here->MOS3sNode)
CKTdltNNum(ckt, here->MOS3sNodePrime);
here->MOS3sNodePrime= 0;
if (here->MOS3dNodePrime > 0
&& here->MOS3dNodePrime != here->MOS3dNode)
CKTdltNNum(ckt, here->MOS3dNodePrime);
here->MOS3dNodePrime= 0;
}
if (here->MOS3dNodePrime > 0
&& here->MOS3dNodePrime != here->MOS3dNode)
CKTdltNNum(ckt, here->MOS3dNodePrime);
here->MOS3dNodePrime= 0;
}
}
return OK;
}