mos2dset.c

spice中支持多层次元件模型仿真的可单独运行的插件源码

		PlusDeriv(&d_cdrain,&d_cdrain,&d_vbin);
		TimesDeriv(&d_cdrain,&d_cdrain,-1.0);
		d_cdrain.value += lvgs;
		d_cdrain.d1_p += 1.0;
		EqualDeriv(&d_dummy,&d_r);
		d_dummy.value = lvds;
		MultDeriv(&d_cdrain,&d_cdrain,&d_dummy);
		MultDeriv(&d_dummy,&d_gammad,&d_body);
		TimesDeriv(&d_dummy,&d_dummy,-1/1.5);
		PlusDeriv(&d_cdrain,&d_cdrain,&d_dummy);
		MultDeriv(&d_cdrain,&d_cdrain,&d_beta1);
            } else {
                /* 
                 *  saturation region                 */
                cdrain = beta1*((lvgs-vbin-eta*
                    vdsat/2.0)*vdsat-gammad*bodys/1.5);
	    TimesDeriv(&d_cdrain,&d_vdsat,0.5*eta);
	    PlusDeriv(&d_cdrain,&d_cdrain,&d_vbin);
	    TimesDeriv(&d_cdrain,&d_cdrain,-1.0);
	    d_cdrain.value += lvgs;
	    d_cdrain.d1_p += 1.0;
	    MultDeriv(&d_cdrain,&d_cdrain,&d_vdsat);
	    MultDeriv(&d_dummy,&d_gammad,&d_bodys);
	    TimesDeriv(&d_dummy,&d_dummy,-1/1.5);
	    PlusDeriv(&d_cdrain,&d_cdrain,&d_dummy);
	    MultDeriv(&d_cdrain,&d_cdrain,&d_beta1);
            }
            /*
             *     compute charges for "on" region             */
            goto doneval;
            /*
             *  finish special cases             */
line1050:
            cdrain = 0.0;
            here->MOS2gm = 0.0;
            here->MOS2gmbs = 0.0;
d_cdrain.value = 0.0;
d_cdrain.d1_p = 0.0;
d_cdrain.d1_q = 0.0;
d_cdrain.d2_p2 = 0.0;
d_cdrain.d2_q2 = 0.0;
d_cdrain.d2_pq = 0.0;
d_cdrain.d2_qr = 0.0;
d_cdrain.d2_pr = 0.0;
d_cdrain.d3_p3 = 0.0;
d_cdrain.d3_q3 = 0.0;
d_cdrain.d3_p2r = 0.0;
d_cdrain.d3_p2q = 0.0;
d_cdrain.d3_q2r = 0.0;
d_cdrain.d3_pq2 = 0.0;
d_cdrain.d3_pr2 = 0.0;
d_cdrain.d3_qr2 = 0.0;
d_cdrain.d3_pqr = 0.0;
}

            /*
             *  finished             
	     */

