b1dset.c

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

    SqrtDeriv(&d_VdsSat,&d_K);
    MultDeriv(&d_VdsSat,&d_VdsSat,&d_A);
    DivDeriv(&d_VdsSat,&d_VgsVth,&d_VdsSat);
    }

    if( vds < VdsSat ) {
        /* Triode Region */
        /*Argl1  =  1 + Uds * vds;*/
	Argl1 = 1 + Uds * vds;
	if (Argl1 < 1.0) {
	Argl1 = 1.0;
	EqualDeriv(&d_Argl1,&d_zero);
	d_Argl1.value = 1.0;
	}
	else
	{
	MultDeriv(&d_Argl1,&d_r,&d_Uds);
	d_Argl1.value += 1.0;
	}


        Argl2  =  VgsVth - 0.5 * A * vds;
	MultDeriv(&d_Argl2,&d_r,&d_A);
	TimesDeriv(&d_Argl2,&d_Argl2,-0.5);
	PlusDeriv(&d_Argl2,&d_Argl2,&d_VgsVth);
        DrCur  =  Beta * Argl2 * vds / Argl1;
	DivDeriv(&d_DrCur,&d_r,&d_Argl1);
	MultDeriv(&d_DrCur,&d_DrCur,&d_Argl2);
	MultDeriv(&d_DrCur,&d_DrCur,&d_Beta);
    } else {  
        /* Pinchoff (Saturation) Region */
	/* history
        Args1  =   1.0 + 1. / Term1;
	InvDeriv(&d_Args1,&d_Term1);
	d_Args1.value += 1.0;
	*/
        /* dVcdVgs  =  Uds / A;
        dVcdVds  =  VgsVth * dUdsdVds / A - dVcdVgs * dVthdVds;
        dVcdVbs  =  ( VgsVth * dUdsdVbs - Uds * 
            (dVthdVbs + VgsVth * dAdVbs / A ))/ A;
        dKdVc  =  0.5* Args1;
        dKdVgs  =  dKdVc * dVcdVgs;
        dKdVds  =  dKdVc * dVcdVds;
        dKdVbs  =  dKdVc * dVcdVbs; */
        Args2  =  VgsVth / A / K;
	MultDeriv(&d_Args2,&d_A,&d_K);
	DivDeriv(&d_Args2,&d_VgsVth,&d_Args2);
        Args3  =  Args2 * VgsVth;
	MultDeriv(&d_Args3,&d_Args2,&d_VgsVth);
        DrCur  =  0.5 * Beta * Args3;
	MultDeriv(&d_DrCur,&d_Beta,&d_Args3);
	TimesDeriv(&d_DrCur,&d_DrCur,0.5);
    }

SubthresholdComputation:

    N0  =  here->B1subthSlope;/*const*/
    Vcut  =  - 40. * N0 * CONSTvt0 ;/*const*/
    if( (N0 >=  200) || (VgsVth < Vcut ) || (VgsVth > (-0.5*Vcut))) {
        goto ChargeComputation;
    }
    
    NB  =  here->B1subthSlopeB;/*const*/
    ND  =  here->B1subthSlopeD;/*const*/
    N  =  N0 + NB * vbs + ND * vds; /* subthreshold slope */
    EqualDeriv(&d_N,&d_r);
    d_N.value = N;
    d_N.d1_q = NB;
    d_N.d1_r = ND;
    if( N < 0.5 ){ N  =  0.5;
    d_N.value = 0.5;
    d_N.d1_q = d_N.d1_r = 0.0;
    }
    Warg1  =  exp( - vds / CONSTvt0 );
    TimesDeriv(&d_Warg1,&d_r,-1/CONSTvt0);
    ExpDeriv(&d_Warg1,&d_Warg1);
    Wds  =  1 - Warg1;
    TimesDeriv(&d_Wds,&d_Warg1,-1.0);
    d_Wds.value += 1.0;
    Wgs  =  exp( VgsVth / ( N * CONSTvt0 ));
    DivDeriv(&d_Wgs,&d_VgsVth,&d_N);
    TimesDeriv(&d_Wgs,&d_Wgs,1/CONSTvt0);
    ExpDeriv(&d_Wgs,&d_Wgs);
    Vtsquare = CONSTvt0 * CONSTvt0 ;/*const*/
    Warg2  =  6.04965 * Vtsquare * here->B1betaZero;/*const*/
    Ilimit  =  4.5 * Vtsquare * here->B1betaZero;/*const*/
    Iexp = Warg2 * Wgs * Wds;
    MultDeriv(&d_Iexp,&d_Wgs,&d_Wds);
    TimesDeriv(&d_Iexp,&d_Iexp,Warg2);
    DrCur  =  DrCur + Ilimit * Iexp / ( Ilimit + Iexp );
    EqualDeriv(&d_dummy,&d_Iexp);
    d_dummy.value += Ilimit;
    InvDeriv(&d_dummy,&d_dummy);
    MultDeriv(&d_dummy,&d_dummy,&d_Iexp);
    TimesDeriv(&d_dummy,&d_dummy,Ilimit);
    PlusDeriv(&d_DrCur,&d_DrCur,&d_dummy);

    /* gds term has been modified to prevent blow up at Vds=0 */
    /* gds = gds + Temp3 * ( -Wds / N / CONSTvt0 * (dVthdVds + 
        VgsVth * ND / N ) + Warg1 / CONSTvt0 ); */

