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
Split 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;
return(OK);
case MOS1_MOD_TYPE:
if (model->MOS1type > 0)
value->sValue = "nmos";
else
value->sValue = "pmos";
if (model->MOS1type > 0)
value->sValue = "nmos";
else
value->sValue = "pmos";
return(OK);
default:
return(E_BADPARM);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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