b3ld.c

来自「ngspice又一个电子CAD仿真软件代码.功能更全」· C语言 代码 · 共 1,722 行 · 第 1/5 页

	      }
	  }
          else
          {
            SourceSatCurrent = 0.0;
            if (!here->BSIM3sourceAreaGiven)
            {   
              here->BSIM3sourceArea = 2.0 * model->BSIM3hdif * pParam->BSIM3weff;
            }
            SourceSatCurrent = here->BSIM3sourceArea * model->BSIM3jctTempSatCurDensity;
            if (!here->BSIM3sourcePerimeterGiven)
            {   
              here->BSIM3sourcePerimeter = 4.0 * model->BSIM3hdif + 2.0 * pParam->BSIM3weff;
            }
            SourceSatCurrent = SourceSatCurrent + here->BSIM3sourcePerimeter * model->BSIM3jctSidewallTempSatCurDensity;
            if (SourceSatCurrent <= 0.0) SourceSatCurrent = 1.0e-14;
          }
	  if (SourceSatCurrent <= 0.0)
	  {   here->BSIM3gbs = ckt->CKTgmin;
              here->BSIM3cbs = here->BSIM3gbs * vbs;
          }
          else
          {   if (model->BSIM3ijth == 0.0)
              {   evbs = exp(vbs / Nvtm);
                  here->BSIM3gbs = SourceSatCurrent * evbs / Nvtm + ckt->CKTgmin;
                  here->BSIM3cbs = SourceSatCurrent * (evbs - 1.0)
                                 + ckt->CKTgmin * vbs; 
              }
              else
              {   if (vbs < here->BSIM3vjsm)
                  {   evbs = exp(vbs / Nvtm);
                      here->BSIM3gbs = SourceSatCurrent * evbs / Nvtm + ckt->CKTgmin;
                      here->BSIM3cbs = SourceSatCurrent * (evbs - 1.0)
                                     + ckt->CKTgmin * vbs;
                  }
                  else
                  {   
		      /* Added revision dependent code */
		      switch (model->BSIM3intVersion) {
			case BSIM3V324:
			case BSIM3V323:
			case BSIM3V322:
			  T0 = here->BSIM3IsEvjsm / Nvtm;
			  here->BSIM3gbs = T0 + (ckt->CKTgmin);
			  here->BSIM3cbs = here->BSIM3IsEvjsm - SourceSatCurrent
			    + T0 * (vbs - here->BSIM3vjsm) + (ckt->CKTgmin) * vbs;
			  break;
			case BSIM3V32:
			default:
			  T0 = (SourceSatCurrent + model->BSIM3ijth) / Nvtm;
			  here->BSIM3gbs = T0 + (ckt->CKTgmin);
			  here->BSIM3cbs = model->BSIM3ijth + (ckt->CKTgmin) * vbs 
			    + T0 * (vbs - here->BSIM3vjsm);
		      }
                  }
              }
          }

          /* acm model */
          if (model->BSIM3acmMod == 0)
          {
            if ((here->BSIM3drainArea <= 0.0) && (here->BSIM3drainPerimeter <= 0.0))
            {   DrainSatCurrent = 1.0e-14;
            }
            else
            {   DrainSatCurrent = here->BSIM3drainArea
                                * model->BSIM3jctTempSatCurDensity
                                + here->BSIM3drainPerimeter
                                * model->BSIM3jctSidewallTempSatCurDensity;
            }
          }
          else
          {
            DrainSatCurrent = 0.0;
            if (!here->BSIM3drainAreaGiven)
            {   
              here->BSIM3drainArea = 2.0 * model->BSIM3hdif * pParam->BSIM3weff;
            }
            DrainSatCurrent = here->BSIM3drainArea * model->BSIM3jctTempSatCurDensity;
            if (!here->BSIM3drainPerimeterGiven)
            {   
              here->BSIM3drainPerimeter = 4.0 * model->BSIM3hdif + 2.0 * pParam->BSIM3weff;
            }
            DrainSatCurrent = DrainSatCurrent + here->BSIM3drainPerimeter * model->BSIM3jctSidewallTempSatCurDensity;
            if (DrainSatCurrent <= 0.0) DrainSatCurrent = 1.0e-14;
          }
	  if (DrainSatCurrent <= 0.0)
	  {   here->BSIM3gbd = ckt->CKTgmin;
              here->BSIM3cbd = here->BSIM3gbd * vbd;
          }
          else
          {   if (model->BSIM3ijth == 0.0)
              {   evbd = exp(vbd / Nvtm);
                  here->BSIM3gbd = DrainSatCurrent * evbd / Nvtm + ckt->CKTgmin;
                  here->BSIM3cbd = DrainSatCurrent * (evbd - 1.0)
                                 + ckt->CKTgmin * vbd;
              }
              else
              {   if (vbd < here->BSIM3vjdm)
                  {   evbd = exp(vbd / Nvtm);
                      here->BSIM3gbd = DrainSatCurrent * evbd / Nvtm + ckt->CKTgmin;
                      here->BSIM3cbd = DrainSatCurrent * (evbd - 1.0)
                                     + ckt->CKTgmin * vbd;
                  }
                  else
                  {   
		      /* Added revision dependent code */
		      switch (model->BSIM3intVersion) {
			case BSIM3V324:
			case BSIM3V323:
			case BSIM3V322:
			  T0 = here->BSIM3IsEvjdm / Nvtm;
			  here->BSIM3gbd = T0 + (ckt->CKTgmin);
			  here->BSIM3cbd = here->BSIM3IsEvjdm - DrainSatCurrent
			    + T0 * (vbd - here->BSIM3vjdm) + (ckt->CKTgmin) * vbd;
			  break;
			case BSIM3V32:
			default:
			  T0 = (DrainSatCurrent + model->BSIM3ijth) / Nvtm;
			  here->BSIM3gbd = T0 + (ckt->CKTgmin);
			  here->BSIM3cbd = model->BSIM3ijth + (ckt->CKTgmin) * vbd
			    + T0 * (vbd - here->BSIM3vjdm);
		      }
                  }
              }
          }
          /* End of diode DC model */

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

	  T0 = Vbs - pParam->BSIM3vbsc - 0.001;
	  T1 = sqrt(T0 * T0 - 0.004 * pParam->BSIM3vbsc);
	  Vbseff = pParam->BSIM3vbsc + 0.5 * (T0 + T1);
	  dVbseff_dVb = 0.5 * (1.0 + T0 / T1);
          if (Vbseff < Vbs)
          {   Vbseff = Vbs;
          }

          if (Vbseff > 0.0)
	  {   T0 = pParam->BSIM3phi / (pParam->BSIM3phi + Vbseff);
              Phis = pParam->BSIM3phi * T0;
              dPhis_dVb = -T0 * T0;
              sqrtPhis = pParam->BSIM3phis3 / (pParam->BSIM3phi + 0.5 * Vbseff);
              dsqrtPhis_dVb = -0.5 * sqrtPhis * sqrtPhis / pParam->BSIM3phis3;
          }
	  else
	  {   Phis = pParam->BSIM3phi - Vbseff;
              dPhis_dVb = -1.0;
              sqrtPhis = sqrt(Phis);
              dsqrtPhis_dVb = -0.5 / sqrtPhis; 
          }
          Xdep = pParam->BSIM3Xdep0 * sqrtPhis / pParam->BSIM3sqrtPhi;
          dXdep_dVb = (pParam->BSIM3Xdep0 / pParam->BSIM3sqrtPhi)
		    * dsqrtPhis_dVb;

          Leff = pParam->BSIM3leff;
          Vtm = model->BSIM3vtm;