/*================HERE=================*/
doneval:    
            /*
             *  COMPUTE EQUIVALENT DRAIN CURRENT SOURCE
             */
            /* 
             * now we do the hard part of the bulk-drain and bulk-source
	     * diode - we evaluate the non-linear capacitance and 
	     * charge                 
             * the basic equations are not hard, but the implementation
	     * is somewhat long in an attempt to avoid log/exponential
	     * evaluations                 
	     */
                /*
                 *  charge storage elements                 *
                 *.. bulk-drain and bulk-source depletion capacitances
		 */
                    if (vbs < here->MOS2tDepCap){
                        arg=1-vbs/here->MOS2tBulkPot;
                        /*
                         * the following block looks somewhat long and messy,
                         * but since most users use the default grading                         * coefficients of .5, and sqrt is MUCH faster than an                         * exp(log()) we use this special case code to buy time.
                         * (as much as 10% of total job time!)
                         */
#ifndef NOSQRT
                        if(model->MOS2bulkJctBotGradingCoeff ==
                                model->MOS2bulkJctSideGradingCoeff) {
                            if(model->MOS2bulkJctBotGradingCoeff == .5) {
                                sarg = sargsw = 1/sqrt(arg);
                            } else {
                                sarg = sargsw =
                                        exp(-model->MOS2bulkJctBotGradingCoeff*
                                        log(arg));
                            }
                        } else {
                            if(model->MOS2bulkJctBotGradingCoeff == .5) {
                                sarg = 1/sqrt(arg);
                            } else {
#endif /*NOSQRT*/
                                sarg = exp(-model->MOS2bulkJctBotGradingCoeff*
                                        log(arg));
#ifndef NOSQRT
                            }
                            if(model->MOS2bulkJctSideGradingCoeff == .5) {
                                sargsw = 1/sqrt(arg);
                            } else {
#endif /*NOSQRT*/
                                sargsw =exp(-model->MOS2bulkJctSideGradingCoeff*
                                        log(arg));
#ifndef NOSQRT
                            }
                        }
#endif /*NOSQRT*/
		    lcapbs=here->MOS2Cbs*sarg+
                                here->MOS2Cbssw*sargsw;
		    lcapbs2 = model->MOS2type*0.5/here->MOS2tBulkPot*(
			here->MOS2Cbs*model->MOS2bulkJctBotGradingCoeff*
			sarg/arg + here->MOS2Cbssw*
			model->MOS2bulkJctSideGradingCoeff*sargsw/arg);
		    lcapbs3 = here->MOS2Cbs*sarg*
			model->MOS2bulkJctBotGradingCoeff*
			(model->MOS2bulkJctBotGradingCoeff+1);
		    lcapbs3 += here->MOS2Cbssw*sargsw*
			model->MOS2bulkJctSideGradingCoeff*
			(model->MOS2bulkJctSideGradingCoeff+1);
		    lcapbs3 = lcapbs3/(6*here->MOS2tBulkPot*
			here->MOS2tBulkPot*arg*arg);
                    } else {
                    /*    *(ckt->CKTstate0 + here->MOS2qbs)= here->MOS2f4s +
                                vbs*(here->MOS2f2s+vbs*(here->MOS2f3s/2));*/
                        lcapbs=here->MOS2f2s+here->MOS2f3s*vbs;
			lcapbs2 = 0.5*here->MOS2f3s;
			lcapbs3 = 0;
                    }
                    if (vbd < here->MOS2tDepCap) {
                        arg=1-vbd/here->MOS2tBulkPot;
                        /*
                         * the following block looks somewhat long and messy,
                         * but since most users use the default grading                         * coefficients of .5, and sqrt is MUCH faster than an                         * exp(log()) we use this special case code to buy time.
                         * (as much as 10% of total job time!)
                         */
#ifndef NOSQRT
                        if(model->MOS2bulkJctBotGradingCoeff == .5 &&
                                model->MOS2bulkJctSideGradingCoeff == .5) {
                            sarg = sargsw = 1/sqrt(arg);
                        } else {
                            if(model->MOS2bulkJctBotGradingCoeff == .5) {
                                sarg = 1/sqrt(arg);
                            } else {
#endif /*NOSQRT*/
                                sarg = exp(-model->MOS2bulkJctBotGradingCoeff*
                                        log(arg));
#ifndef NOSQRT
                            }
                            if(model->MOS2bulkJctSideGradingCoeff == .5) {
                                sargsw = 1/sqrt(arg);
                            } else {
#endif /*NOSQRT*/
                                sargsw =exp(-model->MOS2bulkJctSideGradingCoeff*
                                        log(arg));
#ifndef NOSQRT
                            }
                        }
#endif /*NOSQRT*/
		    lcapbd=here->MOS2Cbd*sarg+
                                here->MOS2Cbdsw*sargsw;
		    lcapbd2 = model->MOS2type*0.5/here->MOS2tBulkPot*(
			here->MOS2Cbd*model->MOS2bulkJctBotGradingCoeff*
			sarg/arg + here->MOS2Cbdsw*
			model->MOS2bulkJctSideGradingCoeff*sargsw/arg);
		    lcapbd3 = here->MOS2Cbd*sarg*
			model->MOS2bulkJctBotGradingCoeff*
			(model->MOS2bulkJctBotGradingCoeff+1);
		    lcapbd3 += here->MOS2Cbdsw*sargsw*
			model->MOS2bulkJctSideGradingCoeff*
			(model->MOS2bulkJctSideGradingCoeff+1);
		    lcapbd3 = lcapbd3/(6*here->MOS2tBulkPot*
			here->MOS2tBulkPot*arg*arg);
                    } else {
                        lcapbd=here->MOS2f2d + vbd * here->MOS2f3d;
			lcapbd2=0.5*here->MOS2f3d;
			lcapbd3=0;
                    }
            /*
             *     meyer's capacitor model             */
	/*
	 * the meyer capacitance equations are in DEVqmeyer	 
	 * these expressions are derived from those equations.
	 * these expressions are incorrect; they assume just one
	 * controlling variable for each charge storage element	 
	 * while actually there are several;  the MOS2 small	 
	 * signal ac linear model is also wrong because it 
	 * ignores controlled capacitive elements. these can be 
	 * corrected (as can the linear ss ac model) if the 
	 * expressions for the charge are available	 
	 */

	 
{


    double phi;
    double cox;
    double vddif;
    double vddif1;
    double vddif2;
    /* von, vgst and vdsat have already been adjusted for 
        possible source-drain interchange */



    phi = here->MOS2tPhi;
    cox = OxideCap;
    if (vgst <= -phi) {
    lcapgb2=lcapgb3=lcapgs2=lcapgs3=lcapgd2=lcapgd3=0;
    } else if (vgst <= -phi/2) {
    lcapgb2= -cox/(4*phi);
    lcapgb3=lcapgs2=lcapgs3=lcapgd2=lcapgd3=0;
    } else if (vgst <= 0) {
    lcapgb2= -cox/(4*phi);
    lcapgb3=lcapgs3=lcapgd2=lcapgd3=0;
    lcapgs2 = cox/(3*phi);
    } else  {			/* the MOS2modes are around because 
					vds has not been adjusted */
        if (vdsat <= here->MOS2mode*vds) {
	lcapgb2=lcapgb3=lcapgs2=lcapgs3=lcapgd2=lcapgd3=0;
        } else {
            vddif = 2.0*vdsat-here->MOS2mode*vds;
            vddif1 = vdsat-here->MOS2mode*vds/*-1.0e-12*/;
            vddif2 = vddif*vddif;
	    lcapgd2 = -vdsat*here->MOS2mode*vds*cox/(3*vddif*vddif2);
	    lcapgd3 = - here->MOS2mode*vds*cox*(vddif - 6*vdsat)/(9*vddif2*vddif2);
	    lcapgs2 = -vddif1*here->MOS2mode*vds*cox/(3*vddif*vddif2);
	    lcapgs3 = - here->MOS2mode*vds*cox*(vddif - 6*vddif1)/(9*vddif2*vddif2);
	    lcapgb2=lcapgb3=0;
        }
    }
    }

		/* the b-s and b-d diodes need no processing ...  */
	here->capbs2 = lcapbs2;
	here->capbs3 = lcapbs3;
	here->capbd2 = lcapbd2;
	here->capbd3 = lcapbd3;
	here->gbs2 = lgbs2;
	here->gbs3 = lgbs3;
	here->gbd2 = lgbd2;
	here->gbd3 = lgbd3;
	here->capgb2 = model->MOS2type*lcapgb2;
	here->capgb3 = lcapgb3;
                /*
                 *   process to get Taylor coefficients, taking into		 * account type and mode.
                 */
