bjtnoise.c File Reference

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

Include dependency graph for bjtnoise.c:

Go to the source code of this file.

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

Variables
static char *	BJTnNames [BJTNSRCS]

Function Documentation

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

Definition at line 44 of file bjtnoise.c.

{
    Ndata *data = (Ndata*)dataptr;
    BJTmodel *model = (BJTmodel *) genmodel;
    BJTinstance *inst;
    char name[N_MXVLNTH];
    double tempOnoise;
    double tempInoise;
    double noizDens[BJTNSRCS];
    double lnNdens[BJTNSRCS];
    int error;
    int i;


    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->BJTnextModel) {
                for (inst = model->BJTinstances; inst;
                        inst = inst->BJTnextInstance) {

                    for (i = 0; i < BJTNSRCS; i++) {

                        (void)sprintf(name,"onoise.%s%s",
                            inst->BJTname,BJTnNames[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->BJTnextModel) {
                for (inst = model->BJTinstances; inst;
                        inst = inst->BJTnextInstance) {

                    for (i = 0; i < BJTNSRCS; i++) {

                        (void)sprintf(name,"onoise_total.%s%s",
                            inst->BJTname,BJTnNames[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->BJTname,BJTnNames[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->BJTnextModel) {
                for (inst = model->BJTinstances; inst;
                        inst = inst->BJTnextInstance) {

                    NevalSrc(&noizDens[BJTRCNOIZ],&lnNdens[BJTRCNOIZ],
                        ckt,THERMNOISE,inst->BJTcolPrimeNode,
                        inst->BJTcolNode,
                        model->BJTcollectorConduct * inst->BJTarea);

                    NevalSrc(&noizDens[BJTRBNOIZ],&lnNdens[BJTRBNOIZ],
                        ckt,THERMNOISE,inst->BJTbasePrimeNode,
                        inst->BJTbaseNode,inst->BJTgx);

                    NevalSrc(&noizDens[BJT_RE_NOISE],&lnNdens[BJT_RE_NOISE],
                        ckt,THERMNOISE,inst->BJTemitPrimeNode,
                        inst->BJTemitNode,
                        model->BJTemitterConduct * inst->BJTarea);

                    NevalSrc(&noizDens[BJTICNOIZ],&lnNdens[BJTICNOIZ],
                        ckt,SHOTNOISE,inst->BJTcolPrimeNode,
                        inst->BJTemitPrimeNode,inst->BJTcc);

                    NevalSrc(&noizDens[BJTIBNOIZ],&lnNdens[BJTIBNOIZ],
                        ckt,SHOTNOISE,inst->BJTbasePrimeNode,
                        inst->BJTemitPrimeNode,inst->BJTcb);

                    NevalSrc(&noizDens[BJTFLNOIZ],(double*)NULL,ckt,
                        N_GAIN,inst->BJTbasePrimeNode,
                        inst->BJTemitPrimeNode,(double)0.0);

                    noizDens[BJTFLNOIZ] *= model->BJTfNcoef * 
                        exp(model->BJTfNexp *
                        log(MAX(FABS(inst->BJTcb),N_MINLOG))) /
                        data->freq;

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

                    noizDens[BJTTOTNOIZ] = noizDens[BJTRCNOIZ] +
                        noizDens[BJTRBNOIZ] + noizDens[BJT_RE_NOISE] +
                        noizDens[BJTICNOIZ] + noizDens[BJTIBNOIZ] +
                        noizDens[BJTFLNOIZ];

                    lnNdens[BJTTOTNOIZ] = log(noizDens[BJTTOTNOIZ]);

                    *OnDens += noizDens[BJTTOTNOIZ];

                    if (data->delFreq == 0.0) { 

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

                        for (i = 0; i < BJTNSRCS; i++) {
                            inst->BJTnVar[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 < BJTNSRCS; i++) {
                                inst->BJTnVar[OUTNOIZ][i] = 0.0;
                                inst->BJTnVar[INNOIZ][i] = 0.0;
                            }
                        }
                    }
                    else {
                        /* data->delFreq != 0.0 (we have to integrate) */

                        /* In order to get the best curve fit, we have
                         * to integrate each component separately
                         */

                        for (i = 0; i < BJTNSRCS; i++) {

                            if (i != BJTTOTNOIZ) {
                                tempOnoise =
                                    Nintegrate(noizDens[i], lnNdens[i],
                                        inst->BJTnVar[LNLSTDENS][i], data);
                                tempInoise =
                                    Nintegrate(noizDens[i] * data->GainSqInv,
                                        lnNdens[i] + data->lnGainInv,
                                        inst->BJTnVar[LNLSTDENS][i] +
                                        data->lnGainInv,data);

                                inst->BJTnVar[LNLSTDENS][i] = lnNdens[i];
                                data->outNoiz += tempOnoise;
                                data->inNoise += tempInoise;

                                if (((NOISEAN*)ckt->CKTcurJob)->NStpsSm
                                        != 0) {

                                    inst->BJTnVar[OUTNOIZ][i] += tempOnoise;
                                    inst->BJTnVar[OUTNOIZ][BJTTOTNOIZ] +=
                                        tempOnoise;
                                    inst->BJTnVar[INNOIZ][i] += tempInoise;
                                    inst->BJTnVar[INNOIZ][BJTTOTNOIZ] +=
                                        tempInoise;
                                }
                            }
                        }
                    }
                    if (data->prtSummary) {
                        for (i = 0; i < BJTNSRCS; 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->BJTnextModel) {
                for (inst = model->BJTinstances; inst;
                        inst = inst->BJTnextInstance) {

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

    return (OK);
}

Variable Documentation

char* BJTnNames[BJTNSRCS]

static

Initial value:

= {
    
    ".rc",      
    ".rb",      
    ".re",     
    ".ic",     
    ".ib",     
    ".1overf", 
    ""         
}

Definition at line 28 of file bjtnoise.c.