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; value->iValue = model->MOS1nlev;
return(OK); return(OK);
case MOS1_MOD_TYPE: case MOS1_MOD_TYPE:
if (model->MOS1type > 0) if (model->MOS1type > 0)
value->sValue = "nmos"; value->sValue = "nmos";
else else
value->sValue = "pmos"; value->sValue = "pmos";
return(OK); return(OK);
default: default:
return(E_BADPARM); 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; model->MOS1typeGiven = TRUE;
} }
break; break;
case MOS1_MOD_KF: case MOS1_MOD_KF:
model->MOS1fNcoef = value->rValue; model->MOS1fNcoef = value->rValue;
model->MOS1fNcoefGiven = TRUE; model->MOS1fNcoefGiven = TRUE;
break; break;
case MOS1_MOD_AF: case MOS1_MOD_AF:
model->MOS1fNexp = value->rValue; model->MOS1fNexp = value->rValue;
model->MOS1fNexpGiven = TRUE; model->MOS1fNexpGiven = TRUE;
break; break;
case MOS1_MOD_NLEV: case MOS1_MOD_NLEV:
model->MOS1nlev = value->iValue; model->MOS1nlev = value->iValue;
model->MOS1nlevGiven = TRUE; model->MOS1nlevGiven = TRUE;
break; break;
default: default:
return(E_BADPARM); return(E_BADPARM);
} }

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

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

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

