b3soild.c

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

                     here->B3SOIthetavth = pParam->B3SOIdvt0 * Theta0;
                     Delt_vth = here->B3SOIthetavth * V0;
                     dDelt_vth_dVb = pParam->B3SOIdvt0 * dTheta0_dVb * V0;
                     if (selfheat)  dDelt_vth_dT = here->B3SOIthetavth * dvbi_dT;
                     else  dDelt_vth_dT = 0.0;

                     T0 = -0.5 * pParam->B3SOIdvt1w * pParam->B3SOIweff * Leff / ltw;
                     if (T0 > -EXPL_THRESHOLD)
                     {   T1 = exp(T0);
                         T2 = T1 * (1.0 + 2.0 * T1);
                         dT1_dVb = -T0 / ltw * T1 * dltw_dVb;
                         dT2_dVb = (1.0 + 4.0 * T1) * dT1_dVb;
                     }
                     else
                     {   T1 = MIN_EXPL;
                         T2 = T1 * (1.0 + 2.0 * T1);
                         dT2_dVb = 0.0;
                     }

                     T0 = pParam->B3SOIdvt0w * T2;
                     DeltVthw = T0 * V0;
                     dDeltVthw_dVb = pParam->B3SOIdvt0w * dT2_dVb * V0;
                     if (selfheat)   dDeltVthw_dT = T0 * dvbi_dT;
                     else   dDeltVthw_dT = 0.0;

                     T0 = sqrt(1.0 + pParam->B3SOInlx / Leff);
                     T1 = (pParam->B3SOIkt1 + pParam->B3SOIkt1l / Leff
                           + pParam->B3SOIkt2 * Vbs0mos);
                     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 * Vbs0mos;
                     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;

                     VthFD = model->B3SOItype * pParam->B3SOIvth0 + pParam->B3SOIk1eff
                         * (sqrtPhis - sqrtPhi) - pParam->B3SOIk2
                         * Vbs0mos- Delt_vth - DeltVthw +(pParam->B3SOIk3 + pParam->B3SOIk3b
                         * Vbs0mos) * tmp2 + DeltVthtemp - DIBL_Sft;

                     T6 = pParam->B3SOIk3b * tmp2 - pParam->B3SOIk2
                          + pParam->B3SOIkt2 * TempRatioMinus1;
                     dVthFD_dVb = pParam->B3SOIk1eff * dsqrtPhis_dVb
                              - dDelt_vth_dVb - dDeltVthw_dVb
                              + T6 - dDIBL_Sft_dVb; /*  this is actually dVth_dVbs0mos  */
                     dVthFD_dVe = dVthFD_dVb * dVbs0mos_dVe;
                     dVthFD_dVd = -dDIBL_Sft_dVd;
                     if (selfheat)
                        dVthFD_dT = dDeltVthtemp_dT - dDelt_vth_dT - dDeltVthw_dT
                                  + dVthFD_dVb * dVbs0mos_dT;
                     else  dVthFD_dT = 0.0;


                     /* VtgseffFD calculation for PhiFD */
                     VtgsFD = VthFD - Vgs_eff;
                     T10 = model->B3SOInofffd * Vtm;
                     DEXP((VtgsFD - model->B3SOIvofffd)/ T10, ExpVtgsFD, T0);
                     VtgseffFD = T10 * log(1.0 + ExpVtgsFD);
                     T0 /= (1.0 + ExpVtgsFD);
                     dVtgseffFD_dVd = T0 * dVthFD_dVd;
                     dVtgseffFD_dVg = -T0 * dVgs_eff_dVg;
                     dVtgseffFD_dVe = T0 * dVthFD_dVe;
                     if (selfheat)
                        dVtgseffFD_dT = T0 * (dVthFD_dT - (VtgsFD - model->B3SOIvofffd)/Temp)
                                      + VtgseffFD/Temp;
                     else dVtgseffFD_dT = 0.0;


                     /* surface potential modeling at strong inversion: PhiON */
                     VgstFD = Vgs_eff - VthFD;
                     DEXP((VgstFD - model->B3SOIvofffd)/ T10, ExpVgstFD, T0);
                     VgsteffFD = T10 * log(1.0 + ExpVgstFD);
                     T0 /= (1.0 + ExpVgstFD);
                     dVgsteffFD_dVd = -T0 * dVthFD_dVd;
                     dVgsteffFD_dVg = T0 * dVgs_eff_dVg;
                     dVgsteffFD_dVe = -T0 * dVthFD_dVe;
                     if (selfheat)
                        dVgsteffFD_dT = T0 * (-dVthFD_dT - (VgstFD - model->B3SOIvofffd)/Temp)
                                      + VgsteffFD/Temp;
                     else dVgsteffFD_dT = 0.0;


                     T1 = model->B3SOImoinFD*pParam->B3SOIk1eff*Vtm*Vtm;
                     if (selfheat) dT1_dT = 2*T1/Temp;
                     else dT1_dT=0.0;

                     T2 = VgsteffFD+ 2*pParam->B3SOIk1eff*sqrt(phi);
                     dT2_dVg = dVgsteffFD_dVg;
                     dT2_dVd = dVgsteffFD_dVd;
                     dT2_dVe = dVgsteffFD_dVe;
                     if (selfheat) dT2_dT = dVgsteffFD_dT;
                     else dT2_dT = 0.0;

                     T0 = 1+ VgsteffFD * T2 / T1;
                     dT0_dVg = (VgsteffFD * dT2_dVg + T2 * dVgsteffFD_dVg) / T1;
                     dT0_dVd = (VgsteffFD * dT2_dVd + T2 * dVgsteffFD_dVd) / T1;
                     dT0_dVe = (VgsteffFD * dT2_dVe + T2 * dVgsteffFD_dVe) / T1;
                     if (selfheat)
                        dT0_dT = (VgsteffFD * (dT2_dT - T2/T1 * dT1_dT) + T2 * dVgsteffFD_dT) / T1;
                     else dT0_dT = 0.0;


                     PhiON = phi + Vtm* log(T0) ; 
                     dPhiON_dVg = Vtm* dT0_dVg/T0 ;
                     dPhiON_dVd = Vtm* dT0_dVd/T0 ;
                     dPhiON_dVe = Vtm* dT0_dVe/T0 ;
                     if (selfheat)
                        dPhiON_dT = Vtm* dT0_dT/T0 + (PhiON-phi)/Temp ;
                     else dPhiON_dT = 0.0;


                     /* surface potential from subthreshold to inversion: PhiFD */
                     T0 = model->B3SOIcox / (model->B3SOIcox + 1.0/(1.0/model->B3SOIcsi + 1.0/Cbox));
                     PhiFD = PhiON - T0 * VtgseffFD;
                     dPhiFD_dVg = dPhiON_dVg - T0 * dVtgseffFD_dVg;
                     dPhiFD_dVd = dPhiON_dVd - T0 * dVtgseffFD_dVd;
                     dPhiFD_dVe = dPhiON_dVe - T0 * dVtgseffFD_dVe;
                     if (selfheat)
                        dPhiFD_dT = dPhiON_dT - T0 * dVtgseffFD_dT;
                     else dPhiFD_dT = 0;


                     /* built-in potential lowering: Vbs0 */
                     T0 = -model->B3SOIdvbd1 * pParam->B3SOIleff / pParam->B3SOIlitl;
                     T1 = model->B3SOIdvbd0 * (exp(0.5*T0) + 2*exp(T0));
                     T2 = T1 * (vbi - phi);
                     T3 = 0.5 * model->B3SOIqsi / model->B3SOIcsi;
                     Vbs0t = PhiFD - T3 + model->B3SOIvbsa + T2;
                     dVbs0t_dVg = dPhiFD_dVg;
                     dVbs0t_dVd = dPhiFD_dVd;
                     dVbs0t_dVe = dPhiFD_dVe;
                     if (selfheat)
                        dVbs0t_dT = dPhiFD_dT + T1 * dvbi_dT;
                     else dVbs0t_dT = 0;


                     T0 = 1 + model->B3SOIcsi / Cbox;
                     T3 = -model->B3SOIdk2b * pParam->B3SOIleff / pParam->B3SOIlitl;
                     T5 = model->B3SOIk2b * (exp(0.5*T3) + 2*exp(T3));
                     T1 = (model->B3SOIk1b - T5) / T0;
                     T2 = T1 * Vesfb;
                     T0 = 1.0/(1 + Cbox / model->B3SOIcsi);
                     Vbs0 = T0 * Vbs0t + T2;
                     dVbs0_dVg = T0 * dVbs0t_dVg;
                     dVbs0_dVd = T0 * dVbs0t_dVd;
                     dVbs0_dVe = T0 * dVbs0t_dVe + T1;
                     if (selfheat)
                        dVbs0_dT =  T0 * dVbs0t_dT - T1 * dvfbb_dT;
                     else
                        dVbs0_dT = 0.0;


                     /* set lowerbound of Vbs (from SPICE) to Vbs0: Vbsitf (Vbs at back interface) */
                     T1 = Vbs - (Vbs0 + 0.02) - 0.01;
                     T2 = sqrt(T1*T1 + 0.0001);
                     T3 = 0.5 * (1 + T1/T2);
                     Vbsitf = Vbs0 + 0.02 + 0.5 * (T1 + T2);
                     dVbsitf_dVg = (1 - T3) * dVbs0_dVg;
                     dVbsitf_dVd = (1 - T3) * dVbs0_dVd;
                     dVbsitf_dVe = (1 - T3) * dVbs0_dVe;
                     dVbsitf_dVb = T3 ;
                     if (selfheat)  dVbsitf_dT = (1 - T3) * dVbs0_dT;
                     else  dVbsitf_dT = 0.0;


                     /* Based on Vbsitf, calculate zero-field body potential for MOS: Vbsmos */
                     T1 = Vbs0t - Vbsitf - 0.005;
                     T2 = sqrt(T1 * T1 + (2.5e-5));
                     T3 = 0.5 * (T1 + T2);
                     T4 = T3 * model->B3SOIcsi / model->B3SOIqsi;
                     Vbsmos = Vbsitf - 0.5 * T3 * T4;
                     T5 = 0.5 * T4 * (1 + T1 / T2);
                     dVbsmos_dVg = dVbsitf_dVg * (1 + T5) - T5 * dVbs0t_dVg;
                     dVbsmos_dVd = dVbsitf_dVd * (1 + T5) - T5 * dVbs0t_dVd;
                     dVbsmos_dVb = dVbsitf_dVb * (1 + T5);
                     dVbsmos_dVe = dVbsitf_dVe * (1 + T5) - T5 * dVbs0t_dVe;
                     if (selfheat)
                        dVbsmos_dT = dVbsitf_dT * (1 + T5) - T5 * dVbs0t_dT;
                     else
                        dVbsmos_dT = 0.0;
                     /* Vbsmos should be used in MOS after some limiting (Vbseff) */


                     Vbp = Vbs - Vps;
                     dVbp_dVb = 1;
                  }
