b3soild.c

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

                  else   dDeltVthw_dT = 0.0;

		  T0 = sqrt(1.0 + pParam->B3SOInlx / Leff);
                  T1 = (pParam->B3SOIkt1 + pParam->B3SOIkt1l / Leff
                        + pParam->B3SOIkt2 * Vbseff);
                  DeltVthtemp = pParam->B3SOIk1eff * (T0 - 1.0) * sqrtPhi + T1 * TempRatioMinus1;
                  if (selfheat)
                     dDeltVthtemp_dT = T1 / model->B3SOItnom;
                  else
                     dDeltVthtemp_dT = 0.0;

		  tmp2 = model->B3SOItox * phi
		       / (pParam->B3SOIweff + pParam->B3SOIw0);

		  T3 = pParam->B3SOIeta0 + pParam->B3SOIetab * Vbseff;
		  if (T3 < 1.0e-4) /* avoid  discontinuity problems caused by etab */ 
		  {   T9 = 1.0 / (3.0 - 2.0e4 * T3);
		      T3 = (2.0e-4 - T3) * T9;
		      T4 = T9 * T9 * pParam->B3SOIetab;
		      dT3_dVb = T4 ;
		  }
		  else
		  {   
		      dT3_dVb = pParam->B3SOIetab ;
		  }
		  DIBL_Sft = T3 * pParam->B3SOItheta0vb0 * Vds;
		  dDIBL_Sft_dVd = pParam->B3SOItheta0vb0 * T3;
		  dDIBL_Sft_dVb = pParam->B3SOItheta0vb0 * Vds * dT3_dVb;

                  T9 =  2.2361 / sqrtPhi;
                  sqrtPhisExt = sqrtPhis - T9 * (Vbsh - Vbseff);
                  dsqrtPhisExt_dVb = dsqrtPhis_dVb - T9 * (dVbsh_dVb - 1);

                  Vth = model->B3SOItype * pParam->B3SOIvth0 + pParam->B3SOIk1eff 
                      * (sqrtPhisExt - sqrtPhi) - pParam->B3SOIk2 
                      * Vbseff- Delt_vth - DeltVthw +(pParam->B3SOIk3 + pParam->B3SOIk3b
                      * Vbseff) * tmp2 + DeltVthtemp - DIBL_Sft;
                  here->B3SOIvon = Vth; 

                  T6 = pParam->B3SOIk3b * tmp2 - pParam->B3SOIk2 
                       + pParam->B3SOIkt2 * TempRatioMinus1;        
                  dVth_dVb = pParam->B3SOIk1eff * dsqrtPhisExt_dVb 
                           - dDelt_vth_dVb - dDeltVthw_dVb
                           + T6 - dDIBL_Sft_dVb;  
                  /*  this is actually dVth_dVbseff  */

                  dVth_dVd = -dDIBL_Sft_dVd;
                  if (selfheat)  
                     dVth_dT = dDeltVthtemp_dT - dDelt_vth_dT - dDeltVthw_dT; 
                  else  dVth_dT = 0.0;


                  /* dVthzb_dT calculation */
                  if ((model->B3SOIcapMod == 3) && (selfheat == 1)) {
                     T3zb = sqrt(Xdep0);
                     ltwzb = lt1zb = model->B3SOIfactor1 * T3zb;

                     T0 = -0.5 * pParam->B3SOIdvt1 * Leff / lt1zb;
                     if (T0 > -EXPL_THRESHOLD)
                     {   T1 = exp(T0);
                         Theta0zb = T1 * (1.0 + 2.0 * T1);
                     }
                     else
                     {   T1 = MIN_EXPL;
                         Theta0zb = T1 * (1.0 + 2.0 * T1);
                     }
                     Delt_vthzb = pParam->B3SOIdvt0 * Theta0zb * V0;
                     dDelt_vthzb_dT = pParam->B3SOIdvt0 * Theta0zb * dvbi_dT;
      
                     T0 = -0.5 * pParam->B3SOIdvt1w * pParam->B3SOIweff * Leff / ltwzb;
                     if (T0 > -EXPL_THRESHOLD)
                     {   T1 = exp(T0);
                         T2 = T1 * (1.0 + 2.0 * T1);
                     }
                     else
                     {   T1 = MIN_EXPL;
                         T2 = T1 * (1.0 + 2.0 * T1);
                     }
                     T0 = pParam->B3SOIdvt0w * T2;
                     DeltVthwzb = T0 * V0;
                     dDeltVthwzb_dT = T0 * dvbi_dT;

                     T0 = sqrt(1.0 + pParam->B3SOInlx / Leff);
                     T1 = (pParam->B3SOIkt1 + pParam->B3SOIkt1l / Leff);
                     DeltVthtempzb = pParam->B3SOIk1eff * (T0 - 1.0) * sqrtPhi
                                   + T1 * TempRatioMinus1;
                     dDeltVthtempzb_dT = T1 / model->B3SOItnom;

                     Vthzb = model->B3SOItype * pParam->B3SOIvth0 
                           - Delt_vthzb - DeltVthwzb + pParam->B3SOIk3 * tmp2
                           + DeltVthtempzb;
                     dVthzb_dT = dDeltVthtempzb_dT - dDelt_vthzb_dT - dDeltVthwzb_dT;
                  }

