mosnoi.c File Reference

#include "spice.h"
#include <stdio.h>
#include <math.h>
#include "mosdefs.h"
#include "noisedef.h"
#include "fteconst.h"
#include "iferrmsg.h"
#include "util.h"

Include dependency graph for mosnoi.c:

Go to the source code of this file.

Functions
int	MOSnoise (int mode, int operation, GENmodel *genmodel, CKTcircuit *ckt, GENERIC *dataptr, double *OnDens)

Variables
static char *	MOSnNames [MOSNSRCS]

Function Documentation

int MOSnoise	(	int	mode,
		int	operation,
		GENmodel *	genmodel,
		CKTcircuit *	ckt,
		GENERIC *	dataptr,
		double *	OnDens
	)

Definition at line 40 of file mosnoi.c.

{
    Ndata *data = (Ndata*)dataptr;
    MOSmodel *model = (MOSmodel *) genmodel;
    MOSinstance *inst;
    char name[N_MXVLNTH];
    double tempOnoise;
    double tempInoise;
    double noizDens[MOSNSRCS];
    double lnNdens[MOSNSRCS];
    double coxSquared;
    int error;
    int i;


    /* 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 (operation == N_OPEN) {

        /* see if we have to to produce a summary report
         * if so, name all the noise generators
         */

        if (((NOISEAN*)ckt->CKTcurJob)->NStpsSm == 0)
            return (OK);

        if (mode == N_DENS) {

            for ( ; model; model = model->MOSnextModel) {

                if (model->MOSoxideCapFactor == 0.0) {
                    coxSquared = 3.9 * 8.854214871e-12 / 1e-7;
                }
                else {
                    coxSquared = model->MOSoxideCapFactor;
                }
                coxSquared *= coxSquared;

                for (inst = model->MOSinstances; inst != NULL;
                        inst = inst->MOSnextInstance) {

                    for (i = 0; i < MOSNSRCS; i++) {
                        (void)sprintf(name,
                            "onoise.%s%s",inst->MOSname,MOSnNames[i]);

                        data->namelist = (IFuid *)
                            trealloc((char *)data->namelist,
                                (data->numPlots + 1)*sizeof(IFuid));

                        if (!data->namelist)
                            return (E_NOMEM);

                        (*(SPfrontEnd->IFnewUid))(ckt,
                            &(data->namelist[data->numPlots++]),
                            (IFuid)NULL,name,UID_OTHER,(GENERIC **)NULL);
                        /* we've added one more plot */
                    }
                }
            }
            return (OK);
        }

        if (mode == INT_NOIZ) {

            for ( ; model; model = model->MOSnextModel) {

                if (model->MOSoxideCapFactor == 0.0) {
                    coxSquared = 3.9 * 8.854214871e-12 / 1e-7;
                }
                else {
                    coxSquared = model->MOSoxideCapFactor;
                }
                coxSquared *= coxSquared;

                for (inst = model->MOSinstances; inst != NULL;
                        inst = inst->MOSnextInstance) {

                    for (i = 0; i < MOSNSRCS; i++) {
                        (void)sprintf(name,
                            "onoise_total.%s%s",inst->MOSname,MOSnNames[i]);

                        data->namelist = (IFuid *)
                            trealloc((char *)data->namelist,
                                (data->numPlots + 1)*sizeof(IFuid));

                        if (!data->namelist)
                            return (E_NOMEM);

                        (*(SPfrontEnd->IFnewUid))(ckt,
                            &(data->namelist[data->numPlots++]),
                            (IFuid)NULL,name,UID_OTHER,(GENERIC **)NULL);
                        /* we've added one more plot */

                        (void)sprintf(name,
                            "inoise_total.%s%s",inst->MOSname,MOSnNames[i]);

                        data->namelist = (IFuid *)
                            trealloc((char *)data->namelist,
                                (data->numPlots + 1)*sizeof(IFuid));

                        if (!data->namelist)
                            return (E_NOMEM);

                        (*(SPfrontEnd->IFnewUid))(ckt,
                            &(data->namelist[data->numPlots++]),
                            (IFuid)NULL,name,UID_OTHER,(GENERIC **)NULL);
                        /* we've added one more plot */
                    }
                }
            }
        }
        return (OK);
    }

    if (operation == N_CALC) {

        if (mode == N_DENS) {

            for ( ; model; model = model->MOSnextModel) {

                if (model->MOSoxideCapFactor == 0.0) {
                    coxSquared = 3.9 * 8.854214871e-12 / 1e-7;
                }
                else {
                    coxSquared = model->MOSoxideCapFactor;
                }
                coxSquared *= coxSquared;

                for (inst = model->MOSinstances; inst != NULL;
                        inst = inst->MOSnextInstance) {

                    NevalSrc(&noizDens[MOSRDNOIZ],
                        &lnNdens[MOSRDNOIZ],
                        ckt,THERMNOISE,inst->MOSdNodePrime,
                        inst->MOSdNode,inst->MOSdrainConductance);

                    NevalSrc(&noizDens[MOSRSNOIZ],
                        &lnNdens[MOSRSNOIZ],
                        ckt,THERMNOISE,inst->MOSsNodePrime,
                        inst->MOSsNode,inst->MOSsourceConductance);

                    NevalSrc(&noizDens[MOSIDNOIZ],
                        &lnNdens[MOSIDNOIZ],
                        ckt,THERMNOISE,inst->MOSdNodePrime,
                        inst->MOSsNodePrime,
                        (2.0/3.0 * FABS(inst->MOSgm)));

                    NevalSrc(&noizDens[MOSFLNOIZ],(double*)NULL,ckt,
                        N_GAIN,inst->MOSdNodePrime,
                        inst->MOSsNodePrime,(double)0.0);

                    noizDens[MOSFLNOIZ] *= model->MOSfNcoef * 
                        exp(model->MOSfNexp *
                        log(MAX(FABS(inst->MOScd),N_MINLOG))) /
                        (data->freq * inst->MOSw * 
                        (inst->MOSl - 2*model->MOSlatDiff) *
                        coxSquared);

                    lnNdens[MOSFLNOIZ] = 
                        log(MAX(noizDens[MOSFLNOIZ],N_MINLOG));

                    noizDens[MOSTOTNOIZ] = noizDens[MOSRDNOIZ] +
                        noizDens[MOSRSNOIZ] +
                        noizDens[MOSIDNOIZ] +
                        noizDens[MOSFLNOIZ];

                    lnNdens[MOSTOTNOIZ] = 
                        log(MAX(noizDens[MOSTOTNOIZ], N_MINLOG));

                    *OnDens += noizDens[MOSTOTNOIZ];

                    if (data->delFreq == 0.0) {

                        /* if we haven't done any previous
                         * integration, we need to initialize
                         * our "history" variables
                         */

                        for (i=0; i < MOSNSRCS; i++) {
                            inst->MOSnVar[LNLSTDENS][i] = lnNdens[i];
                        }

                        /* clear out our integration variables if
                         * it's the first pass
                         */

                        if (data->freq ==
                            ((NOISEAN*)ckt->CKTcurJob)->AC.fstart) {

                            for (i = 0; i < MOSNSRCS; i++) {
                                inst->MOSnVar[OUTNOIZ][i] = 0.0;
                                inst->MOSnVar[INNOIZ][i] = 0.0;
                            }
                        }
                    }
                    else {
                        /* data->delFreq != 0.0
                         * (we have to integrate)
                         */
                        for (i = 0; i < MOSNSRCS; i++) {
                            if (i != MOSTOTNOIZ) {
                                tempOnoise =
                                    Nintegrate(noizDens[i],lnNdens[i],
                                    inst->MOSnVar[LNLSTDENS][i],data);
                                tempInoise =
                                    Nintegrate(noizDens[i] *
                                        data->GainSqInv,
                                    lnNdens[i] + data->lnGainInv,
                                    inst->MOSnVar[LNLSTDENS][i] +
                                        data->lnGainInv,data);
                                inst->MOSnVar[LNLSTDENS][i] = lnNdens[i];
                                data->outNoiz += tempOnoise;
                                data->inNoise += tempInoise;
                                if (((NOISEAN*)ckt->CKTcurJob)->NStpsSm
                                        != 0) {
                                    inst->MOSnVar[OUTNOIZ][i] += tempOnoise;
                                    inst->MOSnVar[OUTNOIZ][MOSTOTNOIZ] +=
                                        tempOnoise;
                                    inst->MOSnVar[INNOIZ][i] += tempInoise;
                                    inst->MOSnVar[INNOIZ][MOSTOTNOIZ] +=
                                        tempInoise;

                                }
                            }
                        }
                    }
                    if (data->prtSummary) {
                        for (i = 0; i < MOSNSRCS; i++) {
                            /* print a summary report */
                            data->outpVector[data->outNumber++] =
                                noizDens[i];
                        }
                    }
                }
            }
            return (OK);
        }
        
        if (mode == INT_NOIZ) {
            /* already calculated, just output */

            if (((NOISEAN*)ckt->CKTcurJob)->NStpsSm == 0)
                return (OK);

            for ( ; model; model = model->MOSnextModel) {

                if (model->MOSoxideCapFactor == 0.0) {
                    coxSquared = 3.9 * 8.854214871e-12 / 1e-7;
                }
                else {
                    coxSquared = model->MOSoxideCapFactor;
                }
                coxSquared *= coxSquared;

                for (inst = model->MOSinstances; inst != NULL;
                        inst = inst->MOSnextInstance) {

                    for (i = 0; i < MOSNSRCS; i++) {
                        data->outpVector[data->outNumber++] =
                            inst->MOSnVar[OUTNOIZ][i];
                        data->outpVector[data->outNumber++] =
                            inst->MOSnVar[INNOIZ][i];
                    }
                }
            }
        }
    }

    return (OK);
}

Variable Documentation

char* MOSnNames[MOSNSRCS]

static

Initial value:

= {
    
    ".rd",      
    ".rs",      
    ".id",      
    ".1overf",  
    ""          
}

Definition at line 27 of file mosnoi.c.