From 89c7b83954998ea1296428541852104105f7b35d Mon Sep 17 00:00:00 2001 From: dwarning Date: Tue, 23 Jan 2024 17:01:05 +0100 Subject: [PATCH] mos1...3: formatting and white spaces --- src/spicelib/devices/mos1/mos1mask.c | 8 +- src/spicelib/devices/mos1/mos1mpar.c | 24 +++--- src/spicelib/devices/mos1/mos1noi.c | 120 +++++++++++++------------- src/spicelib/devices/mos1/mos1set.c | 84 +++++++++--------- src/spicelib/devices/mos2/mos2mask.c | 30 +++---- src/spicelib/devices/mos2/mos2mpar.c | 24 +++--- src/spicelib/devices/mos2/mos2noi.c | 124 +++++++++++++-------------- src/spicelib/devices/mos2/mos2set.c | 84 +++++++++--------- src/spicelib/devices/mos3/mos3mask.c | 20 ++--- src/spicelib/devices/mos3/mos3mpar.c | 26 +++--- src/spicelib/devices/mos3/mos3noi.c | 124 +++++++++++++-------------- src/spicelib/devices/mos3/mos3set.c | 64 +++++++------- 12 files changed, 366 insertions(+), 366 deletions(-) diff --git a/src/spicelib/devices/mos1/mos1mask.c b/src/spicelib/devices/mos1/mos1mask.c index c04522f71..903983103 100644 --- a/src/spicelib/devices/mos1/mos1mask.c +++ b/src/spicelib/devices/mos1/mos1mask.c @@ -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); diff --git a/src/spicelib/devices/mos1/mos1mpar.c b/src/spicelib/devices/mos1/mos1mpar.c index 728fd06d0..82a5dc714 100644 --- a/src/spicelib/devices/mos1/mos1mpar.c +++ b/src/spicelib/devices/mos1/mos1mpar.c @@ -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); } diff --git a/src/spicelib/devices/mos1/mos1noi.c b/src/spicelib/devices/mos1/mos1noi.c index 93b93749c..9d78dd47e 100644 --- a/src/spicelib/devices/mos1/mos1noi.c +++ b/src/spicelib/devices/mos1/mos1noi.c @@ -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; diff --git a/src/spicelib/devices/mos1/mos1set.c b/src/spicelib/devices/mos1/mos1set.c index 65ba81311..313926e55 100644 --- a/src/spicelib/devices/mos1/mos1set.c +++ b/src/spicelib/devices/mos1/mos1set.c @@ -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; } diff --git a/src/spicelib/devices/mos2/mos2mask.c b/src/spicelib/devices/mos2/mos2mask.c index 9e149ea72..7cc54359f 100644 --- a/src/spicelib/devices/mos2/mos2mask.c +++ b/src/spicelib/devices/mos2/mos2mask.c @@ -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); } diff --git a/src/spicelib/devices/mos2/mos2mpar.c b/src/spicelib/devices/mos2/mos2mpar.c index 97fb101a0..175858cbb 100644 --- a/src/spicelib/devices/mos2/mos2mpar.c +++ b/src/spicelib/devices/mos2/mos2mpar.c @@ -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); } diff --git a/src/spicelib/devices/mos2/mos2noi.c b/src/spicelib/devices/mos2/mos2noi.c index 94dfbdf79..90da7b2d1 100644 --- a/src/spicelib/devices/mos2/mos2noi.c +++ b/src/spicelib/devices/mos2/mos2noi.c @@ -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; diff --git a/src/spicelib/devices/mos2/mos2set.c b/src/spicelib/devices/mos2/mos2set.c index b23be6d1f..9f8e9eac6 100644 --- a/src/spicelib/devices/mos2/mos2set.c +++ b/src/spicelib/devices/mos2/mos2set.c @@ -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; } diff --git a/src/spicelib/devices/mos3/mos3mask.c b/src/spicelib/devices/mos3/mos3mask.c index 9f870ec9b..f3a07716d 100644 --- a/src/spicelib/devices/mos3/mos3mask.c +++ b/src/spicelib/devices/mos3/mos3mask.c @@ -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); } diff --git a/src/spicelib/devices/mos3/mos3mpar.c b/src/spicelib/devices/mos3/mos3mpar.c index 1564410b0..890d0b4bb 100644 --- a/src/spicelib/devices/mos3/mos3mpar.c +++ b/src/spicelib/devices/mos3/mos3mpar.c @@ -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); } diff --git a/src/spicelib/devices/mos3/mos3noi.c b/src/spicelib/devices/mos3/mos3noi.c index 33d8bd344..b6e79bba7 100644 --- a/src/spicelib/devices/mos3/mos3noi.c +++ b/src/spicelib/devices/mos3/mos3noi.c @@ -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; diff --git a/src/spicelib/devices/mos3/mos3set.c b/src/spicelib/devices/mos3/mos3set.c index d494f8434..8fc6a2de1 100644 --- a/src/spicelib/devices/mos3/mos3set.c +++ b/src/spicelib/devices/mos3/mos3set.c @@ -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; }