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

mos1...3: formatting and white spaces

pre-master-46
dwarning 2 years ago
parent
1381d71cb1
commit
89c7b83954
12 changed files with 366 additions and 366 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 8
      src/spicelib/devices/mos1/mos1mask.c
  2. 24
      src/spicelib/devices/mos1/mos1mpar.c
  3. 120
      src/spicelib/devices/mos1/mos1noi.c
  4. 84
      src/spicelib/devices/mos1/mos1set.c
  5. 30
      src/spicelib/devices/mos2/mos2mask.c
  6. 24
      src/spicelib/devices/mos2/mos2mpar.c
  7. 124
      src/spicelib/devices/mos2/mos2noi.c
  8. 84
      src/spicelib/devices/mos2/mos2set.c
  9. 20
      src/spicelib/devices/mos3/mos3mask.c
  10. 26
      src/spicelib/devices/mos3/mos3mpar.c
  11. 124
      src/spicelib/devices/mos3/mos3noi.c
  12. 64
      src/spicelib/devices/mos3/mos3set.c

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)
value->sValue = "nmos";
else
value->sValue = "pmos";
if (model->MOS1type > 0)
value->sValue = "nmos";
else
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:
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: 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, "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; 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,
inst -> MOS1drainConductance);
ckt, THERMNOISE, inst->MOS1dNodePrime, inst->MOS1dNode,
inst->MOS1drainConductance);
NevalSrc( & noizDens[MOS1RSNOIZ], & lnNdens[MOS1RSNOIZ], 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], 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, 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 *
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); coxSquared);
} else { } else {
switch (model -> MOS1nlev) {
switch (model->MOS1nlev) {
case 0: 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)); sqrt(coxSquared));
break; break;
case 1: 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)); sqrt(coxSquared));
break; break;
case 2: case 3: 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)); 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[INNOIZ][i] = 0.0;
inst->MOS1nVar[OUTNOIZ][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);
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); 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++) { 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[INNOIZ][i];
data->outpVector[data->outNumber++] = inst->MOS1nVar[OUTNOIZ][i];
data->outpVector[data->outNumber++] = inst->MOS1nVar[INNOIZ][i];
} }
} /* if */ } /* if */
break; break;

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

@ -4,8 +4,8 @@ Author: 1985 Thomas L. Quarles
Modified: 2000 AlansFixes 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" #include "ngspice/ngspice.h"
@ -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) {
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 */ /* loop through all the instances of the model */
for (here = MOS1instances(model); here != NULL ; for (here = MOS1instances(model); here != NULL ;
@ -124,34 +124,34 @@ MOS1setup(SMPmatrix *matrix, GENmodel *inModel, CKTcircuit *ckt,
if(!here->MOS1vonGiven) { if(!here->MOS1vonGiven) {
here->MOS1von = 0; 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 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");
if(error) return(error); if(error) return(error);
here->MOS1dNodePrime = tmp->number; here->MOS1dNodePrime = tmp->number;
if (ckt->CKTcopyNodesets) { if (ckt->CKTcopyNodesets) {
CKTnode *tmpNode;
IFuid tmpName;
CKTnode *tmpNode;
IFuid tmpName;
if (CKTinst2Node(ckt,here,1,&tmpNode,&tmpName)==OK) { if (CKTinst2Node(ckt,here,1,&tmpNode,&tmpName)==OK) {
if (tmpNode->nsGiven) { if (tmpNode->nsGiven) {
tmp->nodeset=tmpNode->nodeset;
tmp->nsGiven=tmpNode->nsGiven;
tmp->nodeset=tmpNode->nodeset;
tmp->nsGiven=tmpNode->nsGiven;
} }
} }
} }
} }
} else { } else {
here->MOS1dNodePrime = here->MOS1dNode; here->MOS1dNodePrime = here->MOS1dNode;
} }
@ -163,19 +163,19 @@ MOS1setup(SMPmatrix *matrix, GENmodel *inModel, CKTcircuit *ckt,
error = CKTmkVolt(ckt,&tmp,here->MOS1name,"source"); error = CKTmkVolt(ckt,&tmp,here->MOS1name,"source");
if(error) return(error); if(error) return(error);
here->MOS1sNodePrime = tmp->number; here->MOS1sNodePrime = tmp->number;
if (ckt->CKTcopyNodesets) { if (ckt->CKTcopyNodesets) {
CKTnode *tmpNode;
IFuid tmpName;
CKTnode *tmpNode;
IFuid tmpName;
if (CKTinst2Node(ckt,here,3,&tmpNode,&tmpName)==OK) { if (CKTinst2Node(ckt,here,3,&tmpNode,&tmpName)==OK) {
if (tmpNode->nsGiven) { if (tmpNode->nsGiven) {
tmp->nodeset=tmpNode->nodeset;
tmp->nsGiven=tmpNode->nsGiven;
tmp->nodeset=tmpNode->nodeset;
tmp->nsGiven=tmpNode->nsGiven;
} }
} }
} }
} }
} else { } else {
here->MOS1sNodePrime = here->MOS1sNode; here->MOS1sNodePrime = here->MOS1sNode;
@ -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
&& 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->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;
}
} }
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:
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: 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:
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: 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, "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; 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,
inst -> MOS2drainConductance);
ckt, THERMNOISE, inst->MOS2dNodePrime, inst->MOS2dNode,
inst->MOS2drainConductance);
NevalSrc( & noizDens[MOS2RSNOIZ], & lnNdens[MOS2RSNOIZ], 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], 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, 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 *
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 { } else {
switch (model -> MOS2nlev) {
switch (model->MOS2nlev) {
case 0: 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; break;
case 1: 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; break;
case 2: case 3: 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; 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[INNOIZ][i] = 0.0;
inst->MOS2nVar[OUTNOIZ][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);
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); 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++) { 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[INNOIZ][i];
data->outpVector[data->outNumber++] = inst->MOS2nVar[OUTNOIZ][i];
data->outpVector[data->outNumber++] = inst->MOS2nVar[INNOIZ][i];
} }
} /* if */ } /* if */
break; break;

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

