b3soipdld.c

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

		      uc = pParam->B3SOIPDuctemp + pParam->B3SOIPDuc1 * T3;
                      dua_dT = pParam->B3SOIPDua1 * T8;
                      dub_dT = pParam->B3SOIPDub1 * T8;
                      duc_dT = pParam->B3SOIPDuc1 * T8;
		  }
		  else {
                      vbi = pParam->B3SOIPDvbi;
                      vfbb = pParam->B3SOIPDvfbb;
                      phi = pParam->B3SOIPDphi;
                      sqrtPhi = pParam->B3SOIPDsqrtPhi;
                      Xdep0 = pParam->B3SOIPDXdep0;
                      jbjt = pParam->B3SOIPDjbjt;
                      jdif = pParam->B3SOIPDjdif;
                      jrec = pParam->B3SOIPDjrec;
                      jtun = pParam->B3SOIPDjtun;

                      /* v2.2.2 bug fix */
                      Ahli = pParam->B3SOIPDahli0; 

                      u0temp = pParam->B3SOIPDu0temp;
                      vsattemp = pParam->B3SOIPDvsattemp;
                      rds0 = pParam->B3SOIPDrds0;
                      ua = pParam->B3SOIPDua;
                      ub = pParam->B3SOIPDub;
                      uc = pParam->B3SOIPDuc;
                      dni_dT = dvbi_dT = dvfbb_dT = djbjt_dT = djdif_dT = 0.0;
                      djrec_dT = djtun_dT = du0temp_dT = dvsattemp_dT = 0.0;
                      drds0_dT = dua_dT = dub_dT = duc_dT = 0.0;
                      dAhli_dT = 0; 
		  }
		  
		  /* TempRatio used for Vth and mobility */
		  if (selfheat) {
		      TempRatioMinus1 = Temp / model->B3SOIPDtnom - 1.0;
		  }
		  else {
		      TempRatioMinus1 =  ckt->CKTtemp / model->B3SOIPDtnom - 1.0;
		  }

		  /* determine DC current and derivatives */
		  vbd = vbs - vds;
		  vgd = vgs - vds;
		  vgb = vgs - vbs;
		  ved = ves - vds;
		  veb = ves - vbs;
		  vge = vgs - ves;
		  vpd = vps - vds;


		  if (vds >= 0.0)
		  {   /* normal mode */
		      here->B3SOIPDmode = 1;
		      Vds = vds;
		      Vgs = vgs;
		      Vbs = vbs;
		      Vbd = vbd;
		      Ves = ves;
		      Vps = vps;

                      wdios = pParam->B3SOIPDwdios;
                      wdiod = pParam->B3SOIPDwdiod;
                      wdiosCV = pParam->B3SOIPDwdiosCV;
                      wdiodCV = pParam->B3SOIPDwdiodCV;

		  }
		  else
		  {   /* inverse mode */
		      here->B3SOIPDmode = -1;
		      Vds = -vds;
		      Vgs = vgd;
		      Vbs = vbd;
		      Vbd = vbs;
		      Ves = ved;
		      Vps = vpd;

                      wdios = pParam->B3SOIPDwdiod;
                      wdiod = pParam->B3SOIPDwdios;
                      wdiosCV = pParam->B3SOIPDwdiodCV;
                      wdiodCV = pParam->B3SOIPDwdiosCV;

		  }

		  Vesfb = Ves - vfbb;
		  Cbox = model->B3SOIPDcbox;
		  K1 = pParam->B3SOIPDk1eff;

		  ChargeComputationNeeded =  
			 ((ckt->CKTmode & (MODEAC | MODETRAN | MODEINITSMSIG)) ||
			 ((ckt->CKTmode & MODETRANOP) && (ckt->CKTmode & MODEUIC)))
				 ? 1 : 0;

                  if (here->B3SOIPDdebugMod <0)
                     ChargeComputationNeeded = 1;
                  



