b3v0ld.c

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

	  else if (vbd <= -0.5)
	  {   here->BSIM3v0gbd = ckt->CKTgmin;
              here->BSIM3v0cbd = -DrainSatCurrent + here->BSIM3v0gbd * vbd;
          }
	  else if (vbd < 0.5)
	  {   evbd = exp(vbd/CONSTvt0);
              here->BSIM3v0gbd = DrainSatCurrent * evbd / CONSTvt0 
                             + ckt->CKTgmin;
              here->BSIM3v0cbd = DrainSatCurrent * (evbd - 1.0) 
                             + ckt->CKTgmin * vbd;
          }
	  else
	  {   evbd = exp(0.5/CONSTvt0);
              here->BSIM3v0gbd = DrainSatCurrent * evbd / CONSTvt0 
                             + ckt->CKTgmin;
              here->BSIM3v0cbd = DrainSatCurrent * (evbd - 1.0) 
                             + ckt->CKTgmin * 0.5;
          }

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

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

	  T0 = Vbs - pParam->BSIM3v0vbsc - 0.001;
	  T1 = sqrt(T0 * T0 - 0.004 * pParam->BSIM3v0vbsc);
	  Vbseff = pParam->BSIM3v0vbsc + 0.5 * (T0 + T1);
	  dVbseff_dVb = 0.5 * (1.0 + T0 / T1);

          if (Vbseff > 0.0)
	  {   T0 = pParam->BSIM3v0phi / (pParam->BSIM3v0phi + Vbseff);
              Phis = pParam->BSIM3v0phi * T0;
              dPhis_dVb = -T0 * T0;
              sqrtPhis = pParam->BSIM3v0phis3 / (pParam->BSIM3v0phi + 0.5 * Vbseff);
              dsqrtPhis_dVb = -0.5 * sqrtPhis * sqrtPhis / pParam->BSIM3v0phis3;
          }
	  else
	  {   Phis = pParam->BSIM3v0phi - Vbseff;
              dPhis_dVb = -1.0;
              sqrtPhis = sqrt(Phis);
              dsqrtPhis_dVb = -0.5 / sqrtPhis; 
          }
          Xdep = pParam->BSIM3v0Xdep0 * sqrtPhis / pParam->BSIM3v0sqrtPhi;
          dXdep_dVb = (pParam->BSIM3v0Xdep0 / pParam->BSIM3v0sqrtPhi)
		    * dsqrtPhis_dVb;

          Leff = pParam->BSIM3v0leff;