@ -14,8 +14,8 @@ Modified: 2000 AlansFixes
int int
MOS2setup(SMPmatrix *matrix, GENmodel *inModel, CKTcircuit *ckt, int *states) 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; MOS2model *model = (MOS2model *)inModel;
@ -110,23 +110,23 @@ MOS2setup(SMPmatrix *matrix, GENmodel *inModel, CKTcircuit *ckt, int *states)
if(!model->MOS2fastSurfaceStateDensityGiven) { if(!model->MOS2fastSurfaceStateDensityGiven) {
model->MOS2fastSurfaceStateDensity = 0; 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 */ /* 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;
IFuid tmpName;
CKTnode *tmpNode;
IFuid tmpName;
/* allocate a chunk of the state vector */ /* allocate a chunk of the state vector */
here->MOS2states = *states; here->MOS2states = *states;
*states += MOS2numStates; *states += MOS2numStates;
@ -153,52 +153,52 @@ MOS2setup(SMPmatrix *matrix, GENmodel *inModel, CKTcircuit *ckt, int *states)
if(!here->MOS2vdsatGiven) { if(!here->MOS2vdsatGiven) {
here->MOS2vdsat = 0; 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 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);
here->MOS2dNodePrime = tmp->number; here->MOS2dNodePrime = tmp->number;
if (ckt->CKTcopyNodesets) { if (ckt->CKTcopyNodesets) {
if (CKTinst2Node(ckt,here,1,&tmpNode,&tmpName)==OK) { if (CKTinst2Node(ckt,here,1,&tmpNode,&tmpName)==OK) {
if (tmpNode->nsGiven) { if (tmpNode->nsGiven) {
tmp->nodeset=tmpNode->nodeset;
tmp->nsGiven=tmpNode->nsGiven;
tmp->nodeset=tmpNode->nodeset;
tmp->nsGiven=tmpNode->nsGiven;
} }
} }
} }
} }
} else { } else {
here->MOS2dNodePrime = here->MOS2dNode; here->MOS2dNodePrime = here->MOS2dNode;
} }
if( ( (model->MOS2sourceResistance != 0) ||
if( ( (model->MOS2sourceResistance != 0) ||
((here->MOS2sourceSquares != 0) && ((here->MOS2sourceSquares != 0) &&
(model->MOS2sheetResistance != 0)) )) { (model->MOS2sheetResistance != 0)) )) {
if (here->MOS2sNodePrime == 0) { if (here->MOS2sNodePrime == 0) {
error = CKTmkVolt(ckt,&tmp,here->MOS2name,"internal#source"); error = CKTmkVolt(ckt,&tmp,here->MOS2name,"internal#source");
if(error) return(error); if(error) return(error);
here->MOS2sNodePrime = tmp->number; here->MOS2sNodePrime = tmp->number;
if (ckt->CKTcopyNodesets) { if (ckt->CKTcopyNodesets) {
if (CKTinst2Node(ckt,here,3,&tmpNode,&tmpName)==OK) { if (CKTinst2Node(ckt,here,3,&tmpNode,&tmpName)==OK) {
if (tmpNode->nsGiven) { if (tmpNode->nsGiven) {
tmp->nodeset=tmpNode->nodeset;
tmp->nsGiven=tmpNode->nsGiven;
tmp->nodeset=tmpNode->nodeset;
tmp->nsGiven=tmpNode->nsGiven;
} }
} }
} }
} }
} else { } else {
here->MOS2sNodePrime = here->MOS2sNode; here->MOS2sNodePrime = here->MOS2sNode;
} }
@ -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
&& 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; 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); return(OK);
case MOS3_MOD_DELVTO: case MOS3_MOD_DELVTO:
value->rValue = here->MOS3delvt0; value->rValue = here->MOS3delvt0;
return(OK);
return(OK);
case MOS3_MOD_RSH: case MOS3_MOD_RSH:
value->rValue = here->MOS3sheetResistance; value->rValue = here->MOS3sheetResistance;
return(OK); return(OK);
@ -147,22 +147,22 @@ MOS3mAsk(CKTcircuit *ckt, GENmodel *inst, int which, IFvalue *value)
return(OK); return(OK);
case MOS3_MOD_KAPPA: case MOS3_MOD_KAPPA:
value->rValue = here->MOS3kappa; value->rValue = here->MOS3kappa;
return(OK);
return(OK);
case MOS3_MOD_KF: case MOS3_MOD_KF:
value->rValue = here->MOS3fNcoef; value->rValue = here->MOS3fNcoef;
return(OK); return(OK);
case MOS3_MOD_AF: case MOS3_MOD_AF:
value->rValue = here->MOS3fNexp; value->rValue = here->MOS3fNexp;
return(OK);
return(OK);
case MOS3_MOD_NLEV: case MOS3_MOD_NLEV:
value->iValue = here->MOS3nlev; 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: default:
return(E_BADPARM); 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: case MOS3_MOD_DELVTO:
model->MOS3delvt0 = value->rValue; model->MOS3delvt0 = value->rValue;
model->MOS3delvt0Given = TRUE; model->MOS3delvt0Given = TRUE;
break;
break;
case MOS3_MOD_U0: case MOS3_MOD_U0:
model->MOS3surfaceMobility = value->rValue; model->MOS3surfaceMobility = value->rValue;
model->MOS3surfaceMobilityGiven = TRUE; model->MOS3surfaceMobilityGiven = TRUE;
@ -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:
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: 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, "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; 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,
inst -> MOS3drainConductance);
ckt, THERMNOISE, inst->MOS3dNodePrime, inst->MOS3dNode,
inst->MOS3drainConductance);
NevalSrc( & noizDens[MOS3RSNOIZ], & lnNdens[MOS3RSNOIZ], 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], 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, 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 *
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 { } else {
switch (model -> MOS3nlev) {
switch (model->MOS3nlev) {
case 0: 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; break;
case 1: 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; break;
case 2: case 3: 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; 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[INNOIZ][i] = 0.0;
inst->MOS3nVar[OUTNOIZ][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);
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); 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++) { 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[INNOIZ][i];
data->outpVector[data->outNumber++] = inst->MOS3nVar[OUTNOIZ][i];
data->outpVector[data->outNumber++] = inst->MOS3nVar[INNOIZ][i];
} }
} /* if */ } /* if */
break; break;

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