/* Poly Gate Si Depletion Effect */
		  T0 = pParam->B3SOIPDvfb + phi;
		  if ((pParam->B3SOIPDngate > 1.e18) && (pParam->B3SOIPDngate < 1.e25) 
		       && (Vgs > T0))
		  /* added to avoid the problem caused by ngate */
		  {   T1 = 1.0e6 * Charge_q * EPSSI * pParam->B3SOIPDngate
			 / (model->B3SOIPDcox * model->B3SOIPDcox);
		      T4 = sqrt(1.0 + 2.0 * (Vgs - T0) / T1);
		      T2 = T1 * (T4 - 1.0);
		      T3 = 0.5 * T2 * T2 / T1; /* T3 = Vpoly */
		      T7 = 1.12 - T3 - 0.05;
		      T6 = sqrt(T7 * T7 + 0.224);
		      T5 = 1.12 - 0.5 * (T7 + T6);
		      Vgs_eff = Vgs - T5;
		      dVgs_eff_dVg = 1.0 - (0.5 - 0.5 / T4) * (1.0 + T7 / T6); 
		  }
		  else
		  {   Vgs_eff = Vgs;
		      dVgs_eff_dVg = 1.0;
		  }


		  Leff = pParam->B3SOIPDleff;

		  if (selfheat) {
		      Vtm = KboQ * Temp;
                      dVtm_dT = KboQ;
		  }
		  else {
		      Vtm = model->B3SOIPDvtm;
                      dVtm_dT = 0.0;
		  }

		  V0 = vbi - phi;

                  Vbp = Vbs - Vps;
                  dVbp_dVb = 1;


                  /* T2 is Vbs limited above Vbsc=-5 */
                  T0 = Vbs + 5 - 0.001;
                  T1 = sqrt(T0 * T0 - 0.004 * (-5));
                  T2 = (-5) + 0.5 * (T0 + T1);
                  dT2_dVb = 0.5 * (1.0 + T0 / T1);

                  /* 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;

                  /* 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;
                  here->B3SOIPDvbseff = Vbs;
            
                  /* 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->B3SOIPDdvt2 * Vbseff;
		  if (T0 >= - 0.5)
		  {   T1 = 1.0 + T0;
		      T2 = pParam->B3SOIPDdvt2 ;
		  }
		  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->B3SOIPDdvt2 * T4 * T4 ;
		  }
		  lt1 = model->B3SOIPDfactor1 * T3 * T1;
		  dlt1_dVb =model->B3SOIPDfactor1 * (0.5 / T3 * T1 * dXdep_dVb + T3 * T2);

		  T0 = pParam->B3SOIPDdvt2w * Vbseff;
		  if (T0 >= - 0.5)
		  {   T1 = 1.0 + T0;
		      T2 = pParam->B3SOIPDdvt2w ;
		  }
		  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->B3SOIPDdvt2w * T4 * T4 ;
		  }
		  ltw= model->B3SOIPDfactor1 * T3 * T1;
		  dltw_dVb=model->B3SOIPDfactor1*(0.5 / T3 * T1 * dXdep_dVb + T3 * T2);

		  T0 = -0.5 * pParam->B3SOIPDdvt1 * 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->B3SOIPDthetavth = pParam->B3SOIPDdvt0 * Theta0;
		  Delt_vth = here->B3SOIPDthetavth * V0;
		  dDelt_vth_dVb = pParam->B3SOIPDdvt0 * dTheta0_dVb * V0;
                  if (selfheat)  dDelt_vth_dT = here->B3SOIPDthetavth * dvbi_dT;
                  else  dDelt_vth_dT = 0.0;

		  T0 = -0.5 * pParam->B3SOIPDdvt1w * pParam->B3SOIPDweff * 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->B3SOIPDdvt0w * T2;
		  DeltVthw = T0 * V0;
		  dDeltVthw_dVb = pParam->B3SOIPDdvt0w * dT2_dVb * V0;
                  if (selfheat)   dDeltVthw_dT = T0 * dvbi_dT;
                  else   dDeltVthw_dT = 0.0;

		  T0 = sqrt(1.0 + pParam->B3SOIPDnlx / Leff);
                  T1 = (pParam->B3SOIPDkt1 + pParam->B3SOIPDkt1l / Leff
                        + pParam->B3SOIPDkt2 * Vbseff);
                  DeltVthtemp = pParam->B3SOIPDk1eff * (T0 - 1.0) * sqrtPhi + T1 * TempRatioMinus1;
                  if (selfheat)
                     dDeltVthtemp_dT = T1 / model->B3SOIPDtnom;
                  else
                     dDeltVthtemp_dT = 0.0;

		  tmp2 = model->B3SOIPDtox * phi
		       / (pParam->B3SOIPDweff + pParam->B3SOIPDw0);

		  T3 = pParam->B3SOIPDeta0 + pParam->B3SOIPDetab * 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->B3SOIPDetab;
		      dT3_dVb = T4 ;
		  }
		  else
		  {   
		      dT3_dVb = pParam->B3SOIPDetab ;
		  }
		  DIBL_Sft = T3 * pParam->B3SOIPDtheta0vb0 * Vds;
		  dDIBL_Sft_dVd = pParam->B3SOIPDtheta0vb0 * T3;
		  dDIBL_Sft_dVb = pParam->B3SOIPDtheta0vb0 * Vds * dT3_dVb;

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

                  Vth = model->B3SOIPDtype * pParam->B3SOIPDvth0 + pParam->B3SOIPDk1eff 
                      * (sqrtPhisExt - sqrtPhi) - pParam->B3SOIPDk2 
                      * Vbseff- Delt_vth - DeltVthw +(pParam->B3SOIPDk3 + pParam->B3SOIPDk3b
                      * Vbseff) * tmp2 + DeltVthtemp - DIBL_Sft;
                  here->B3SOIPDvon = Vth; 

                  T6 = pParam->B3SOIPDk3b * tmp2 - pParam->B3SOIPDk2 
                       + pParam->B3SOIPDkt2 * TempRatioMinus1;        
                  dVth_dVb = pParam->B3SOIPDk1eff * 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->B3SOIPDcapMod == 3) && (selfheat == 1)) {
                     T3zb = sqrt(Xdep0);
                     ltwzb = lt1zb = model->B3SOIPDfactor1 * T3zb;

                     T0 = -0.5 * pParam->B3SOIPDdvt1 * 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->B3SOIPDdvt0 * Theta0zb * V0;
                     dDelt_vthzb_dT = pParam->B3SOIPDdvt0 * Theta0zb * dvbi_dT;
      
                     T0 = -0.5 * pParam->B3SOIPDdvt1w * pParam->B3SOIPDweff * 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->B3SOIPDdvt0w * T2;
                     DeltVthwzb = T0 * V0;
                     dDeltVthwzb_dT = T0 * dvbi_dT;

                     T0 = sqrt(1.0 + pParam->B3SOIPDnlx / Leff);
                     T1 = (pParam->B3SOIPDkt1 + pParam->B3SOIPDkt1l / Leff);
                     DeltVthtempzb = pParam->B3SOIPDk1eff * (T0 - 1.0) * sqrtPhi
                                   + T1 * TempRatioMinus1;
                     dDeltVthtempzb_dT = T1 / model->B3SOIPDtnom;

                     Vthzb = model->B3SOIPDtype * pParam->B3SOIPDvth0 
                           - Delt_vthzb - DeltVthwzb + pParam->B3SOIPDk3 * tmp2
                           + DeltVthtempzb;
                     dVthzb_dT = dDeltVthtempzb_dT - dDelt_vthzb_dT - dDeltVthwzb_dT;
                  }

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

		  T3 = pParam->B3SOIPDcdsc + pParam->B3SOIPDcdscb * Vbseff
		       + pParam->B3SOIPDcdscd * Vds;
		  dT3_dVb = pParam->B3SOIPDcdscb;
		  dT3_dVd = pParam->B3SOIPDcdscd;

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

		  if (T4 >= -0.5)
		  {   n = 1.0 + T4;
		      dn_dVb = dT4_dVb;