gm2 = d_cdrain.d2_p2;
gb2 = d_cdrain.d2_q2;
gds2 = d_cdrain.d2_r2;
gmb = d_cdrain.d2_pq;
gbds = d_cdrain.d2_qr;
gmds = d_cdrain.d2_pr;
gm3 = d_cdrain.d3_p3;
gb3 = d_cdrain.d3_q3;
gds3 = d_cdrain.d3_r3;
gm2ds = d_cdrain.d3_p2r;
gm2b = d_cdrain.d3_p2q;
gb2ds = d_cdrain.d3_q2r;
gmb2 = d_cdrain.d3_pq2;
gmds2 = d_cdrain.d3_pr2;
gbds2 = d_cdrain.d3_qr2;
gmbds = d_cdrain.d3_pqr;

	if (here->MOS2mode == 1)
		{
		/* normal mode - no source-drain interchange */

 here->cdr_x2 = gm2;
 here->cdr_y2 = gb2;
 here->cdr_z2 = gds2;
 here->cdr_xy = gmb;
 here->cdr_yz = gbds;
 here->cdr_xz = gmds;
 here->cdr_x3 = gm3;
 here->cdr_y3 = gb3;
 here->cdr_z3 = gds3;
 here->cdr_x2z = gm2ds;
 here->cdr_x2y = gm2b;
 here->cdr_y2z = gb2ds;
 here->cdr_xy2 = gmb2;
 here->cdr_xz2 = gmds2;
 here->cdr_yz2 = gbds2;
 here->cdr_xyz = gmbds;

		/* the gate caps have been divided and made into			Taylor coeffs., but not adjusted for type */

	here->capgs2 = model->MOS2type*lcapgs2;
	here->capgs3 = lcapgs3;
	here->capgd2 = model->MOS2type*lcapgd2;
	here->capgd3 = lcapgd3;
} else {
		/*
		 * inverse mode - source and drain interchanged		 */
here->cdr_x2 = -gm2;
here->cdr_y2 = -gb2;
here->cdr_z2 = -(gm2 + gb2 + gds2 + 2*(gmb + gmds + gbds));
here->cdr_xy = -gmb;
here->cdr_yz = gmb + gb2 + gbds;
here->cdr_xz = gm2 + gmb + gmds;
here->cdr_x3 = -gm3;
here->cdr_y3 = -gb3;
here->cdr_z3 = gm3 + gb3 + gds3 + 
	3*(gm2b + gm2ds + gmb2 + gb2ds + gmds2 + gbds2) + 6*gmbds ;
here->cdr_x2z = gm3 + gm2b + gm2ds;
here->cdr_x2y = -gm2b;
here->cdr_y2z = gmb2 + gb3 + gb2ds;
here->cdr_xy2 = -gmb2;
here->cdr_xz2 = -(gm3 + 2*(gm2b + gm2ds + gmbds) +
					gmb2 + gmds2);
here->cdr_yz2 = -(gb3 + 2*(gmb2 + gb2ds + gmbds) +
					gm2b + gbds2);
here->cdr_xyz = gm2b + gmb2 + gmbds;

          here->capgs2 = model->MOS2type*lcapgd2;
	  here->capgs3 = lcapgd3;

	  here->capgd2 = model->MOS2type*lcapgs2;
	  here->capgd3 = lcapgs3;

}

/* now to adjust for type and multiply by factors to convert to Taylor coeffs. */

here->cdr_x2 = 0.5*model->MOS2type*here->cdr_x2;
here->cdr_y2 = 0.5*model->MOS2type*here->cdr_y2;
here->cdr_z2 = 0.5*model->MOS2type*here->cdr_z2;
here->cdr_xy = model->MOS2type*here->cdr_xy;
here->cdr_yz = model->MOS2type*here->cdr_yz;
here->cdr_xz = model->MOS2type*here->cdr_xz;
here->cdr_x3 = here->cdr_x3/6.;
here->cdr_y3 = here->cdr_y3/6.;
here->cdr_z3 = here->cdr_z3/6.;
here->cdr_x2z = 0.5*here->cdr_x2z;
here->cdr_x2y = 0.5*here->cdr_x2y;
here->cdr_y2z = 0.5*here->cdr_y2z;
here->cdr_xy2 = 0.5*here->cdr_xy2;
here->cdr_xz2 = 0.5*here->cdr_xz2;
here->cdr_yz2 = 0.5*here->cdr_yz2;


		}
        }
    return(OK);
    }