/* Vth Calculation */
          T3 = sqrt(Xdep);
          V0 = pParam->BSIM3vbi - pParam->BSIM3phi;

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

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

          T0 = -0.5 * pParam->BSIM3dvt1 * 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->BSIM3thetavth = pParam->BSIM3dvt0 * Theta0;
          Delt_vth = here->BSIM3thetavth * V0;
          dDelt_vth_dVb = pParam->BSIM3dvt0 * dTheta0_dVb * V0;

          T0 = -0.5 * pParam->BSIM3dvt1w * pParam->BSIM3weff * 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->BSIM3dvt0w * T2;
          T2 = T0 * V0;
          dT2_dVb = pParam->BSIM3dvt0w * dT2_dVb * V0;

          TempRatio =  ckt->CKTtemp / model->BSIM3tnom - 1.0;
          T0 = sqrt(1.0 + pParam->BSIM3nlx / Leff);
          T1 = pParam->BSIM3k1ox * (T0 - 1.0) * pParam->BSIM3sqrtPhi
             + (pParam->BSIM3kt1 + pParam->BSIM3kt1l / Leff
             + pParam->BSIM3kt2 * Vbseff) * TempRatio;
          tmp2 = model->BSIM3tox * pParam->BSIM3phi
	       / (pParam->BSIM3weff + pParam->BSIM3w0);

	  T3 = pParam->BSIM3eta0 + pParam->BSIM3etab * 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->BSIM3theta0vb0;
          DIBL_Sft = dDIBL_Sft_dVd * Vds;

          Vth = model->BSIM3type * pParam->BSIM3vth0 - pParam->BSIM3k1
              * pParam->BSIM3sqrtPhi + pParam->BSIM3k1ox * sqrtPhis
              - pParam->BSIM3k2ox * Vbseff - Delt_vth - T2 + (pParam->BSIM3k3
              + pParam->BSIM3k3b * Vbseff) * tmp2 + T1 - DIBL_Sft;

          here->BSIM3von = Vth; 

          dVth_dVb = pParam->BSIM3k1ox * dsqrtPhis_dVb - pParam->BSIM3k2ox
                   - dDelt_vth_dVb - dT2_dVb + pParam->BSIM3k3b * tmp2
                   - pParam->BSIM3etab * Vds * pParam->BSIM3theta0vb0 * T4
                   + pParam->BSIM3kt2 * TempRatio;
          dVth_dVd = -dDIBL_Sft_dVd;

