b3v1sld.c

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

          }

	  if ((here->BSIM3v1SdrainArea <= 0.0) &&
	      (here->BSIM3v1SdrainPerimeter <= 0.0))
	  {   DrainSatCurrent = 1.0e-14;
	  }
	  else
	  {   DrainSatCurrent = here->BSIM3v1SdrainArea
			      * model->BSIM3v1SjctTempSatCurDensity
			      + here->BSIM3v1SdrainPerimeter
			      * model->BSIM3v1SjctSidewallTempSatCurDensity;
	  }

	  if (DrainSatCurrent <= 0.0)
	  {   here->BSIM3v1Sgbd = ckt->CKTgmin;
              here->BSIM3v1Scbd = here->BSIM3v1Sgbd * vbd;
          }
	  else if (vbd < 0.5)
	  {   evbd = exp(vbd / Nvtm);
              here->BSIM3v1Sgbd = DrainSatCurrent * evbd / Nvtm + ckt->CKTgmin;
              here->BSIM3v1Scbd = DrainSatCurrent * (evbd - 1.0) 
                             + ckt->CKTgmin * vbd;
          }
	  else
	  {   evbd = exp(0.5 / Nvtm);
              T0 = DrainSatCurrent * evbd / Nvtm;
              here->BSIM3v1Sgbd = T0 + ckt->CKTgmin;
              here->BSIM3v1Scbd = DrainSatCurrent * (evbd - 1.0) 
			     + T0 * (vbd - 0.5) + ckt->CKTgmin * vbd;
          }
/* S/B and D/B diodes code change ends */

          if (vds >= 0.0)
	  {   /* normal mode */
              here->BSIM3v1Smode = 1;
              Vds = vds;
              Vgs = vgs;
              Vbs = vbs;
          }
	  else
	  {   /* inverse mode */
              here->BSIM3v1Smode = -1;
              Vds = -vds;
              Vgs = vgd;
              Vbs = vbd;
          }

          ChargeComputationNeeded =  
                 ((ckt->CKTmode & (MODEAC | MODETRAN | MODEINITSMSIG)) ||
                 ((ckt->CKTmode & MODETRANOP) && (ckt->CKTmode & MODEUIC)))
                 ? 1 : 0;
	  T0 = Vbs - pParam->BSIM3v1Svbsc - 0.001;
	  T1 = sqrt(T0 * T0 - 0.004 * pParam->BSIM3v1Svbsc);
	  Vbseff = pParam->BSIM3v1Svbsc + 0.5 * (T0 + T1);
	  dVbseff_dVb = 0.5 * (1.0 + T0 / T1);
	  if (Vbseff < Vbs)
	  {   Vbseff = Vbs;
	  } /* Added to avoid the possible numerical problems due to computer accuracy. See comments for diffVds */

          if (Vbseff > 0.0)
	  {   T0 = pParam->BSIM3v1Sphi / (pParam->BSIM3v1Sphi + Vbseff);
              Phis = pParam->BSIM3v1Sphi * T0;
              dPhis_dVb = -T0 * T0;
              sqrtPhis = pParam->BSIM3v1Sphis3 / (pParam->BSIM3v1Sphi + 0.5 * Vbseff);
              dsqrtPhis_dVb = -0.5 * sqrtPhis * sqrtPhis / pParam->BSIM3v1Sphis3;
          }
	  else
	  {   Phis = pParam->BSIM3v1Sphi - Vbseff;
              dPhis_dVb = -1.0;
              sqrtPhis = sqrt(Phis);
              dsqrtPhis_dVb = -0.5 / sqrtPhis; 
          }
          Xdep = pParam->BSIM3v1SXdep0 * sqrtPhis / pParam->BSIM3v1SsqrtPhi;
          dXdep_dVb = (pParam->BSIM3v1SXdep0 / pParam->BSIM3v1SsqrtPhi)
		    * dsqrtPhis_dVb;

          Leff = pParam->BSIM3v1Sleff;
          Vtm = model->BSIM3v1Svtm;