ChargeComputation:

    /* Some Limiting of DC Parameters */
/*    if(DrCur < 0.0) DrCur = 0.0;
    if(gm < 0.0) gm = 0.0;
    if(gds < 0.0) gds = 0.0;
    if(gmbs < 0.0) gmbs = 0.0;
    */

    WLCox = model->B1Cox * 
        (here->B1l - model->B1deltaL * 1.e-6) * 
        (here->B1w - model->B1deltaW * 1.e-6) * 1.e4;   /* F */

    if( ! ChargeComputationNeeded )  {  
        qg  = 0;
        qd = 0;
        qb = 0;
	EqualDeriv(&d_qg,&d_zero);
	EqualDeriv(&d_qb,&d_zero);
	EqualDeriv(&d_qd,&d_zero);
        goto finished;
    }
    G  =   1.0 - 1./(1.744+0.8364 * Vpb);
    TimesDeriv(&d_G,&d_Vpb,-0.8364);
    d_G.value -= 1.744;
    InvDeriv(&d_G,&d_G);
    d_G.value += 1.0;

    A  =  1.0 + 0.5*K1*G/SqrtVpb;
    if (A < 1.0) {
    A = 1.0;
    EqualDeriv(&d_A,&d_zero);
    d_A.value = 1.0;
    }
    else
    {
    DivDeriv(&d_A,&d_G,&d_SqrtVpb);
    TimesDeriv(&d_A,&d_A,0.5*K1);
    d_A.value += 1.0;
    }

    /*Arg  =  1 + Ugs * VgsVth;*/
    Phi  =  MAX( 0.1, Phi);/*const*/

    if( model->B1channelChargePartitionFlag >= 1 ) {

/*0/100 partitioning for drain/source chArges at the saturation region*/
        Vth0 = Vfb + Phi + K1 * SqrtVpb;
	TimesDeriv(&d_Vth0,&d_SqrtVpb,K1);
	d_Vth0.value += Vfb + Phi;
        VgsVth = vgs - Vth0;
	TimesDeriv(&d_VgsVth,&d_Vth0,-1.0);
	PlusDeriv(&d_VgsVth,&d_VgsVth,&d_p);
        Arg1 = A * vds;
	MultDeriv(&d_Arg1,&d_A,&d_r);
        Arg2 = VgsVth - 0.5 * Arg1;
	TimesDeriv(&d_Arg2,&d_Arg1,-0.5);
	PlusDeriv(&d_Arg2,&d_Arg2,&d_VgsVth);
        Arg3 = vds - Arg1;
	TimesDeriv(&d_Arg3,&d_Arg1,-1.0);
	PlusDeriv(&d_Arg3,&d_Arg3,&d_r);
        Arg5 = Arg1 * Arg1;
	MultDeriv(&d_Arg5,&d_Arg1,&d_Arg1);

        Ent = MAX(Arg2,1.0e-8);
	if (Arg2 < 1.0e-8) {
	EqualDeriv(&d_Ent,&d_zero);
	d_Ent.value = 1.0e-8;
	}
	else
	{
	EqualDeriv(&d_Ent,&d_Arg2);
	}

        Vcom = VgsVth * VgsVth / 6.0 - 1.25e-1 * Arg1 * 
            VgsVth + 2.5e-2 * Arg5;
	    TimesDeriv(&d_dummy,&d_Arg1,-0.125);
	    TimesDeriv(&d_Vcom,&d_VgsVth,1/6.0);
	    PlusDeriv(&d_Vcom,&d_Vcom,&d_dummy);
	    MultDeriv(&d_Vcom,&d_Vcom,&d_VgsVth);
	    TimesDeriv(&d_dummy,&d_Arg5,2.5e-2);
	    PlusDeriv(&d_Vcom,&d_Vcom,&d_dummy);
	VdsPinchoff = VgsVth / A;
	if (VdsPinchoff < 0.0) {
	VdsPinchoff = 0.0;
	EqualDeriv(&d_VdsPinchoff,&d_zero);
	}
	else
	{
	DivDeriv(&d_VdsPinchoff,&d_VgsVth,&d_A);
	}
        Vgb  =  vgs  -  vbs ;
	EqualDeriv(&d_Vgb,&d_p);
	d_Vgb.value = Vgb;
	d_Vgb.d1_q = -1.0;
        Vgb_Vfb  =  Vgb  -  Vfb;
	EqualDeriv(&d_Vgb_Vfb,&d_Vgb);
	d_Vgb_Vfb.value -= Vfb;

        if( Vgb_Vfb < 0){
            /* Accumulation Region */
            qg  =  WLCox * Vgb_Vfb;
	    TimesDeriv(&d_qg,&d_Vgb_Vfb,WLCox);
            qb  =  - qg;
	    TimesDeriv(&d_qb,&d_qg,-1.0);
            qd  =  0. ;
	    EqualDeriv(&d_qd,&d_zero);
            goto finished;
        } else if ( vgs < Vth0 ){
            /* Subthreshold Region */
            qg  =  0.5 * WLCox * K1 * K1 * (-1 + 
                sqrt(1 + 4 * Vgb_Vfb / (K1 * K1)));
            TimesDeriv(&d_qg,&d_Vgb_Vfb,4/(K1*K1));
	    d_qg.value += 1.0;
	    SqrtDeriv(&d_qg,&d_qg);
	    d_qg.value -= 1.0;
	    TimesDeriv(&d_qg,&d_qg,0.5 * WLCox * K1 * K1);
            qb  =  -qg;
	    TimesDeriv(&d_qb,&d_qg,-1.0);
            qd  =  0.;
	    EqualDeriv(&d_qd,&d_zero);
            goto finished;
        } else if( vds < VdsPinchoff ){    /* triode region  */
            /*VgsVth2 = VgsVth*VgsVth;*/
            EntSquare = Ent * Ent;
	    MultDeriv(&d_EntSquare,&d_Ent,&d_Ent);
            Argl1 = 1.2e1 * EntSquare;
	    TimesDeriv(&d_Argl1,&d_EntSquare,12.0);
            Argl2 = 1.0 - A;
	    TimesDeriv(&d_Argl2,&d_A,-1.0);
	    d_Argl2.value += 1.0;
	    /*
            Argl3 = Arg1 * vds;
	    MultDeriv(&d_Argl3,&d_Arg1,&d_r);
	    */
            /*Argl4 = Vcom/Ent/EntSquare;*/
            if (Ent > 1.0e-8) {   
                Argl5 = Arg1 / Ent;
		DivDeriv(&d_Argl5,&d_Arg1,&d_Ent);
                /*Argl6 = Vcom/EntSquare;*/  
            } else {   
                Argl5 = 2.0;
		EqualDeriv(&d_Argl5,&d_zero);
		d_Argl5.value = 2.0;
                Argl6 = 4.0 / 1.5e1;/*const*/
            }
            Argl7 = Argl5 / 1.2e1;
	    TimesDeriv(&d_Argl7,&d_Argl5,1.0/12.0);
	    /*
            Argl8 = 6.0 * Ent;
	    TimesDeriv(&d_Argl8,&d_Ent,6.0);
            Argl9 = 0.125 * Argl5 * Argl5;
	    MultDeriv(&d_Argl9,&d_Argl5,&d_Argl5);
	    TimesDeriv(&d_Argl9,&d_Argl9,0.125);
	    */
            qg = WLCox * (vgs - Vfb - Phi - 0.5 * vds + vds * Argl7);
	    EqualDeriv(&d_qg,&d_Argl7);
	    d_qg.value -= 0.5;
	    MultDeriv(&d_qg,&d_qg,&d_r);
	    d_qg.value  += vgs - Vfb - Phi;
	    d_qg.d1_p += 1.0;
	    TimesDeriv(&d_qg,&d_qg,WLCox);
            qb = WLCox * ( - Vth0 + Vfb + Phi + 0.5 * Arg3 - Arg3 * Argl7);
	    TimesDeriv(&d_qb,&d_Argl7,-1.0);
	    d_qb.value += 0.5;
	    MultDeriv(&d_qb,&d_qb,&d_Arg3);
	    d_qb.value += Vfb + Phi;
	    TimesDeriv(&d_dummy,&d_Vth0,-1.0);
	    PlusDeriv(&d_qb,&d_qb,&d_dummy);
	    TimesDeriv(&d_qb,&d_qb,WLCox);
            qd =  - WLCox * (0.5 * VgsVth - 0.75 * Arg1 + 
                0.125 * Arg1 * Argl5);
	    TimesDeriv(&d_qd,&d_Argl5,0.125);
	    d_qd.value -= 0.75;
	    MultDeriv(&d_qd,&d_qd,&d_Arg1);
	    TimesDeriv(&d_dummy,&d_VgsVth,0.5);
	    PlusDeriv(&d_qd,&d_qd,&d_dummy);
	    TimesDeriv(&d_qd,&d_qd, -WLCox);
            goto finished;
        } else if( vds >= VdsPinchoff ) {    /* saturation region   */
            Args1 = 1.0 /  (3*A);
	    TimesDeriv(&d_Args1,&d_A,3.0);
	    InvDeriv(&d_Args1,&d_Args1);
            qg = WLCox * (vgs - Vfb - Phi - VgsVth * Args1);
	    MultDeriv(&d_qg,&d_VgsVth,&d_Args1);
	    d_qg.value += Vfb + Phi - vgs;
	    d_qg.d1_p -= 1.0;
	    TimesDeriv(&d_qg,&d_qg,-WLCox);
            qb = WLCox * (Vfb + Phi - Vth0 + (1.0 - A) * VgsVth * Args1);
	    TimesDeriv(&d_dummy,&d_A,-1.0);
	    d_dummy.value += 1.0;
	    MultDeriv(&d_qb,&d_VgsVth, &d_dummy);
	    MultDeriv(&d_qb,&d_qb,&d_Args1);
	    d_qb.value += Vfb + Phi;
	    TimesDeriv(&d_dummy,&d_Vth0,-1.0);
	    PlusDeriv(&d_qb,&d_qb,&d_dummy);
	    TimesDeriv(&d_qb,&d_qb,WLCox);
            qd = 0.0;
	    EqualDeriv(&d_qd,&d_zero);
            goto finished;
        }

        goto finished;

    } else {

/*0/100 partitioning for drain/source chArges at the saturation region*/
	co4v15 = 1./15.;
        Vth0 = Vfb + Phi + K1 * SqrtVpb;
	TimesDeriv(&d_Vth0,&d_SqrtVpb,K1);
	d_Vth0.value += Vfb + Phi;
        VgsVth = vgs - Vth0;
	TimesDeriv(&d_VgsVth,&d_Vth0,-1.0);
	d_VgsVth.value += vgs;
	d_VgsVth.d1_p += 1.0;
        Arg1 = A * vds;
	MultDeriv(&d_Arg1,&d_A,&d_r);
        Arg2 = VgsVth - 0.5 * Arg1;
	TimesDeriv(&d_Arg2,&d_Arg1,-0.5);
	PlusDeriv(&d_Arg2,&d_Arg2,&d_VgsVth);
        Arg3 = vds - Arg1;
	TimesDeriv(&d_Arg3,&d_Arg1,-1.0);
	d_Arg3.value = Arg3;
	d_Arg3.d1_r += 1.0;
        Arg5 = Arg1 * Arg1;
	MultDeriv(&d_Arg5,&d_Arg1,&d_Arg1);
        Ent = MAX(Arg2,1.0e-8);
	if (Arg2 < 1.0e-8) {
	EqualDeriv(&d_Ent,&d_zero);
	d_Ent.value = Ent;
	}
	else
	{
	EqualDeriv(&d_Ent,&d_Arg2);
	}

        Vcom = VgsVth * VgsVth / 6.0 - 1.25e-1 * Arg1 * 
            VgsVth + 2.5e-2 * Arg5;
	TimesDeriv(&d_dummy,&d_VgsVth,1/6.0);
	TimesDeriv(&d_Vcom,&d_Arg1,-0.125);
	PlusDeriv(&d_Vcom,&d_Vcom,&d_dummy);
	MultDeriv(&d_Vcom,&d_Vcom,&d_VgsVth);
	TimesDeriv(&d_dummy,&d_Arg5,2.5e-2);
	PlusDeriv(&d_Vcom,&d_Vcom,&d_dummy);
	VdsPinchoff = VgsVth / A;
	if (VdsPinchoff < 0.0) {
	VdsPinchoff = 0.0;
	EqualDeriv(&d_VdsPinchoff,&d_zero);
	}
	else
	{
	DivDeriv(&d_VdsPinchoff,&d_VgsVth,&d_A);
	}

        Vgb  =  vgs  -  vbs ;
	EqualDeriv(&d_Vgb,&d_p);
	d_Vgb.value = Vgb;
	d_Vgb.d1_q = -1.0;
        Vgb_Vfb  =  Vgb  -  Vfb;
	EqualDeriv(&d_Vgb_Vfb,&d_Vgb);
	d_Vgb_Vfb.value = Vgb_Vfb;

        if( Vgb_Vfb < 0){
            /* Accumulation Region */
            qg  =  WLCox * Vgb_Vfb;
	    TimesDeriv(&d_qg,&d_Vgb_Vfb,WLCox);
            qb  =  - qg;
	    TimesDeriv(&d_qb,&d_qg,-1.0);
            qd  =  0. ;
	    EqualDeriv(&d_qd,&d_zero);
            goto finished;
        } else if ( vgs < Vth0 ){
            /* Subthreshold Region */
            qg  =  0.5 * WLCox * K1 * K1 * (-1 + 
                sqrt(1 + 4 * Vgb_Vfb / (K1 * K1)));
            TimesDeriv(&d_qg,&d_Vgb_Vfb,4/(K1*K1));
	    d_qg.value += 1.0;
	    SqrtDeriv(&d_qg,&d_qg);
	    d_qg.value -= 1.0;
	    TimesDeriv(&d_qg,&d_qg,0.5 * WLCox * K1 * K1);
            qb  =  -qg;
	    TimesDeriv(&d_qb,&d_qg,-1.0);
            qd  =  0.;
	    EqualDeriv(&d_qd,&d_zero);
            goto finished;
        } else if( vds < VdsPinchoff ){    /* triode region  */
	    /*
            VgsVthSquare = VgsVth*VgsVth;
	    MultDeriv(&d_VgsVthSquare,&d_VgsVth,&d_VgsVth);
	    */
            EntSquare = Ent * Ent;
	    MultDeriv(&d_EntSquare,&d_Ent,&d_Ent);
            Argl1 = 1.2e1 * EntSquare;
	    TimesDeriv(&d_Argl1,&d_EntSquare,12.0);
            Argl2 = 1.0 - A;
	    TimesDeriv(&d_Argl2,&d_A,-1.0);
	    d_Argl2.value += 1.0;
	    /*
            Argl3 = Arg1 * vds;
	    MultDeriv(&d_Argl3,&d_Arg1,&d_r);
            Argl4 = Vcom/Ent/EntSquare;
	    MultDeriv(&d_Argl4,&d_Ent,&d_EntSquare);
	    DivDeriv(&d_Argl4,&d_Vcom,&d_Argl4);
	    */
            if (Ent > 1.0e-8) {   
                Argl5 = Arg1 / Ent;
		DivDeriv(&d_Argl5,&d_Arg1,&d_Ent);
                Argl6 = Vcom/EntSquare;
		DivDeriv(&d_Argl6,&d_Vcom,&d_EntSquare);
            } else {   
                Argl5 = 2.0;
		EqualDeriv(&d_Argl5,&d_zero);
		d_Argl5.value = Argl5;
                Argl6 = 4.0 / 1.5e1;
		EqualDeriv(&d_Argl6,&d_zero);
		d_Argl6.value = Argl6;
            }
            Argl7 = Argl5 / 1.2e1;
	    TimesDeriv(&d_Argl7,&d_Argl5,1/12.0);
	    /*
            Argl8 = 6.0 * Ent;
	    TimesDeriv(&d_Argl8,&d_Ent,6.0);
            Argl9 = 0.125 * Argl5 * Argl5;
	    MultDeriv(&d_Argl9,&d_Argl5,&d_Argl5);
	    TimesDeriv(&d_Argl9,&d_Argl9,0.125);
	    */
            qg = WLCox * (vgs - Vfb - Phi - 0.5 * vds + vds * Argl7);
	    EqualDeriv(&d_qg,&d_Argl7);
	    d_qg.value -= 0.5;
	    MultDeriv(&d_qg,&d_qg,&d_r);
	    d_qg.value  += vgs - Vfb - Phi;
	    d_qg.d1_p += 1.0;
	    TimesDeriv(&d_qg,&d_qg,WLCox);
            qb = WLCox * ( - Vth0 + Vfb + Phi + 0.5 * Arg3 - Arg3 * Argl7);
	    TimesDeriv(&d_qb,&d_Argl7,-1.0);
	    d_qb.value += 0.5;