/* Vth Calculation */
          if ((T1 = 1.0 + pParam->BSIM3v0dvt2 * Vbseff) < 1.0e-10)
	      T1 = 1.0E-10;
          if ((T2 = 1.0 + pParam->BSIM3v0dvt2w * Vbseff) < 1.0E-10)
	      T2 = 1.0E-10;

          T3 = sqrt(Xdep);
          lt1 = model->BSIM3v0factor1 * T3 * T1;
          dlt1_dVb = model->BSIM3v0factor1 * (0.5 / T3 * T1 * dXdep_dVb
                   + T3 * pParam->BSIM3v0dvt2);

          ltw = model->BSIM3v0factor1 * T3 * T2;
          dltw_dVb = model->BSIM3v0factor1 * (0.5 / T3 * T2 * dXdep_dVb
                   + T3 * pParam->BSIM3v0dvt2w);

          T0 = -0.5 * pParam->BSIM3v0dvt1 * Leff / lt1;
          if (T0 > -EXP_THRESHOLD)
          {   T1 = exp(T0);
              dT1_dVb = -T0 / lt1 * T1 * dlt1_dVb;
          }
          else
          {   T1 = MIN_EXP;
              dT1_dVb = 0.0;
          }

          Theta0 = T1 * (1.0 + 2.0 * T1);
          dTheta0_dVb = (1.0 + 4.0 * T1) * dT1_dVb;

          here->BSIM3v0thetavth = pParam->BSIM3v0dvt0 * Theta0;
          T0 = pParam->BSIM3v0vbi - pParam->BSIM3v0phi;
          Delt_vth = here->BSIM3v0thetavth * T0;
          dDelt_vth_dVb = pParam->BSIM3v0dvt0 * dTheta0_dVb * T0;

          T0 = -0.5 * pParam->BSIM3v0dvt1w * pParam->BSIM3v0weff * Leff / ltw;
          if (T0 > -EXP_THRESHOLD)
          {   T1 = exp(T0);
              dT1_dVb = -T0 / ltw * T1 * dltw_dVb;
          }
          else
          {   T1 = MIN_EXP;
              dT1_dVb = 0.0;
          }

          T2 = T1 * (1.0 + 2.0 * T1);
          dT2_dVb = (1.0 + 4.0 * T1) * dT1_dVb;

          T0 = pParam->BSIM3v0dvt0w * T2;
          T1 = pParam->BSIM3v0vbi - pParam->BSIM3v0phi;
          T2 = T0 * T1;
          dT2_dVb = pParam->BSIM3v0dvt0w * dT2_dVb * T1;

          TempRatio =  ckt->CKTtemp / model->BSIM3v0tnom - 1.0;
          T0 = sqrt(1.0 + pParam->BSIM3v0nlx / Leff);
          T1 = pParam->BSIM3v0k1 * (T0 - 1.0) * pParam->BSIM3v0sqrtPhi
             + (pParam->BSIM3v0kt1 + pParam->BSIM3v0kt1l / Leff
             + pParam->BSIM3v0kt2 * Vbseff) * TempRatio;
          tmp2 = model->BSIM3v0tox / (pParam->BSIM3v0weff
	       + pParam->BSIM3v0w0) * pParam->BSIM3v0phi;

          dDIBL_Sft_dVd = (pParam->BSIM3v0eta0 + pParam->BSIM3v0etab
                        * Vbseff) * pParam->BSIM3v0theta0vb0;
          DIBL_Sft = dDIBL_Sft_dVd * Vds;

          Vth = model->BSIM3v0type * pParam->BSIM3v0vth0 + pParam->BSIM3v0k1 
              * (sqrtPhis - pParam->BSIM3v0sqrtPhi) - pParam->BSIM3v0k2 
              * Vbseff - Delt_vth - T2 + (pParam->BSIM3v0k3 + pParam->BSIM3v0k3b
              * Vbseff) * tmp2 + T1 - DIBL_Sft;

          here->BSIM3v0von = Vth; 

          dVth_dVb = pParam->BSIM3v0k1 * dsqrtPhis_dVb - pParam->BSIM3v0k2
                   - dDelt_vth_dVb - dT2_dVb + pParam->BSIM3v0k3b * tmp2
                   - pParam->BSIM3v0etab * Vds * pParam->BSIM3v0theta0vb0
                   + pParam->BSIM3v0kt2 * TempRatio;
          dVth_dVd = -dDIBL_Sft_dVd; 

/* Calculate n */
          tmp2 = pParam->BSIM3v0nfactor * EPSSI / Xdep;
          tmp3 = pParam->BSIM3v0cdsc + pParam->BSIM3v0cdscb * Vbseff
               + pParam->BSIM3v0cdscd * Vds;
	  n = 1.0 + (tmp2 + tmp3 * Theta0 + pParam->BSIM3v0cit) / model->BSIM3v0cox;
	  if (n > 1.0)
	  {   dn_dVb = (-tmp2 / Xdep * dXdep_dVb + tmp3 * dTheta0_dVb
                     + pParam->BSIM3v0cdscb * Theta0) / model->BSIM3v0cox;  
              dn_dVd = pParam->BSIM3v0cdscd * Theta0 / model->BSIM3v0cox;            
	  }
	  else
	  {   n = 1.0;
	      dn_dVb = dn_dVd = 0.0;  
	  }

