jfetnoi.c File Reference

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

Include dependency graph for jfetnoi.c:

Go to the source code of this file.

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

Variables
static char *	JFETnNames [JFETNSRCS]

Function Documentation

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

Definition at line 46 of file jfetnoi.c.

{
    Ndata *data = (Ndata*)dataptr;
    JFETmodel *model = (JFETmodel *) genmodel;
    JFETinstance *inst;
    char name[N_MXVLNTH];
    double tempOnoise;
    double tempInoise;
    double noizDens[JFETNSRCS];
    double lnNdens[JFETNSRCS];
    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->JFETnextModel) {
                for (inst = model->JFETinstances; inst;
                        inst = inst->JFETnextInstance) {

                    for (i = 0; i < JFETNSRCS; i++) {
                        (void)sprintf(name,
                            "onoise.%s%s",inst->JFETname,JFETnNames[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->JFETnextModel) {
                for (inst = model->JFETinstances; inst;
                        inst = inst->JFETnextInstance) {

                    for (i = 0; i < JFETNSRCS; i++) {
                        (void)sprintf(name,
                            "onoise_total.%s%s",inst->JFETname,JFETnNames[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->JFETname,JFETnNames[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->JFETnextModel) {
                for (inst = model->JFETinstances; inst;
                        inst = inst->JFETnextInstance) {

                    NevalSrc(&noizDens[JFETRDNOIZ],&lnNdens[JFETRDNOIZ],
                        ckt,THERMNOISE,inst->JFETdrainPrimeNode,
                        inst->JFETdrainNode,
                        model->JFETdrainConduct * inst->JFETarea);

                    NevalSrc(&noizDens[JFETRSNOIZ],&lnNdens[JFETRSNOIZ],
                        ckt,THERMNOISE,inst->JFETsourcePrimeNode,
                        inst->JFETsourceNode,
                        model->JFETsourceConduct*inst->JFETarea);

                    NevalSrc(&noizDens[JFETIDNOIZ],&lnNdens[JFETIDNOIZ],
                        ckt,THERMNOISE,inst->JFETdrainPrimeNode,
                        inst->JFETsourcePrimeNode,
                        (2.0/3.0 * FABS(*(ckt->CKTstate0 + inst->JFETgm))));

                    NevalSrc(&noizDens[JFETFLNOIZ],(double*)NULL,ckt,
                        N_GAIN,inst->JFETdrainPrimeNode,
                        inst->JFETsourcePrimeNode, (double)0.0);

                    noizDens[JFETFLNOIZ] *= model->JFETfNcoef * 
                        exp(model->JFETfNexp *
                        log(MAX(FABS(*(ckt->CKTstate0 + inst->JFETcd)),
                        N_MINLOG))) / data->freq;

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

                    noizDens[JFETTOTNOIZ] = noizDens[JFETRDNOIZ] +
                        noizDens[JFETRSNOIZ] + noizDens[JFETIDNOIZ] +
                        noizDens[JFETFLNOIZ];

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

                    *OnDens += noizDens[JFETTOTNOIZ];

                    if (data->delFreq == 0.0) { 

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

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

                        for (i = 0; i < JFETNSRCS; i++) {
                            if (i != JFETTOTNOIZ) {
                                tempOnoise =
                                    Nintegrate(noizDens[i], lnNdens[i],
                                        inst->JFETnVar[LNLSTDENS][i], data);
                                tempInoise =
                                    Nintegrate(noizDens[i] * data->GainSqInv,
                                        lnNdens[i] + data->lnGainInv,
                                        inst->JFETnVar[LNLSTDENS][i] +
                                        data->lnGainInv,data);
                                inst->JFETnVar[LNLSTDENS][i] = lnNdens[i];
                                data->outNoiz += tempOnoise;
                                data->inNoise += tempInoise;
                                if (((NOISEAN*)ckt->CKTcurJob)->NStpsSm
                                        != 0) {
                                    inst->JFETnVar[OUTNOIZ][i] += tempOnoise;
                                    inst->JFETnVar[OUTNOIZ][JFETTOTNOIZ] +=
                                        tempOnoise;
                                    inst->JFETnVar[INNOIZ][i] += tempInoise;
                                    inst->JFETnVar[INNOIZ][JFETTOTNOIZ] +=
                                        tempInoise;
                                }
                            }
                        }
                    }
                    if (data->prtSummary) {
                        /* print a summary report */
                        for (i = 0; i < JFETNSRCS; i++) {
                            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->JFETnextModel) {
                for (inst = model->JFETinstances; inst;
                        inst = inst->JFETnextInstance) {

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

    return (OK);
}

Variable Documentation

char* JFETnNames[JFETNSRCS]

static

Initial value:

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

Definition at line 32 of file jfetnoi.c.