@ -17,8 +17,8 @@ Modified: 2000 AlansFixes
int int
MOS3setup(SMPmatrix *matrix, GENmodel *inModel, CKTcircuit *ckt, int *states) 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) { if(!model->MOS3delvt0Given) {
model->MOS3delvt0 = 0; model->MOS3delvt0 = 0;
}
}
if(!model->MOS3jctSatCurDensityGiven) { if(!model->MOS3jctSatCurDensityGiven) {
model->MOS3jctSatCurDensity = 0; model->MOS3jctSatCurDensity = 0;
} }
@ -132,24 +132,24 @@ 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) {
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 */ /* 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;
IFuid tmpName;
CKTnode *tmpNode;
IFuid tmpName;
/* allocate a chunk of the state vector */ /* allocate a chunk of the state vector */
here->MOS3states = *states; here->MOS3states = *states;
*states += MOS3NUMSTATES; *states += MOS3NUMSTATES;
@ -198,8 +198,8 @@ MOS3setup(SMPmatrix *matrix, GENmodel *inModel, CKTcircuit *ckt, int *states)
if (ckt->CKTcopyNodesets) { if (ckt->CKTcopyNodesets) {
if (CKTinst2Node(ckt,here,1,&tmpNode,&tmpName)==OK) { if (CKTinst2Node(ckt,here,1,&tmpNode,&tmpName)==OK) {
if (tmpNode->nsGiven) { 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 || if((model->MOS3sourceResistance != 0 ||
(model->MOS3sheetResistance != 0 &&
(model->MOS3sheetResistance != 0 &&
here->MOS3sourceSquares != 0 ) )) { here->MOS3sourceSquares != 0 ) )) {
if (here->MOS3sNodePrime == 0) { if (here->MOS3sNodePrime == 0) {
error = CKTmkVolt(ckt,&tmp,here->MOS3name,"internal#source"); 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 (ckt->CKTcopyNodesets) {
if (CKTinst2Node(ckt,here,3,&tmpNode,&tmpName)==OK) { if (CKTinst2Node(ckt,here,3,&tmpNode,&tmpName)==OK) {
if (tmpNode->nsGiven) { 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; 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
&& 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; return OK;
} }
Write Preview
Loading…
Cancel
Save