/* end of v3.0 block edition */


/* v3.0 modification */
                  /* T2 is Vbsmos limited above Vbsc=-5 */
                  T0 = Vbsmos + 5 - 0.001;
                  T1 = sqrt(T0 * T0 - 0.004 * (-5));
                  T2 = (-5) + 0.5 * (T0 + T1);
                  dT2_dVb = (0.5 * (1.0 + T0 / T1)) * dVbsmos_dVb;
                  dT2_dVg = (0.5 * (1.0 + T0 / T1)) * dVbsmos_dVg;
                  dT2_dVd = (0.5 * (1.0 + T0 / T1)) * dVbsmos_dVd;
                  dT2_dVe = (0.5 * (1.0 + T0 / T1)) * dVbsmos_dVe;
                  if (selfheat) dT2_dT = (0.5 * (1.0 + T0 / T1)) * dVbsmos_dT;  
                  else  dT2_dT = 0.0;

                  /* Vbsh is T2 limited below 1.5 */
                  T0 = 1.5;
                  T1 = T0 - T2 - 0.002;
                  T3 = sqrt(T1 * T1 + 0.008 * T0);
                  Vbsh = T0 - 0.5 * (T1 + T3);
                  dVbsh_dVb = 0.5 * (1.0 + T1 / T3) * dT2_dVb;
                  dVbsh_dVg = 0.5 * (1.0 + T1 / T3) * dT2_dVg;
                  dVbsh_dVd = 0.5 * (1.0 + T1 / T3) * dT2_dVd;
                  dVbsh_dVe = 0.5 * (1.0 + T1 / T3) * dT2_dVe;
                  if (selfheat) dVbsh_dT = 0.5 * (1.0 + T1 / T3) * dT2_dT; 
                  else  dVbsh_dT = 0.0;


                  /* Vbseff is Vbsh limited to 0.95*phi */
                  T0 = 0.95 * phi;
                  T1 = T0 - Vbsh - 0.002;
                  T2 = sqrt(T1 * T1 + 0.008 * T0);
                  Vbseff = T0 - 0.5 * (T1 + T2);
                  dVbseff_dVb = 0.5 * (1.0 + T1 / T2) * dVbsh_dVb;
                  dVbseff_dVg = 0.5 * (1.0 + T1 / T2) * dVbsh_dVg;
                  dVbseff_dVd = 0.5 * (1.0 + T1 / T2) * dVbsh_dVd;
                  dVbseff_dVe = 0.5 * (1.0 + T1 / T2) * dVbsh_dVe;
                  if (selfheat)  dVbseff_dT = 0.5 * (1.0 + T1 / T2) * dVbsh_dT;
                  else  dVbseff_dT = 0.0;
                  here->B3SOIvbseff = Vbs; /* SPICE sol. */
