b3soild.c

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

		      if (pParam->B3SOInsub > 0) {
                         T0 = log(pParam->B3SOInpeak / pParam->B3SOInsub);
		         vfbb = -model->B3SOItype * Vtm * T0;
                         dvfbb_dT = -model->B3SOItype * KboQ * T0;
                      } 
		      else {
                         T0 = log(-pParam->B3SOInpeak * pParam->B3SOInsub / ni / ni);
		         vfbb = -model->B3SOItype * Vtm * T0;
                         dvfbb_dT = -model->B3SOItype *
                                   (KboQ * T0 - Vtm * 2.0 * dni_dT / ni);
                      }

/*		      phi = 2.0 * Vtm * log(pParam->B3SOInpeak / ni);  */
		      phi = here->B3SOIphi;
		      sqrtPhi = sqrt(phi);
		      Xdep0 = sqrt(2.0 * EPSSI / (Charge_q
				         * pParam->B3SOInpeak * 1.0e6))
				         * sqrtPhi;
		      /*  Save the values below for phi calculation in B3SOIaccept()  */
		      here->B3SOIvtm = Vtm;
		      here->B3SOIni = ni;

                      T3 = TempRatio - 1.0;
                      T8 = 1/ model->B3SOItnom;
                      T4 = Eg300 / Vtm * T3;
                      dT4_dT = Eg300 / Vtm / Vtm * (Vtm * T8 - T3 * KboQ);

                      T7 = model->B3SOIxbjt * T4 / pParam->B3SOIndiode;
                      dT7_dT = model->B3SOIxbjt * dT4_dT / pParam->B3SOIndiode;
                      DEXP(T7, T0, dT0_dT7);
                      dT0_dT = dT0_dT7 * dT7_dT;
 
                      if (model->B3SOIxbjt == model->B3SOIxdif) {
                         T1 = T0;
                         dT1_dT = dT0_dT;
                      } 
                      else {
                         T7 = model->B3SOIxdif * T4 / pParam->B3SOIndiode;
                         dT7_dT = model->B3SOIxdif * dT4_dT / pParam->B3SOIndiode;
                         DEXP(T7, T1, dT1_dT7);
                         dT1_dT = dT1_dT7 * dT7_dT;
                      }

                      T7 = model->B3SOIxrec * T4 / pParam->B3SOInrecf0;
                      dT7_dT = model->B3SOIxrec * dT4_dT / pParam->B3SOInrecf0;
                      DEXP(T7, T2, dT2_dT7);
                      dT2_dT = dT2_dT7 * dT7_dT;
 
                      /* high level injection */
                      Ahli = pParam->B3SOIahli * T0;
                      dAhli_dT = pParam->B3SOIahli * dT0_dT;
 
                      jbjt = pParam->B3SOIisbjt * T0;
                      jdif = pParam->B3SOIisdif * T1;
                      jrec = pParam->B3SOIisrec * T2;
                      djbjt_dT = pParam->B3SOIisbjt * dT0_dT;
                      djdif_dT = pParam->B3SOIisdif * dT1_dT;
                      djrec_dT = pParam->B3SOIisrec * dT2_dT;
 
                      T7 = model->B3SOIxtun * T3;
                      dT7_dT = model->B3SOIxtun * T8;
                      DEXP(T7, T0, dT0_dT7);
                      dT0_dT = dT0_dT7 * dT7_dT;
                      jtun = pParam->B3SOIistun * T0;
                      djtun_dT = pParam->B3SOIistun * dT0_dT;

		      u0temp = pParam->B3SOIu0 * pow(TempRatio, pParam->B3SOIute);
                      du0temp_dT = pParam->B3SOIu0 * pParam->B3SOIute *
                                   pow(TempRatio, pParam->B3SOIute - 1.0) * T8;

		      vsattemp = pParam->B3SOIvsat - pParam->B3SOIat * T3;
                      dvsattemp_dT = -pParam->B3SOIat * T8;

		      rds0 = (pParam->B3SOIrdsw + pParam->B3SOIprt
		          * T3) / pParam->B3SOIrds0denom;
                      drds0_dT = pParam->B3SOIprt / pParam->B3SOIrds0denom * T8;

		      ua = pParam->B3SOIuatemp + pParam->B3SOIua1 * T3;
		      ub = pParam->B3SOIubtemp + pParam->B3SOIub1 * T3;
		      uc = pParam->B3SOIuctemp + pParam->B3SOIuc1 * T3;
                      dua_dT = pParam->B3SOIua1 * T8;
                      dub_dT = pParam->B3SOIub1 * T8;
                      duc_dT = pParam->B3SOIuc1 * T8;
		  }
		  else {
                      vbi = pParam->B3SOIvbi;
                      vfbb = pParam->B3SOIvfbb;
                      phi = pParam->B3SOIphi;
                      sqrtPhi = pParam->B3SOIsqrtPhi;
                      Xdep0 = pParam->B3SOIXdep0;
                      jbjt = pParam->B3SOIjbjt;
                      jdif = pParam->B3SOIjdif;
                      jrec = pParam->B3SOIjrec;
                      jtun = pParam->B3SOIjtun;

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

                      u0temp = pParam->B3SOIu0temp;
                      vsattemp = pParam->B3SOIvsattemp;
                      rds0 = pParam->B3SOIrds0;
                      ua = pParam->B3SOIua;
                      ub = pParam->B3SOIub;
                      uc = pParam->B3SOIuc;
                      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->B3SOItnom - 1.0;
		  }
		  else {
		      TempRatioMinus1 =  ckt->CKTtemp / model->B3SOItnom - 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->B3SOImode = 1;
		      Vds = vds;
		      Vgs = vgs;
		      Vbs = vbs;
		      Vbd = vbd;
		      Ves = ves;
		      Vps = vps;

                      wdios = pParam->B3SOIwdios;
                      wdiod = pParam->B3SOIwdiod;
                      wdiosCV = pParam->B3SOIwdiosCV;
                      wdiodCV = pParam->B3SOIwdiodCV;

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

                      wdios = pParam->B3SOIwdiod;
                      wdiod = pParam->B3SOIwdios;
                      wdiosCV = pParam->B3SOIwdiodCV;
                      wdiodCV = pParam->B3SOIwdiosCV;

		  }

		  Vesfb = Ves - vfbb;
		  Cbox = model->B3SOIcbox;
		  K1 = pParam->B3SOIk1eff;

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

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