/* Calculate n */
		  T2 = pParam->B3SOInfactor * EPSSI / Xdep;
		  dT2_dVb = - T2 / Xdep * dXdep_dVb;

		  T3 = pParam->B3SOIcdsc + pParam->B3SOIcdscb * Vbseff
		       + pParam->B3SOIcdscd * Vds;
		  dT3_dVb = pParam->B3SOIcdscb;
		  dT3_dVd = pParam->B3SOIcdscd;

		  T4 = (T2 + T3 * Theta0 + pParam->B3SOIcit) / model->B3SOIcox;
		  dT4_dVb = (dT2_dVb + Theta0 * dT3_dVb + dTheta0_dVb * T3)
                            / model->B3SOIcox;
		  dT4_dVd = Theta0 * dT3_dVd / model->B3SOIcox;

		  if (T4 >= -0.5)
		  {   n = 1.0 + T4;
		      dn_dVb = dT4_dVb;
		      dn_dVd = dT4_dVd;
		  }
		  else
		   /* avoid  discontinuity problems caused by T4 */ 
		  {   T0 = 1.0 / (3.0 + 8.0 * T4);
		      n = (1.0 + 3.0 * T4) * T0;
		      T0 *= T0;
		      dn_dVb = T0 * dT4_dVb;
		      dn_dVd = T0 * dT4_dVd;
		  }