/* Calculate n */
          tmp2 = pParam->BSIM3nfactor * EPSSI / Xdep;
          tmp3 = pParam->BSIM3cdsc + pParam->BSIM3cdscb * Vbseff
               + pParam->BSIM3cdscd * Vds;
	  tmp4 = (tmp2 + tmp3 * Theta0 + pParam->BSIM3cit) / model->BSIM3cox;
	  if (tmp4 >= -0.5)
	  {   n = 1.0 + tmp4;
	      dn_dVb = (-tmp2 / Xdep * dXdep_dVb + tmp3 * dTheta0_dVb
                     + pParam->BSIM3cdscb * Theta0) / model->BSIM3cox;
              dn_dVd = pParam->BSIM3cdscd * Theta0 / model->BSIM3cox;
	  }
	  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->BSIM3cdscb * Theta0) / model->BSIM3cox * T0;
              dn_dVd = pParam->BSIM3cdscd * Theta0 / model->BSIM3cox * T0;
	  }

/* Poly Gate Si Depletion Effect */
	  T0 = pParam->BSIM3vfb + pParam->BSIM3phi;
          if ((pParam->BSIM3ngate > 1.e18) && (pParam->BSIM3ngate < 1.e25) 
               && (Vgs > T0))
	  /* added to avoid the problem caused by ngate */
          {   T1 = 1.0e6 * Charge_q * EPSSI * pParam->BSIM3ngate
                 / (model->BSIM3cox * model->BSIM3cox);
              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->BSIM3voff - 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->BSIM3voff) / (n * Vtm);
	      ExpVgst = exp(T0);
	      Vgsteff = Vtm * pParam->BSIM3cdep0 / model->BSIM3cox * 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->BSIM3cox / (Vtm * pParam->BSIM3cdep0)
		      * exp(ExpArg);
              T2 = 1.0 - T10 * dT2_dVg;
              dT2_dVd = -dT2_dVg * (dVth_dVd - 2.0 * Vtm * ExpArg * dn_dVd)