mos1load.c

ngspice又一个电子CAD仿真软件代码.功能更全

/**********
Copyright 1990 Regents of the University of California.  All rights reserved.
Author: 1985 Thomas L. Quarles
Modified: 2000 AlansFixes
**********/

#include "ngspice.h"
#include "cktdefs.h"
#include "devdefs.h"
#include "mos1defs.h"
#include "trandefs.h"
#include "const.h"
#include "sperror.h"
#include "suffix.h"

int
MOS1load(GENmodel *inModel, CKTcircuit *ckt)
        /* actually load the current value into the 
         * sparse matrix previously provided 
         */
{
    MOS1model *model = (MOS1model *) inModel;
    MOS1instance *here;
    double Beta;
    double DrainSatCur;
    double EffectiveLength;
    double GateBulkOverlapCap;
    double GateDrainOverlapCap;
    double GateSourceOverlapCap;
    double OxideCap;
    double SourceSatCur;
    double arg;
    double cbhat;
    double cdhat;
    double cdrain;
    double cdreq;
    double ceq;
    double ceqbd;
    double ceqbs;
    double ceqgb;
    double ceqgd;
    double ceqgs;
    double delvbd;
    double delvbs;
    double delvds;
    double delvgd;
    double delvgs;
    double evbd;
    double evbs;
    double gcgb;
    double gcgd;
    double gcgs;
    double geq;
    double sarg;
    double sargsw;
    double vbd;
    double vbs;
    double vds;
    double vdsat;
    double vgb1;
    double vgb;
    double vgd1;
    double vgd;
    double vgdo;
    double vgs1;
    double vgs;
    double von;
    double vt;
    double xfact = 0.0;
    int xnrm;
    int xrev;
    double capgs = 0.0;   /* total gate-source capacitance */
    double capgd = 0.0;   /* total gate-drain capacitance */
    double capgb = 0.0;   /* total gate-bulk capacitance */
    int Check;
#ifndef NOBYPASS    
    double tempv;
#endif /*NOBYPASS*/    
    int error;
 #ifdef CAPBYPASS
    int senflag;
#endif /*CAPBYPASS*/           
    int SenCond;



#ifdef CAPBYPASS
    senflag = 0;
    if(ckt->CKTsenInfo && ckt->CKTsenInfo->SENstatus == PERTURBATION &&
        (ckt->CKTsenInfo->SENmode & (ACSEN | TRANSEN))) {
        senflag = 1;
    }
#endif /* CAPBYPASS */ 

    /*  loop through all the MOS1 device models */
    for( ; model != NULL; model = model->MOS1nextModel ) {

        /* loop through all the instances of the model */
        for (here = model->MOS1instances; here != NULL ;
	     here=here->MOS1nextInstance) {
	    if (here->MOS1owner != ARCHme) continue;

            vt = CONSTKoverQ * here->MOS1temp;
            Check=1;
            if(ckt->CKTsenInfo){
#ifdef SENSDEBUG
                printf("MOS1load \n");
#endif /* SENSDEBUG */

                if((ckt->CKTsenInfo->SENstatus == PERTURBATION)&&
		   (here->MOS1senPertFlag == OFF))continue;

            }
            SenCond = ckt->CKTsenInfo && here->MOS1senPertFlag;

/*
  
*/

            /* first, we compute a few useful values - these could be
             * pre-computed, but for historical reasons are still done
             * here.  They may be moved at the expense of instance size
             */

            EffectiveLength=here->MOS1l - 2*model->MOS1latDiff;
            
            if( (here->MOS1tSatCurDens == 0) || 
                    (here->MOS1drainArea == 0) ||
                    (here->MOS1sourceArea == 0)) {
                DrainSatCur = here->MOS1m * here->MOS1tSatCur;
                SourceSatCur = here->MOS1m * here->MOS1tSatCur;
            } else {
                DrainSatCur = here->MOS1tSatCurDens * 
                        here->MOS1m * here->MOS1drainArea;
                SourceSatCur = here->MOS1tSatCurDens * 
                        here->MOS1m * here->MOS1sourceArea;
            }
            GateSourceOverlapCap = model->MOS1gateSourceOverlapCapFactor * 
                    here->MOS1m * here->MOS1w;
            GateDrainOverlapCap = model->MOS1gateDrainOverlapCapFactor * 
                    here->MOS1m * here->MOS1w;
            GateBulkOverlapCap = model->MOS1gateBulkOverlapCapFactor * 
                    here->MOS1m * EffectiveLength;
            Beta = here->MOS1tTransconductance * here->MOS1m *
                    here->MOS1w/EffectiveLength;
            OxideCap = model->MOS1oxideCapFactor * EffectiveLength * 
                    here->MOS1m * here->MOS1w;
           
            /* 
             * ok - now to do the start-up operations
             *
             * we must get values for vbs, vds, and vgs from somewhere
             * so we either predict them or recover them from last iteration
             * These are the two most common cases - either a prediction
             * step or the general iteration step and they
             * share some code, so we put them first - others later on
             */

            if(SenCond){
#ifdef SENSDEBUG
                printf("MOS1senPertFlag = ON \n");
#endif /* SENSDEBUG */
                if((ckt->CKTsenInfo->SENmode == TRANSEN) &&
		   (ckt->CKTmode & MODEINITTRAN)) {
                    vgs = *(ckt->CKTstate1 + here->MOS1vgs);
                    vds = *(ckt->CKTstate1 + here->MOS1vds);
                    vbs = *(ckt->CKTstate1 + here->MOS1vbs);
                    vbd = *(ckt->CKTstate1 + here->MOS1vbd);
                    vgb = vgs - vbs;
                    vgd = vgs - vds;
                }
                else if (ckt->CKTsenInfo->SENmode == ACSEN){
                    vgb = model->MOS1type * ( 
                        *(ckt->CKTrhsOp+here->MOS1gNode) -
                        *(ckt->CKTrhsOp+here->MOS1bNode));
                    vbs = *(ckt->CKTstate0 + here->MOS1vbs);
                    vbd = *(ckt->CKTstate0 + here->MOS1vbd);
                    vgd = vgb + vbd ;
                    vgs = vgb + vbs ;
                    vds = vbs - vbd ;
                }
                else{
                    vgs = *(ckt->CKTstate0 + here->MOS1vgs);
                    vds = *(ckt->CKTstate0 + here->MOS1vds);
                    vbs = *(ckt->CKTstate0 + here->MOS1vbs);
                    vbd = *(ckt->CKTstate0 + here->MOS1vbd);
                    vgb = vgs - vbs;
                    vgd = vgs - vds;
                }
#ifdef SENSDEBUG
                printf(" vbs = %.7e ,vbd = %.7e,vgb = %.7e\n",vbs,vbd,vgb);
                printf(" vgs = %.7e ,vds = %.7e,vgd = %.7e\n",vgs,vds,vgd);
#endif /* SENSDEBUG */
                goto next1;
            }


            if((ckt->CKTmode & (MODEINITFLOAT | MODEINITPRED | MODEINITSMSIG
				| MODEINITTRAN)) ||
	       ( (ckt->CKTmode & MODEINITFIX) && (!here->MOS1off) )  ) {
#ifndef PREDICTOR
                if(ckt->CKTmode & (MODEINITPRED | MODEINITTRAN) ) {

                    /* predictor step */

                    xfact=ckt->CKTdelta/ckt->CKTdeltaOld[1];
                    *(ckt->CKTstate0 + here->MOS1vbs) = 
			*(ckt->CKTstate1 + here->MOS1vbs);
                    vbs = (1+xfact)* (*(ckt->CKTstate1 + here->MOS1vbs))
			-(xfact * (*(ckt->CKTstate2 + here->MOS1vbs)));
                    *(ckt->CKTstate0 + here->MOS1vgs) = 
			*(ckt->CKTstate1 + here->MOS1vgs);
                    vgs = (1+xfact)* (*(ckt->CKTstate1 + here->MOS1vgs))
			-(xfact * (*(ckt->CKTstate2 + here->MOS1vgs)));
                    *(ckt->CKTstate0 + here->MOS1vds) = 
			*(ckt->CKTstate1 + here->MOS1vds);
                    vds = (1+xfact)* (*(ckt->CKTstate1 + here->MOS1vds))
			-(xfact * (*(ckt->CKTstate2 + here->MOS1vds)));
                    *(ckt->CKTstate0 + here->MOS1vbd) = 
			*(ckt->CKTstate0 + here->MOS1vbs)-
			*(ckt->CKTstate0 + here->MOS1vds);
                } else {
#endif /* PREDICTOR */

                    /* general iteration */

                    vbs = model->MOS1type * ( 
                        *(ckt->CKTrhsOld+here->MOS1bNode) -
                        *(ckt->CKTrhsOld+here->MOS1sNodePrime));
                    vgs = model->MOS1type * ( 
                        *(ckt->CKTrhsOld+here->MOS1gNode) -
                        *(ckt->CKTrhsOld+here->MOS1sNodePrime));
                    vds = model->MOS1type * ( 
                        *(ckt->CKTrhsOld+here->MOS1dNodePrime) -
                        *(ckt->CKTrhsOld+here->MOS1sNodePrime));
#ifndef PREDICTOR
                }
#endif /* PREDICTOR */

                /* now some common crunching for some more useful quantities */

                vbd=vbs-vds;
                vgd=vgs-vds;
                vgdo = *(ckt->CKTstate0 + here->MOS1vgs) - 
		    *(ckt->CKTstate0 + here->MOS1vds);
                delvbs = vbs - *(ckt->CKTstate0 + here->MOS1vbs);
                delvbd = vbd - *(ckt->CKTstate0 + here->MOS1vbd);
                delvgs = vgs - *(ckt->CKTstate0 + here->MOS1vgs);
                delvds = vds - *(ckt->CKTstate0 + here->MOS1vds);
                delvgd = vgd-vgdo;

                /* these are needed for convergence testing */

                if (here->MOS1mode >= 0) {
                    cdhat=
                        here->MOS1cd-
                        here->MOS1gbd * delvbd +
                        here->MOS1gmbs * delvbs +
                        here->MOS1gm * delvgs + 
                        here->MOS1gds * delvds ;
                } else {
                    cdhat=
                        here->MOS1cd -
                        ( here->MOS1gbd -
			  here->MOS1gmbs) * delvbd -
                        here->MOS1gm * delvgd + 
                        here->MOS1gds * delvds ;
                }
                cbhat=
                    here->MOS1cbs +
                    here->MOS1cbd +
                    here->MOS1gbd * delvbd +
                    here->MOS1gbs * delvbs ;
/*
  
*/

#ifndef NOBYPASS
                /* now lets see if we can bypass (ugh) */
                tempv = (MAX(fabs(cbhat),
			    fabs(here->MOS1cbs + here->MOS1cbd)) +
			 ckt->CKTabstol);
                if ((!(ckt->CKTmode &
		       (MODEINITPRED|MODEINITTRAN|MODEINITSMSIG))) &&
		    (ckt->CKTbypass) &&
		    (fabs(cbhat-(here->MOS1cbs + 
				 here->MOS1cbd)) < ckt->CKTreltol * tempv) &&
		    (fabs(delvbs) < (ckt->CKTreltol *
				     MAX(fabs(vbs),
					 fabs( *(ckt->CKTstate0 +
						 here->MOS1vbs))) +
				     ckt->CKTvoltTol)) &&
		    (fabs(delvbd) < (ckt->CKTreltol *
				     MAX(fabs(vbd),
					 fabs(*(ckt->CKTstate0 +
						here->MOS1vbd))) +
				     ckt->CKTvoltTol)) &&
		    (fabs(delvgs) < (ckt->CKTreltol *
				     MAX(fabs(vgs),
					 fabs(*(ckt->CKTstate0 +
						here->MOS1vgs)))+
				     ckt->CKTvoltTol)) &&
		    (fabs(delvds) < (ckt->CKTreltol *
				     MAX(fabs(vds),
					 fabs(*(ckt->CKTstate0 +
						here->MOS1vds))) +
				     ckt->CKTvoltTol)) &&
		    (fabs(cdhat- here->MOS1cd) < (ckt->CKTreltol *
						  MAX(fabs(cdhat),
						      fabs(here->MOS1cd)) +
						  ckt->CKTabstol))) {
		  /* bypass code */
		  /* nothing interesting has changed since last
		   * iteration on this device, so we just
		   * copy all the values computed last iteration out
		   * and keep going
		   */
		  vbs = *(ckt->CKTstate0 + here->MOS1vbs);
		  vbd = *(ckt->CKTstate0 + here->MOS1vbd);
		  vgs = *(ckt->CKTstate0 + here->MOS1vgs);