@ -81,15 +81,15 @@ MOS1setup(SMPmatrix *matrix, GENmodel *inModel, CKTcircuit *ckt,
if(!model->MOS1gammaGiven) { if(!model->MOS1gammaGiven) {
model->MOS1gamma = 0; model->MOS1gamma = 0;
} }
if(!model->MOS1fNcoefGiven) { if(!model->MOS1fNcoefGiven) {
model->MOS1fNcoef = 0; model->MOS1fNcoef = 0;
} }
if(!model->MOS1fNexpGiven) { if(!model->MOS1fNexpGiven) {
model->MOS1fNexp = 1; model->MOS1fNexp = 1;
} }
if(!model->MOS1nlevGiven) { if(!model->MOS1nlevGiven) {
model->MOS1nlev = 2; model->MOS1nlev = 2;
} }
/* 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 ;
@ -124,15 +124,15 @@ MOS1setup(SMPmatrix *matrix, GENmodel *inModel, CKTcircuit *ckt,
if(!here->MOS1vonGiven) { if(!here->MOS1vonGiven) {
here->MOS1von = 0; here->MOS1von = 0;
} }
if(!here->MOS1drainSquaresGiven) { if(!here->MOS1drainSquaresGiven) {
here->MOS1drainSquares=1; here->MOS1drainSquares=1;
} }
if(!here->MOS1sourceSquaresGiven) { if(!here->MOS1sourceSquaresGiven) {
here->MOS1sourceSquares=1; here->MOS1sourceSquares=1;
} }
if ((model->MOS1drainResistance != 0 if ((model->MOS1drainResistance != 0
|| (model->MOS1sheetResistance != 0 || (model->MOS1sheetResistance != 0
&& here->MOS1drainSquares != 0) )) { && here->MOS1drainSquares != 0) )) {
if (here->MOS1dNodePrime == 0) { if (here->MOS1dNodePrime == 0) {
error = CKTmkVolt(ckt,&tmp,here->MOS1name,"drain"); error = CKTmkVolt(ckt,&tmp,here->MOS1name,"drain");
@ -140,8 +140,8 @@ MOS1setup(SMPmatrix *matrix, GENmodel *inModel, CKTcircuit *ckt,
here->MOS1dNodePrime = tmp->number; here->MOS1dNodePrime = tmp->number;
if (ckt->CKTcopyNodesets) { if (ckt->CKTcopyNodesets) {
CKTnode *tmpNode; CKTnode *tmpNode;
IFuid tmpName; IFuid tmpName;
if (CKTinst2Node(ckt,here,1,&tmpNode,&tmpName)==OK) { if (CKTinst2Node(ckt,here,1,&tmpNode,&tmpName)==OK) {
if (tmpNode->nsGiven) { if (tmpNode->nsGiven) {
@ -165,8 +165,8 @@ MOS1setup(SMPmatrix *matrix, GENmodel *inModel, CKTcircuit *ckt,
here->MOS1sNodePrime = tmp->number; here->MOS1sNodePrime = tmp->number;
if (ckt->CKTcopyNodesets) { if (ckt->CKTcopyNodesets) {
CKTnode *tmpNode; CKTnode *tmpNode;
IFuid tmpName; IFuid tmpName;
if (CKTinst2Node(ckt,here,3,&tmpNode,&tmpName)==OK) { if (CKTinst2Node(ckt,here,3,&tmpNode,&tmpName)==OK) {
if (tmpNode->nsGiven) { if (tmpNode->nsGiven) {
@ -221,21 +221,21 @@ MOS1unsetup(GENmodel *inModel, CKTcircuit *ckt)
MOS1instance *here; MOS1instance *here;
for (model = (MOS1model *)inModel; model != NULL; for (model = (MOS1model *)inModel; model != NULL;
model = MOS1nextModel(model)) model = MOS1nextModel(model))
{ {
for (here = MOS1instances(model); here != NULL; for (here = MOS1instances(model); here != NULL;
here=MOS1nextInstance(here)) here=MOS1nextInstance(here))
{ {
if (here->MOS1sNodePrime > 0 if (here->MOS1sNodePrime > 0
&& here->MOS1sNodePrime != here->MOS1sNode) && here->MOS1sNodePrime != here->MOS1sNode)
CKTdltNNum(ckt, here->MOS1sNodePrime); CKTdltNNum(ckt, here->MOS1sNodePrime);
here->MOS1sNodePrime= 0; here->MOS1sNodePrime= 0;
if (here->MOS1dNodePrime > 0 if (here->MOS1dNodePrime > 0
&& here->MOS1dNodePrime != here->MOS1dNode) && here->MOS1dNodePrime != here->MOS1dNode)
CKTdltNNum(ckt, here->MOS1dNodePrime); CKTdltNNum(ckt, here->MOS1dNodePrime);
here->MOS1dNodePrime= 0; here->MOS1dNodePrime= 0;
} }
} }
return OK; 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: case MOS2_MOD_UCRIT:
value->rValue = model->MOS2critField; value->rValue = model->MOS2critField;
break; break;
case MOS2_MOD_KF: case MOS2_MOD_KF:
value->rValue = model->MOS2fNcoef; value->rValue = model->MOS2fNcoef;
break; break;
case MOS2_MOD_AF: case MOS2_MOD_AF:
value->rValue = model->MOS2fNexp; value->rValue = model->MOS2fNexp;
break; break;
case MOS2_MOD_NLEV: case MOS2_MOD_NLEV:
value->iValue = model->MOS2nlev; value->iValue = model->MOS2nlev;
break; break;
case MOS2_MOD_TYPE: case MOS2_MOD_TYPE:
if (model->MOS2type > 0) if (model->MOS2type > 0)
value->sValue = "nmos"; value->sValue = "nmos";
else else
value->sValue = "pmos"; value->sValue = "pmos";
break; break;
default: default:
return(E_BADPARM); 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; model->MOS2typeGiven = TRUE;
} }
break; break;
case MOS2_MOD_KF: case MOS2_MOD_KF:
model->MOS2fNcoef = value->rValue; model->MOS2fNcoef = value->rValue;
model->MOS2fNcoefGiven = TRUE; model->MOS2fNcoefGiven = TRUE;
break; break;
case MOS2_MOD_AF: case MOS2_MOD_AF:
model->MOS2fNexp = value->rValue; model->MOS2fNexp = value->rValue;
model->MOS2fNexpGiven = TRUE; model->MOS2fNexpGiven = TRUE;
break; break;
case MOS2_MOD_NLEV: case MOS2_MOD_NLEV:
model->MOS2nlev = value->iValue; model->MOS2nlev = value->iValue;
model->MOS2nlevGiven = TRUE; model->MOS2nlevGiven = TRUE;
break; break;
default: default:
return(E_BADPARM); return(E_BADPARM);
} }

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

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

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

@ -110,22 +110,22 @@ MOS2setup(SMPmatrix *matrix, GENmodel *inModel, CKTcircuit *ckt, int *states)
if(!model->MOS2fastSurfaceStateDensityGiven) { if(!model->MOS2fastSurfaceStateDensityGiven) {
model->MOS2fastSurfaceStateDensity = 0; model->MOS2fastSurfaceStateDensity = 0;
} }
if(!model->MOS2fNcoefGiven) { if(!model->MOS2fNcoefGiven) {
model->MOS2fNcoef = 0; model->MOS2fNcoef = 0;
} }
if(!model->MOS2fNexpGiven) { if(!model->MOS2fNexpGiven) {
model->MOS2fNexp = 1; model->MOS2fNexp = 1;
} }
if(!model->MOS2nlevGiven) { if(!model->MOS2nlevGiven) {
model->MOS2nlev = 2; model->MOS2nlev = 2;
} }
/* loop through all the instances of the model */ /* loop through all the instances of the model */
for (here = MOS2instances(model); here != NULL ; for (here = MOS2instances(model); here != NULL ;
here=MOS2nextInstance(here)) { here=MOS2nextInstance(here)) {
CKTnode *tmpNode; CKTnode *tmpNode;
IFuid tmpName; IFuid tmpName;
/* allocate a chunk of the state vector */ /* allocate a chunk of the state vector */
here->MOS2states = *states; here->MOS2states = *states;
@ -153,15 +153,15 @@ MOS2setup(SMPmatrix *matrix, GENmodel *inModel, CKTcircuit *ckt, int *states)
if(!here->MOS2vdsatGiven) { if(!here->MOS2vdsatGiven) {
here->MOS2vdsat = 0; here->MOS2vdsat = 0;
} }
if (!here->MOS2drainSquaresGiven) { if (!here->MOS2drainSquaresGiven) {
here->MOS2drainSquares=1; here->MOS2drainSquares=1;
} }
if (!here->MOS2sourceSquaresGiven) { if (!here->MOS2sourceSquaresGiven) {
here->MOS2sourceSquares=1; here->MOS2sourceSquares=1;
} }
if ((model->MOS2drainResistance != 0 if ((model->MOS2drainResistance != 0
|| (here->MOS2drainSquares != 0 || (here->MOS2drainSquares != 0
&& model->MOS2sheetResistance != 0))) { && model->MOS2sheetResistance != 0))) {
if (here->MOS2dNodePrime == 0) { if (here->MOS2dNodePrime == 0) {
error = CKTmkVolt(ckt,&tmp,here->MOS2name,"internal#drain"); error = CKTmkVolt(ckt,&tmp,here->MOS2name,"internal#drain");
if(error) return(error); if(error) return(error);
@ -244,21 +244,21 @@ MOS2unsetup(GENmodel *inModel, CKTcircuit *ckt)
MOS2instance *here; MOS2instance *here;
for (model = (MOS2model *)inModel; model != NULL; for (model = (MOS2model *)inModel; model != NULL;
model = MOS2nextModel(model)) model = MOS2nextModel(model))
{ {
for (here = MOS2instances(model); here != NULL; for (here = MOS2instances(model); here != NULL;
here=MOS2nextInstance(here)) here=MOS2nextInstance(here))
{ {
if (here->MOS2sNodePrime > 0 if (here->MOS2sNodePrime > 0
&& here->MOS2sNodePrime != here->MOS2sNode) && here->MOS2sNodePrime != here->MOS2sNode)
CKTdltNNum(ckt, here->MOS2sNodePrime); CKTdltNNum(ckt, here->MOS2sNodePrime);
here->MOS2sNodePrime = 0; here->MOS2sNodePrime = 0;
if (here->MOS2dNodePrime > 0 if (here->MOS2dNodePrime > 0
&& here->MOS2dNodePrime != here->MOS2dNode) && here->MOS2dNodePrime != here->MOS2dNode)
CKTdltNNum(ckt, here->MOS2dNodePrime); CKTdltNNum(ckt, here->MOS2dNodePrime);
here->MOS2dNodePrime = 0; here->MOS2dNodePrime = 0;
} }
} }
return OK; return OK;
} }

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

@ -157,12 +157,12 @@ MOS3mAsk(CKTcircuit *ckt, GENmodel *inst, int which, IFvalue *value)
case MOS3_MOD_NLEV: case MOS3_MOD_NLEV:
value->iValue = here->MOS3nlev; value->iValue = here->MOS3nlev;
return(OK); return(OK);
case MOS3_MOD_TYPE: case MOS3_MOD_TYPE:
if (here->MOS3type > 0) if (here->MOS3type > 0)
value->sValue = "nmos"; value->sValue = "nmos";
else else
value->sValue = "pmos"; value->sValue = "pmos";
return(OK); return(OK);
default: default:
return(E_BADPARM); return(E_BADPARM);
} }

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

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

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

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

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

@ -133,22 +133,22 @@ MOS3setup(SMPmatrix *matrix, GENmodel *inModel, CKTcircuit *ckt, int *states)
if(!model->MOS3oxideThicknessGiven) { if(!model->MOS3oxideThicknessGiven) {
model->MOS3oxideThickness = 1e-7; model->MOS3oxideThickness = 1e-7;
} }
if(!model->MOS3fNcoefGiven) { if(!model->MOS3fNcoefGiven) {
model->MOS3fNcoef = 0; model->MOS3fNcoef = 0;
} }
if(!model->MOS3fNexpGiven) { if(!model->MOS3fNexpGiven) {
model->MOS3fNexp = 1; model->MOS3fNexp = 1;
} }
if(!model->MOS3nlevGiven) { if(!model->MOS3nlevGiven) {
model->MOS3nlev = 2; model->MOS3nlev = 2;
} }
/* loop through all the instances of the model */ /* loop through all the instances of the model */
for (here = MOS3instances(model); here != NULL ; for (here = MOS3instances(model); here != NULL ;
here=MOS3nextInstance(here)) { here=MOS3nextInstance(here)) {
CKTnode *tmpNode; CKTnode *tmpNode;
IFuid tmpName; IFuid tmpName;
/* allocate a chunk of the state vector */ /* allocate a chunk of the state vector */
here->MOS3states = *states; here->MOS3states = *states;
@ -269,21 +269,21 @@ MOS3unsetup(GENmodel *inModel, CKTcircuit *ckt)
MOS3instance *here; MOS3instance *here;
for (model = (MOS3model *)inModel; model != NULL; for (model = (MOS3model *)inModel; model != NULL;
model = MOS3nextModel(model)) model = MOS3nextModel(model))
{ {
for (here = MOS3instances(model); here != NULL; for (here = MOS3instances(model); here != NULL;
here=MOS3nextInstance(here)) here=MOS3nextInstance(here))
{ {
if (here->MOS3sNodePrime > 0 if (here->MOS3sNodePrime > 0
&& here->MOS3sNodePrime != here->MOS3sNode) && here->MOS3sNodePrime != here->MOS3sNode)
CKTdltNNum(ckt, here->MOS3sNodePrime); CKTdltNNum(ckt, here->MOS3sNodePrime);
here->MOS3sNodePrime= 0; here->MOS3sNodePrime= 0;
if (here->MOS3dNodePrime > 0 if (here->MOS3dNodePrime > 0
&& here->MOS3dNodePrime != here->MOS3dNode) && here->MOS3dNodePrime != here->MOS3dNode)
CKTdltNNum(ckt, here->MOS3dNodePrime); CKTdltNNum(ckt, here->MOS3dNodePrime);
here->MOS3dNodePrime= 0; here->MOS3dNodePrime= 0;
} }
} }
return OK; return OK;
} }