b1dset.c

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

	    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) * here->B1m) * 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);