/* Effective Vgst (Vgsteff) Calculation */

		  Vgst = Vgs_eff - Vth;
                  dVgst_dVg = dVgs_eff_dVg;
                  dVgst_dVd = -dVth_dVd;
                  dVgst_dVb = -dVth_dVb;

		  T10 = 2.0 * n * Vtm;
		  VgstNVt = Vgst / T10;
		  ExpArg = (2.0 * pParam->B3SOIvoff - Vgst) / T10;

		  /* MCJ: Very small Vgst */
		  if (VgstNVt > EXPL_THRESHOLD)
		  {   Vgsteff = Vgst;
                      /* T0 is dVgsteff_dVbseff */
                      T0 = -dVth_dVb;
		      dVgsteff_dVg = dVgs_eff_dVg + T0 * dVbseff_dVg; /* v3.0 */
		      dVgsteff_dVd = -dVth_dVd + T0 * dVbseff_dVd; /* v3.0 */
		      dVgsteff_dVb = T0 * dVbseff_dVb;
                      dVgsteff_dVe = T0 * dVbseff_dVe; /* v3.0 */
                      if (selfheat)
                         dVgsteff_dT  = -dVth_dT + T0 * dVbseff_dT; /* v3.0 */
                      else
                         dVgsteff_dT = 0.0;
		  }
		  else if (ExpArg > EXPL_THRESHOLD)
		  {   T0 = (Vgst - pParam->B3SOIvoff) / (n * Vtm);
		      ExpVgst = exp(T0);
		      Vgsteff = Vtm * pParam->B3SOIcdep0 / model->B3SOIcox * ExpVgst;
		      T3 = Vgsteff / (n * Vtm) ;
                      /* T1 is dVgsteff_dVbseff */
		      T1  = -T3 * (dVth_dVb + T0 * Vtm * dn_dVb);
		      dVgsteff_dVg = T3 * dVgs_eff_dVg+ T1 * dVbseff_dVg; /* v3.0 */
		      dVgsteff_dVd = -T3 * (dVth_dVd + T0 * Vtm * dn_dVd)+ T1 * dVbseff_dVd; /* v3.0 */
                      dVgsteff_dVe = T1 * dVbseff_dVe; /* v3.0 */
                      dVgsteff_dVb = T1 * dVbseff_dVb;
                      if (selfheat)
                         dVgsteff_dT = -T3 * (dVth_dT + T0 * dVtm_dT * n)
                                     + Vgsteff / Temp+ T1 * dVbseff_dT; /* v3.0 */
                      else
                         dVgsteff_dT = 0.0;
		  }
		  else
		  {   ExpVgst = exp(VgstNVt);
		      T1 = T10 * log(1.0 + ExpVgst);
		      dT1_dVg = ExpVgst / (1.0 + ExpVgst);
		      dT1_dVb = -dT1_dVg * (dVth_dVb + Vgst / n * dn_dVb)
			      + T1 / n * dn_dVb; 
		      dT1_dVd = -dT1_dVg * (dVth_dVd + Vgst / n * dn_dVd)
			      + T1 / n * dn_dVd;
                      T3 = (1.0 / Temp);
                      if (selfheat)
                         dT1_dT = -dT1_dVg * (dVth_dT + Vgst * T3) + T1 * T3;
                      else
                         dT1_dT = 0.0;

		      dT2_dVg = -model->B3SOIcox / (Vtm * pParam->B3SOIcdep0)
			      * exp(ExpArg);
		      T2 = 1.0 - T10 * dT2_dVg;
		      dT2_dVd = -dT2_dVg * (dVth_dVd - 2.0 * Vtm * ExpArg * dn_dVd)
			      + (T2 - 1.0) / n * dn_dVd;
		      dT2_dVb = -dT2_dVg * (dVth_dVb - 2.0 * Vtm * ExpArg * dn_dVb)
			      + (T2 - 1.0) / n * dn_dVb;
                      if (selfheat)
                         dT2_dT = -dT2_dVg * (dVth_dT - ExpArg * T10 * T3);
                      else
                         dT2_dT = 0.0;

		      Vgsteff = T1 / T2;
		      T3 = T2 * T2;
                      /*  T4 is dVgsteff_dVbseff  */
		      T4 = (T2 * dT1_dVb - T1 * dT2_dVb) / T3;
                      dVgsteff_dVb = T4 * dVbseff_dVb;
                      dVgsteff_dVe = T4 * dVbseff_dVe; /* v3.0 */
		      dVgsteff_dVg = (T2 * dT1_dVg - T1 * dT2_dVg) / T3 * dVgs_eff_dVg
                                     + T4 * dVbseff_dVg; /* v3.0 */
		      dVgsteff_dVd = (T2 * dT1_dVd - T1 * dT2_dVd) / T3+ T4 * dVbseff_dVd; /* v3.0 */
                      if (selfheat)
                         dVgsteff_dT = (T2 * dT1_dT - T1 * dT2_dT) / T3+ T4 * dVbseff_dT; /* v3.0 */
                      else
                         dVgsteff_dT = 0.0;
		  }
		  Vgst2Vtm = Vgsteff + 2.0 * Vtm;
                  if (selfheat)  dVgst2Vtm_dT = 2.0 * dVtm_dT;  
                  else  dVgst2Vtm_dT = 0.0;
		  here->B3SOIVgsteff = Vgsteff; /* v2.2.3 bug fix */


/* Calculate Effective Channel Geometry */
		  T9 = sqrtPhis - sqrtPhi;
		  Weff = pParam->B3SOIweff - (2.0 - here->B3SOInbc) * (pParam->B3SOIdwg * Vgsteff 
		       + pParam->B3SOIdwb * T9); 
		  dWeff_dVg = -(2.0 - here->B3SOInbc) * pParam->B3SOIdwg;
		  dWeff_dVb = -(2.0 - here->B3SOInbc) * pParam->B3SOIdwb * dsqrtPhis_dVb;

		  if (Weff < 2.0e-8) /* to avoid the discontinuity problem due to Weff*/
		  {   T0 = 1.0 / (6.0e-8 - 2.0 * Weff);
		      Weff = 2.0e-8 * (4.0e-8 - Weff) * T0;
		      T0 *= T0 * 4.0e-16;
		      dWeff_dVg *= T0;
		      dWeff_dVb *= T0;
		  }

		  T0 = pParam->B3SOIprwg * Vgsteff + pParam->B3SOIprwb * T9;
		  if (T0 >= -0.9)
		  {   Rds = rds0 * (1.0 + T0);
		      dRds_dVg = rds0 * pParam->B3SOIprwg;
		      dRds_dVb = rds0 * pParam->B3SOIprwb * dsqrtPhis_dVb;

                      if (selfheat && (Rds!=0.0))  dRds_dT = (1.0 + T0) * drds0_dT;
                      else  dRds_dT = 0.0;

		  }
		  else
		   /* to avoid the discontinuity problem due to prwg and prwb*/
		  {   T1 = 1.0 / (17.0 + 20.0 * T0);
		      Rds = rds0 * (0.8 + T0) * T1;
		      T1 *= T1;
		      dRds_dVg = rds0 * pParam->B3SOIprwg * T1;
		      dRds_dVb = rds0 * pParam->B3SOIprwb * dsqrtPhis_dVb
			       * T1;

                      if (selfheat && (Rds!=0.0))  dRds_dT = (0.8 + T0) * T1 * drds0_dT;
                      else  dRds_dT = 0.0;

		  }
		  here->B3SOIrds = Rds; /* v2.2.3 bug fix */

