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

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;

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;

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;