/* Vth Calculation */
          T3 = sqrt(Xdep);
          V0 = pParam->BSIM3v1Svbi - pParam->BSIM3v1Sphi;

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

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

          T0 = -0.5 * pParam->BSIM3v1Sdvt1 * Leff / lt1;
          if (T0 > -EXP_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_EXP;
              Theta0 = T1 * (1.0 + 2.0 * T1);
              dTheta0_dVb = 0.0;
          }

          here->BSIM3v1Sthetavth = pParam->BSIM3v1Sdvt0 * Theta0;
          Delt_vth = here->BSIM3v1Sthetavth * V0;
          dDelt_vth_dVb = pParam->BSIM3v1Sdvt0 * dTheta0_dVb * V0;

          T0 = -0.5 * pParam->BSIM3v1Sdvt1w * pParam->BSIM3v1Sweff * Leff / ltw;
          if (T0 > -EXP_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_EXP;
              T2 = T1 * (1.0 + 2.0 * T1);
              dT2_dVb = 0.0;
          }

          T0 = pParam->BSIM3v1Sdvt0w * T2;
          T2 = T0 * V0;
          dT2_dVb = pParam->BSIM3v1Sdvt0w * dT2_dVb * V0;

          TempRatio =  ckt->CKTtemp / model->BSIM3v1Stnom - 1.0;
          T0 = sqrt(1.0 + pParam->BSIM3v1Snlx / Leff);
          T1 = pParam->BSIM3v1Sk1 * (T0 - 1.0) * pParam->BSIM3v1SsqrtPhi
             + (pParam->BSIM3v1Skt1 + pParam->BSIM3v1Skt1l / Leff
             + pParam->BSIM3v1Skt2 * Vbseff) * TempRatio;
          tmp2 = model->BSIM3v1Stox * pParam->BSIM3v1Sphi
	       / (pParam->BSIM3v1Sweff + pParam->BSIM3v1Sw0);

	  T3 = pParam->BSIM3v1Seta0 + pParam->BSIM3v1Setab * 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;
	  }
	  else
	  {   T4 = 1.0;
	  }
	  dDIBL_Sft_dVd = T3 * pParam->BSIM3v1Stheta0vb0;
          DIBL_Sft = dDIBL_Sft_dVd * Vds;

          Vth = model->BSIM3v1Stype * pParam->BSIM3v1Svth0 + pParam->BSIM3v1Sk1 
              * (sqrtPhis - pParam->BSIM3v1SsqrtPhi) - pParam->BSIM3v1Sk2 
              * Vbseff - Delt_vth - T2 + (pParam->BSIM3v1Sk3 + pParam->BSIM3v1Sk3b
              * Vbseff) * tmp2 + T1 - DIBL_Sft;

          here->BSIM3v1Svon = Vth; 

          dVth_dVb = pParam->BSIM3v1Sk1 * dsqrtPhis_dVb - pParam->BSIM3v1Sk2
                   - dDelt_vth_dVb - dT2_dVb + pParam->BSIM3v1Sk3b * tmp2
                   - pParam->BSIM3v1Setab * Vds * pParam->BSIM3v1Stheta0vb0 * T4
                   + pParam->BSIM3v1Skt2 * TempRatio;
          dVth_dVd = -dDIBL_Sft_dVd; 

/* Calculate n */
          tmp2 = pParam->BSIM3v1Snfactor * EPSSI / Xdep;
          tmp3 = pParam->BSIM3v1Scdsc + pParam->BSIM3v1Scdscb * Vbseff
               + pParam->BSIM3v1Scdscd * Vds;
	  tmp4 = (tmp2 + tmp3 * Theta0 + pParam->BSIM3v1Scit) / model->BSIM3v1Scox;
	  if (tmp4 >= -0.5)
	  {   n = 1.0 + tmp4;
	      dn_dVb = (-tmp2 / Xdep * dXdep_dVb + tmp3 * dTheta0_dVb
                     + pParam->BSIM3v1Scdscb * Theta0) / model->BSIM3v1Scox;
              dn_dVd = pParam->BSIM3v1Scdscd * Theta0 / model->BSIM3v1Scox;
	  }
	  else
	   /* avoid  discontinuity problems caused by tmp4 */ 
	  {   T0 = 1.0 / (3.0 + 8.0 * tmp4);
	      n = (1.0 + 3.0 * tmp4) * T0;
	      T0 *= T0;
	      dn_dVb = (-tmp2 / Xdep * dXdep_dVb + tmp3 * dTheta0_dVb
                     + pParam->BSIM3v1Scdscb * Theta0) / model->BSIM3v1Scox * T0;
              dn_dVd = pParam->BSIM3v1Scdscd * Theta0 / model->BSIM3v1Scox * T0;
	  }

/* Poly Gate Si Depletion Effect */
	  T0 = pParam->BSIM3v1Svfb + pParam->BSIM3v1Sphi;
          if ((pParam->BSIM3v1Sngate > 1.e18) && (pParam->BSIM3v1Sngate < 1.e25) 
               && (Vgs > T0))
	  /* added to avoid the problem caused by ngate */
          {   T1 = 1.0e6 * Charge_q * EPSSI * pParam->BSIM3v1Sngate
                 / (model->BSIM3v1Scox * model->BSIM3v1Scox);
              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;
          }
          Vgst = Vgs_eff - Vth;