/* Calculate Abulk */
                  if (pParam->B3SOIa0 == 0.0) {

                     Abulk0 = Abulk = 1.0;

                     dAbulk0_dVb = dAbulk_dVg = dAbulk_dVb = 0.0;
                  }
                  else { 
                     T10 = pParam->B3SOIketa * Vbsh; 
                     if (T10 >= -0.9) {
                        T11 = 1.0 / (1.0 + T10);
                        dT11_dVb = -pParam->B3SOIketa * T11 * T11 * dVbsh_dVb;
                     }
                     else { /* added to avoid the problems caused by Keta */
                        T12 = 1.0 / (0.8 + T10);
                        T11 = (17.0 + 20.0 * T10) * T12;
                        dT11_dVb = -pParam->B3SOIketa * T12 * T12 * dVbsh_dVb;
                     }

/* v3.0 bug fix */
                     T10 = phi + pParam->B3SOIketas;

                     T13 = (Vbsh * T11) / T10;
                     dT13_dVb = (Vbsh * dT11_dVb + T11 * dVbsh_dVb) / T10;

                     /* limit 1/sqrt(1-T13) to 6, starting at T13=0.96 */
                     if (T13 < 0.96) {
                        T14 = 1 / sqrt(1-T13);
                        T10 = 0.5 * T14 / (1-T13);
                        dT14_dVb = T10 * dT13_dVb;
                     }
                     else {
                        T11 = 1.0 / (1.0 - 1.043406*T13);
                        T14 = (6.00167 - 6.26044 * T13) * T11;
                        T10 = 0.001742 * T11 * T11;
                        dT14_dVb = T10 * dT13_dVb;
                     }

/* v3.0 bug fix */
                     T10 = 0.5 * pParam->B3SOIk1eff 
                         / sqrt(phi + pParam->B3SOIketas);

                     T1 = T10 * T14;
                     dT1_dVb = T10 * dT14_dVb;

                     T9 = sqrt(model->B3SOIxj * Xdep);
                     tmp1 = Leff + 2.0 * T9;
                     T5 = Leff / tmp1;
                     tmp2 = pParam->B3SOIa0 * T5;
                     tmp3 = pParam->B3SOIweff + pParam->B3SOIb1;
                     tmp4 = pParam->B3SOIb0 / tmp3;
                     T2 = tmp2 + tmp4;
                     dT2_dVb = -T9 * tmp2 / tmp1 / Xdep * dXdep_dVb;
                     T6 = T5 * T5;
                     T7 = T5 * T6;
 
                     Abulk0 = 1 + T1 * T2;
                     dAbulk0_dVb = T1 * dT2_dVb + T2 * dT1_dVb;
 
                     T8 = pParam->B3SOIags * pParam->B3SOIa0 * T7;
                     dAbulk_dVg = -T1 * T8;
                     Abulk = Abulk0 + dAbulk_dVg * Vgsteff;
 
                     dAbulk_dVb = dAbulk0_dVb 
                                - T8 * Vgsteff * (dT1_dVb + 3.0 * T1 * dT2_dVb / tmp2);
                  }

                  if (Abulk0 < 0.01)
                  {
                     T9 = 1.0 / (3.0 - 200.0 * Abulk0);
                     Abulk0 = (0.02 - Abulk0) * T9;
                     dAbulk0_dVb *= T9 * T9;
                  }

                  if (Abulk < 0.01)
                  {
                     T9 = 1.0 / (3.0 - 2