/* end of v3.0 modification */

 
                  /* Below all the variables refer to Vbseff */
                  if (dVbseff_dVb < 1e-20) {
                     dVbseff_dVb = 1e-20;
                     dVbsh_dVb *= 1e20;
                  }
                  else
                     dVbsh_dVb /= dVbseff_dVb;
 
                  Phis = phi - Vbseff;
                  dPhis_dVb = -1;
                  sqrtPhis = sqrt(Phis);
                  dsqrtPhis_dVb = -0.5 / sqrtPhis;

                  Xdep = Xdep0 * sqrtPhis / sqrtPhi;
                  dXdep_dVb = (Xdep0 / sqrtPhi) * dsqrtPhis_dVb;

/* Vth Calculation */
		  T3 = sqrt(Xdep);
                  
		  T0 = pParam->B3SOIdvt2 * Vbseff;
		  if (T0 >= - 0.5)
		  {   T1 = 1.0 + T0;
		      T2 = pParam->B3SOIdvt2 ;
		  }
		  else /* Added to avoid any discontinuity problems caused by dvt2 */ 
		  {   T4 = 1.0 / (3.0 + 8.0 * T0);
		      T1 = (1.0 + 3.0 * T0) * T4; 
		      T2 = pParam->B3SOIdvt2 * T4 * T4 ;
		  }
		  lt1 = model->B3SOIfactor1 * T3 * T1;
		  dlt1_dVb =model->B3SOIfactor1 * (0.5 / T3 * T1 * dXdep_dVb + T3 * T2);

		  T0 = pParam->B3SOIdvt2w * Vbseff;
		  if (T0 >= - 0.5)
		  {   T1 = 1.0 + T0;
		      T2 = pParam->B3SOIdvt2w ;
		  }
		  else /* Added to avoid any discontinuity problems caused by dvt2w */ 
		  {   T4 = 1.0 / (3.0 + 8.0 * T0);
		      T1 = (1.0 + 3.0 * T0) * T4; 
		      T2 = pParam->B3SOIdvt2w * T4 * T4 ;
		  }
		  ltw= model->B3SOIfactor1 * T3 * T1;
		  dltw_dVb=model->B3SOIfactor1*(0.5 / T3 * T1 * dXdep_dVb + T3 * T2);

		  T0 = -0.5 * pParam->B3SOIdvt1 * Leff / lt1;
		  if (T0 > -EXPL_THRESHOLD)
		  {   T1 = exp(T0);
		      Theta0 = T1 * (1.0 + 2.0 * T1);
		      dT1_dVb = -T0 / lt1 * T1 * dlt1_dVb;
		      dTheta0_dVb = (1.0 + 4.0 * T1) * dT1_dVb;
		  }
		  else
		  {   T1 = MIN_EXPL;
		      Theta0 = T1 * (1.0 + 2.0 * T1);
		      dTheta0_dVb = 0.0;
		  }

		  here->B3SOIthetavth = pParam->B3SOIdvt0 * Theta0;
		  Delt_vth = here->B3SOIthetavth * V0;
		  dDelt_vth_dVb = pParam->B3SOIdvt0 * dTheta0_dVb * V0;
                  if (selfheat)  dDelt_vth_dT = here->B3SOIthetavth * dvbi_dT;
                  else  dDelt_vth_dT = 0.0;

		  T0 = -0.5 * pParam->B3SOIdvt1w * pParam->B3SOIweff * Leff / ltw;
		  if (T0 > -EXPL_THRESHOLD)
		  {   T1 = exp(T0);
		      T2 = T1 * (1.0 + 2.0 * T1);
		      dT1_dVb = -T0 / ltw * T1 * dltw_dVb;
		      dT2_dVb = (1.0 + 4.0 * T1) * dT1_dVb;
		  }
		  else
		  {   T1 = MIN_EXPL;
		      T2 = T1 * (1.0 + 2.0 * T1);
		      dT2_dVb = 0.0;
		  }

		  T0 = pParam->B3SOIdvt0w * T2;
		  DeltVthw = T0 * V0;
		  dDeltVthw_dVb = pParam->B3SOIdvt0w * dT2_dVb * V0;
                  if (selfheat)   dDeltVthw_dT = T0 * dvbi_dT;