/* Poly Gate Si Depletion Effect */
	  T0 = pParam->BSIM3v0vfb + pParam->BSIM3v0phi;
          if (model->BSIM3v0ngateGiven && (Vgs > T0))
	  {   T1 = 1.0e6 * Charge_q * EPSSI * pParam->BSIM3v0ngate
                 / (model->BSIM3v0cox * model->BSIM3v0cox);
              T4 = sqrt(1.0 + 2.0 * (Vgs - T0) / T1);
              T2 = T1 * (T4 - 1.0);
              T3 = 0.5 * T2 * T2 / T1;

              if (T3 < 1.12)
	      {   Vgs_eff = T0 + T2;
                  dVgs_eff_dVg = 1.0 / T4;
              }
	      else
	      {   Vgs_eff = Vgs - 1.12;
                  dVgs_eff_dVg = 1.0;
              }
          }
	  else
	  {   Vgs_eff = Vgs;
              dVgs_eff_dVg = 1.0;
          }
          Vgst = Vgs_eff - Vth;

/* Effective Vgst (Vgsteff) Calculation */
          Vtm = model->BSIM3v0vtm;

          T10 = 2.0 * n * Vtm;
          VgstNVt = Vgst / T10;
          if (VgstNVt < -EXP_THRESHOLD) 
	  {   T1 = T10 * MIN_EXP; 
	      dT1_dVg = dT1_dVd = dT1_dVb = 0.0;
	  }
          else if (VgstNVt > EXP_THRESHOLD)
	  {   T1 = Vgst;
              dT1_dVg = dVgs_eff_dVg;
              dT1_dVd = -dVth_dVd;
              dT1_dVb = -dVth_dVb;
          }
	  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;
	      dT1_dVg *= dVgs_eff_dVg;
          }

	  T2 = model->BSIM3v0tox / (pParam->BSIM3v0weff + pParam->BSIM3v0w0);
          ExpArg = (2.0 * pParam->BSIM3v0voff - Vgst) / T10;
          if (ExpArg < -EXP_THRESHOLD)
	  {   T2 = 1.0;
              dT2_dVg = dT2_dVd = dT2_dVb = 0.0;

          }
	  else if (ExpArg > EXP_THRESHOLD)
	  {   T2 = 1.0 + 2.0 * n * model->BSIM3v0cox / pParam->BSIM3v0cdep0
		 * MAX_EXP;
              dT2_dVg = dT2_dVd = dT2_dVb = 0.0;
          }
	  else
	  {   dT2_dVg = -model->BSIM3v0cox / Vtm / pParam->BSIM3v0cdep0
		      * 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;
	      dT2_dVg *= dVgs_eff_dVg;
          }

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

/* Calculate Effective Channel Geometry */
          Weff = pParam->BSIM3v0weff - 2.0 * (pParam->BSIM3v0dwg * Vgsteff 
               + pParam->BSIM3v0dwb * (sqrtPhis - pParam->BSIM3v0sqrtPhi)); 
          dWeff_dVg = -2.0 * pParam->BSIM3v0dwg;
          dWeff_dVb = -2.0 * pParam->BSIM3v0dwb * dsqrtPhis_dVb;

          if (Weff < 1.0e-8)
	  {   Weff = 1.0e-8;
              dWeff_dVg = dWeff_dVb = 0;
          }

          Rds = pParam->BSIM3v0rds0 * (1.0 + pParam->BSIM3v0prwg * Vgsteff 
              + pParam->BSIM3v0prwb * (sqrtPhis - pParam->BSIM3v0sqrtPhi));
	  if (Rds > 0.0)
	  {   dRds_dVg = pParam->BSIM3v0rds0 * pParam->BSIM3v0prwg;
              dRds_dVb = pParam->BSIM3v0rds0 * pParam->BSIM3v0prwb * dsqrtPhis_dVb;
	  }
	  else
	  {   Rds = dRds_dVg = dRds_dVb = 0.0;
	  }
	  
          WVCox = Weff * pParam->BSIM3v0vsattemp * model->BSIM3v0cox;
          WVCoxRds = WVCox * Rds; 