/* Effective Vgst (Vgsteff) Calculation */

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

	  /* MCJ: Very small Vgst */
          if (VgstNVt > EXP_THRESHOLD)
	  {   Vgsteff = Vgst;
              dVgsteff_dVg = dVgs_eff_dVg;
              dVgsteff_dVd = -dVth_dVd;
              dVgsteff_dVb = -dVth_dVb;
	  }
	  else if (ExpArg > EXP_THRESHOLD)
	  {   T0 = (Vgst - pParam->BSIM3v1Svoff) / (n * Vtm);
	      ExpVgst = exp(T0);
	      Vgsteff = Vtm * pParam->BSIM3v1Scdep0 / model->BSIM3v1Scox * ExpVgst;
              dVgsteff_dVg = Vgsteff / (n * Vtm);
              dVgsteff_dVd = -dVgsteff_dVg * (dVth_dVd + T0 * Vtm * dn_dVd);
              dVgsteff_dVb = -dVgsteff_dVg * (dVth_dVb + T0 * Vtm * dn_dVb);
	      dVgsteff_dVg *= dVgs_eff_dVg;
	  }
	  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;

	      dT2_dVg = -model->BSIM3v1Scox / (Vtm * pParam->BSIM3v1Scdep0)
		      * 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;

              Vgsteff = T1 / T2;
	      T3 = T2 * T2;
              dVgsteff_dVg = (T2 * dT1_dVg - T1 * dT2_dVg) / T3 * dVgs_eff_dVg;
              dVgsteff_dVd = (T2 * dT1_dVd - T1 * dT2_dVd) / T3;
              dVgsteff_dVb = (T2 * dT1_dVb - T1 * dT2_dVb) / T3;
	  }

/* Calculate Effective Channel Geometry */
          T9 = sqrtPhis - pParam->BSIM3v1SsqrtPhi;
          Weff = pParam->BSIM3v1Sweff - 2.0 * (pParam->BSIM3v1Sdwg * Vgsteff 
               + pParam->BSIM3v1Sdwb * T9); 
          dWeff_dVg = -2.0 * pParam->BSIM3v1Sdwg;
          dWeff_dVb = -2.0 * pParam->BSIM3v1Sdwb * 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->BSIM3v1Sprwg * Vgsteff + pParam->BSIM3v1Sprwb * T9;
	  if (T0 >= -0.9)
	  {   Rds = pParam->BSIM3v1Srds0 * (1.0 + T0);
	      dRds_dVg = pParam->BSIM3v1Srds0 * pParam->BSIM3v1Sprwg;
              dRds_dVb = pParam->BSIM3v1Srds0 * pParam->BSIM3v1Sprwb * dsqrtPhis_dVb;
	  }
	  else
           /* to avoid the discontinuity problem due to prwg and prwb*/
	  {   T1 = 1.0 / (17.0 + 20.0 * T0);
	      Rds = pParam->BSIM3v1Srds0 * (0.8 + T0) * T1;
	      T1 *= T1;
	      dRds_dVg = pParam->BSIM3v1Srds0 * pParam->BSIM3v1Sprwg * T1;
              dRds_dVb = pParam->BSIM3v1Srds0 * pParam->BSIM3v1Sprwb * dsqrtPhis_dVb
		       * T1;
	  }
	  
/* Calculate Abulk */
          T1 = 0.5 * pParam->BSIM3v1Sk1 / sqrtPhis;
          dT1_dVb = -T1 / sqrtPhis * dsqrtPhis_dVb;

          T9 = sqrt(pParam->BSIM3v1Sxj * Xdep);
          tmp1 = Leff + 2.0 * T9;
          T5 = Leff / tmp1; 
          tmp2 = pParam->BSIM3v1Sa0 * T5;
          tmp3 = pParam->BSIM3v1Sweff + pParam->BSIM3v1Sb1; 
          tmp4 = pParam->BSIM3v1Sb0 / tmp3;
          T2 = tmp2 + tmp4;
          dT2_dVb = -T9 / tmp1 / Xdep * dXdep_dVb;
          T6 = T5 * T5;
          T7 = T5 * T6;

          Abulk0 = 1.0 + T1 * T2; 
          dAbulk0_dVb = T1 * tmp2 * dT2_dVb + T2 * dT1_dVb;

          T8 = pParam->BSIM3v1Sags * pParam->BSIM3v1Sa0 * T7;
          dAbulk_dVg = -T1 * T8;
          Abulk = Abulk0 + dAbulk_dVg * Vgsteff; 
          dAbulk_dVb = dAbulk0_dVb - T8 * Vgsteff * (dT1_dVb
		     + 3.0 * T1 * dT2_dVb);

          if (Abulk0 < 0.1) /* added to avoid the problems caused by Abulk0 */
	  {   T9 = 1.0 / (3.0 - 20.0 * Abulk0);
	      Abulk0 = (0.2 - Abulk0) * T9;
	      dAbulk0_dVb *= T9 * T9;
	  }

          if (Abulk < 0.1)
          /* added to avoid the problems caused by Abulk */
	  {   T9 = 1.0 / (3.0 - 20.0 * Abulk);
	      Abulk = (0.2 - Abulk) * T9;
	      dAbulk_dVb *= T9 * T9;
	  }

          T2 = pParam->BSIM3v1Sketa * Vbseff;