/* Poly Gate Si Depletion Effect */
		  T0 = pParam->B3SOIvfb + phi;
		  if ((pParam->B3SOIngate > 1.e18) && (pParam->B3SOIngate < 1.e25) 
		       && (Vgs > T0))
		  /* added to avoid the problem caused by ngate */
		  {   T1 = 1.0e6 * Charge_q * EPSSI * pParam->B3SOIngate
			 / (model->B3SOIcox * model->B3SOIcox);
		      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->B3SOIleff;

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

		  V0 = vbi - phi;


/* begin of v3.0 block addition */
/* B/S built-in potential lowering calculation */
                  if (model->B3SOIsoiMod == 0) /* BSIMPD */
                  {

                     Vbsmos = Vbs;
                     dVbsmos_dVg = 0.0;
                     dVbsmos_dVd = 0.0;
                     dVbsmos_dVb = 1.0;
                     dVbsmos_dVe = 0.0;
                     if (selfheat)  dVbsmos_dT = 0.0;
                     else  dVbsmos_dT = 0.0;

                     Vbp = Vbs - Vps;
                     dVbp_dVb = 1;
                  }
                  else /* soiMod=1: adding FD module on top of BSIMPD */
                  {
                     /* prepare Vbs0 & Vbs0mos for VthFD calculation */
                     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 = phi - T3 + model->B3SOIvbsa + T2;
                     if (selfheat)
                        dVbs0t_dT = T1 * dvbi_dT;
                     else
                        dVbs0t_dT = 0.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;
                     T4 = 1.0/(1 + Cbox / model->B3SOIcsi);
                     Vbs0 = T4 * Vbs0t + T2;
                     dVbs0_dVe = T1;
                     if (selfheat)
                        dVbs0_dT = T4 * dVbs0t_dT - T1 * dvfbb_dT;
                     else
                        dVbs0_dT = 0.0;

                   
                     /* zero field body potential cal. */
                     T1 = Vbs0t - Vbs0 - 0.005;
                     T2 = sqrt(T1 * T1 + (2.5e-5));
                     T3 = 0.5 * (T1 + T2);
                     T4 = T3 * model->B3SOIcsi / model->B3SOIqsi;
                     Vbs0mos = Vbs0 - 0.5 * T3 * T4;
                     T5 = 0.5 * T4 * (1 + T1 / T2);
                     dVbs0mos_dVe = dVbs0_dVe * (1 + T5);
                     if (selfheat)
                        dVbs0mos_dT = dVbs0_dT * (1 + T5) - T5 * dVbs0t_dT;
                     else
                        dVbs0mos_dT = 0.0;


                     /* set the upperbound of Vbs0mos to be phi for square root calc. */
                     T1 = phi - 0.02;
                     T2 = T1 - Vbs0mos - 0.005;
                     T3 = sqrt(T2 * T2 + 4.0 * 0.005);
                     Vbs0mos = T1 - 0.5 * (T2 + T3);
                     T4 = 0.5 * (1 + T2 / T3);
                     dVbs0mos_dVe = T4 * dVbs0mos_dVe;
                     if (selfheat)
                        dVbs0mos_dT = T4 * dVbs0mos_dT;
                     else  dVbs0mos_dT = 0.0;


                     /* VthFD calculation */
                     Phis = phi - Vbs0mos;
                     dPhis_dVb = -1; /* w.r.t Vbs0mos */
                     sqrtPhis = sqrt(Phis);
                     dsqrtPhis_dVb = -0.5 / sqrtPhis;
                     Xdep = Xdep0 * sqrtPhis / sqrtPhi;
                     dXdep_dVb = (Xdep0 / sqrtPhi) * dsqrtPhis_dVb;
                     T3 = sqrt(Xdep);

                     T0 = pParam->B3SOIdvt2 * Vbs0mos;
                     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 * Vbs0mos;
                     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;
                     }