/* Calculate Abulk */
          T0 = 1.0 / (1.0 + pParam->BSIM3v0keta * Vbseff);
          dT0_dVb = -pParam->BSIM3v0keta * T0 * T0;

          T1 = 0.5 * pParam->BSIM3v0k1 / sqrtPhis;
          dT1_dVb = -T1 / sqrtPhis * dsqrtPhis_dVb;

          tmp1 = Leff + 2.0 * sqrt(pParam->BSIM3v0xj * Xdep);
          T5 = Leff / tmp1; 
          tmp2 = pParam->BSIM3v0a0 *T5;
          tmp3 = pParam->BSIM3v0weff + pParam->BSIM3v0b1; 
          tmp4 = pParam->BSIM3v0b0 / tmp3;
          T2 = tmp2 + tmp4;
          dT2_dVb = -tmp2 / tmp1 * sqrt(pParam->BSIM3v0xj / Xdep) * dXdep_dVb;
          T6 = T5 * T5;
          T7 = T5 * T6;
          Abulk0 = T0 * (1.0 + T1 * T2); 
                   if (Abulk0 < 0.01)
                      Abulk0= 0.01; 
          T8 = pParam->BSIM3v0ags * pParam->BSIM3v0a0 * T7;
          dAbulk_dVg = -T1 * T0 * T8;
          Abulk = Abulk0 + dAbulk_dVg * Vgsteff; 
                   if (Abulk < 0.01)
                        Abulk= 0.01;
                      
          dAbulk0_dVb = T0 * T1 * dT2_dVb + T0 * T2 * dT1_dVb   
               	      + (1.0 + T1 * T2) * dT0_dVb;
          dAbulk_dVb = dAbulk0_dVb - T8 * Vgsteff * (T1 * (3.0 * T0 * dT2_dVb
		     / tmp2 + dT0_dVb) + T0 * dT1_dVb); 
/* Mobility calculation */

          if (model->BSIM3v0mobMod == 1)
	  {   T0 = Vgsteff + Vth + Vth;
              T2 = pParam->BSIM3v0ua + pParam->BSIM3v0uc * Vbseff;
              T3 = T0 / model->BSIM3v0tox;
              Denomi = 1.0 + T3 * (T2
                     + pParam->BSIM3v0ub * T3);
              T1 = T2 / model->BSIM3v0tox + 2.0 * pParam->BSIM3v0ub * T3
                 / model->BSIM3v0tox;
              dDenomi_dVg = T1;
              dDenomi_dVd = T1 * 2.0 * dVth_dVd;
              dDenomi_dVb = T1 * 2.0 * dVth_dVb + pParam->BSIM3v0uc * T3;
          }
	  else if (model->BSIM3v0mobMod == 2)
	  {   Denomi = 1.0 + Vgsteff / model->BSIM3v0tox * (pParam->BSIM3v0ua
		     + pParam->BSIM3v0uc * Vbseff + pParam->BSIM3v0ub * Vgsteff
                     / model->BSIM3v0tox);
              T1 = (pParam->BSIM3v0ua + pParam->BSIM3v0uc * Vbseff) / model->BSIM3v0tox
                 + 2.0 * pParam->BSIM3v0ub / (model->BSIM3v0tox * model->BSIM3v0tox)
		 * Vgsteff;
              dDenomi_dVg = T1;
              dDenomi_dVd = 0.0;
              dDenomi_dVb = Vgsteff * pParam->BSIM3v0uc / model->BSIM3v0tox; 
          }
	  else
	  {   T0 = Vgsteff + Vth + Vth;
              T2 = 1.0 + pParam->BSIM3v0uc * Vbseff;
              T3 = T0 / model->BSIM3v0tox;
              T4 = T3 * (pParam->BSIM3v0ua + pParam->BSIM3v0ub * T3);
              Denomi = 1.0 + T4 * T2;

              T1 = (pParam->BSIM3v0ua / model->BSIM3v0tox + 2.0 * pParam->BSIM3v0ub
		 * T3 / model->BSIM3v0tox) * T2;
              dDenomi_dVg = T1;
              dDenomi_dVd = T1 * 2.0 * dVth_dVd;
              dDenomi_dVb = T1 * 2.0 * dVth_dVb + pParam->BSIM3v0uc * T4;
          }

          here->BSIM3v0ueff = ueff = pParam->BSIM3v0u0temp / Denomi;
          dueff_dVg = -ueff / Denomi * dDenomi_dVg;
          dueff_dVd = -ueff / Denomi * dDenomi_dVd;
          dueff_dVb = -ueff / Denomi * dDenomi_dVb;


/* Saturation Drain Voltage  Vdsat */
          Esat = 2.0 * pParam->BSIM3v0vsattemp / ueff;