b4ld.c

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

                       vsbd = DEVpnjlim(vsbd, vsbdo, CONSTvt0, model->BSIM4vcrit, &Check2);
                       vsbs = vsbd + vds;
                       if ((Check1 == 0) && (Check2 == 0))
                           Check = 0;
                       else
                           Check = 1;
                   }
               }
          }

          /* Calculate DC currents and their derivatives */
          vbd = vbs - vds;
          vgd = vgs - vds;
          vgb = vgs - vbs;
	  vged = vges - vds;
	  vgmd = vgms - vds;
	  vgmb = vgms - vbs;
          vdbd = vdbs - vds;

          vbs_jct = (!here->BSIM4rbodyMod) ? vbs : vsbs;
          vbd_jct = (!here->BSIM4rbodyMod) ? vbd : vdbd;

          /* Source/drain junction diode DC model begins */
          Nvtms = model->BSIM4vtm * model->BSIM4SjctEmissionCoeff;
	  if ((here->BSIM4Aseff <= 0.0) && (here->BSIM4Pseff <= 0.0))
	  {   SourceSatCurrent = 1.0e-14;
	  }
          else
          {   SourceSatCurrent = here->BSIM4Aseff * model->BSIM4SjctTempSatCurDensity
                               + here->BSIM4Pseff * model->BSIM4SjctSidewallTempSatCurDensity
                               + pParam->BSIM4weffCJ * here->BSIM4nf
                               * model->BSIM4SjctGateSidewallTempSatCurDensity;
          }

	  if (SourceSatCurrent <= 0.0)
	  {   here->BSIM4gbs = ckt->CKTgmin;
              here->BSIM4cbs = here->BSIM4gbs * vbs_jct;
          }
          else
	  {   switch(model->BSIM4dioMod)
              {   case 0:
                      evbs = exp(vbs_jct / Nvtms);
                      T1 = model->BSIM4xjbvs * exp(-(model->BSIM4bvs + vbs_jct) / Nvtms);
		      /* WDLiu: Magic T1 in this form; different from BSIM4 beta. */
		      here->BSIM4gbs = SourceSatCurrent * (evbs + T1) / Nvtms + ckt->CKTgmin;
		      here->BSIM4cbs = SourceSatCurrent * (evbs + here->BSIM4XExpBVS
				     - T1 - 1.0) + ckt->CKTgmin * vbs_jct;
		      break;
                  case 1:
		      T2 = vbs_jct / Nvtms;
	              if (T2 < -EXP_THRESHOLD)
		      {   here->BSIM4gbs = ckt->CKTgmin;
                          here->BSIM4cbs = SourceSatCurrent * (MIN_EXP - 1.0)
                                         + ckt->CKTgmin * vbs_jct;
                      }
		      else if (vbs_jct <= here->BSIM4vjsmFwd)
		      {   evbs = exp(T2);
			  here->BSIM4gbs = SourceSatCurrent * evbs / Nvtms + ckt->CKTgmin;
                          here->BSIM4cbs = SourceSatCurrent * (evbs - 1.0)
                                         + ckt->CKTgmin * vbs_jct;
	              }
		      else
		      {   T0 = here->BSIM4IVjsmFwd / Nvtms;
                          here->BSIM4gbs = T0 + ckt->CKTgmin;
                          here->BSIM4cbs = here->BSIM4IVjsmFwd - SourceSatCurrent + T0 
					 * (vbs_jct - here->BSIM4vjsmFwd) + ckt->CKTgmin * vbs_jct;
		      }	
                      break;
                  case 2:
                      if (vbs_jct < here->BSIM4vjsmRev)
                      {   T0 = vbs_jct / Nvtms;
                          if (T0 < -EXP_THRESHOLD)
                          {    evbs = MIN_EXP;
			       devbs_dvb = 0.0;
			  }
                          else
			  {    evbs = exp(T0);
                               devbs_dvb = evbs / Nvtms;
			  }

			  T1 = evbs - 1.0;
			  T2 = here->BSIM4IVjsmRev + here->BSIM4SslpRev
			     * (vbs_jct - here->BSIM4vjsmRev);
			  here->BSIM4gbs = devbs_dvb * T2 + T1 * here->BSIM4SslpRev + ckt->CKTgmin;
                          here->BSIM4cbs = T1 * T2 + ckt->CKTgmin * vbs_jct;
                      }         
                      else if (vbs_jct <= here->BSIM4vjsmFwd)
                      {   T0 = vbs_jct / Nvtms;
                          if (T0 < -EXP_THRESHOLD)
                          {    evbs = MIN_EXP;
                               devbs_dvb = 0.0;
                          }
                          else
                          {    evbs = exp(T0);
                               devbs_dvb = evbs / Nvtms;
                          }

			  T1 = (model->BSIM4bvs + vbs_jct) / Nvtms;
                          if (T1 > EXP_THRESHOLD)
                          {   T2 = MIN_EXP;
			      T3 = 0.0;
			  }
                          else
			  {   T2 = exp(-T1);
			      T3 = -T2 /Nvtms;
			  }
                          here->BSIM4gbs = SourceSatCurrent * (devbs_dvb - model->BSIM4xjbvs * T3)
					 + ckt->CKTgmin;
			  here->BSIM4cbs = SourceSatCurrent * (evbs + here->BSIM4XExpBVS - 1.0
				         - model->BSIM4xjbvs * T2) + ckt->CKTgmin * vbs_jct;
                      }
		      else
		      {   here->BSIM4gbs = here->BSIM4SslpFwd + ckt->CKTgmin;
                          here->BSIM4cbs = here->BSIM4IVjsmFwd + here->BSIM4SslpFwd * (vbs_jct
					 - here->BSIM4vjsmFwd) + ckt->CKTgmin * vbs_jct;
		      }
                      break;
                  default: break;
              }
	  }

          Nvtmd = model->BSIM4vtm * model->BSIM4DjctEmissionCoeff;
	  if ((here->BSIM4Adeff <= 0.0) && (here->BSIM4Pdeff <= 0.0))
	  {   DrainSatCurrent = 1.0e-14;
	  }
          else
          {   DrainSatCurrent = here->BSIM4Adeff * model->BSIM4DjctTempSatCurDensity
                              + here->BSIM4Pdeff * model->BSIM4DjctSidewallTempSatCurDensity
                              + pParam->BSIM4weffCJ * here->BSIM4nf
                              * model->BSIM4DjctGateSidewallTempSatCurDensity;
          }

	  if (DrainSatCurrent <= 0.0)
	  {   here->BSIM4gbd = ckt->CKTgmin;
              here->BSIM4cbd = here->BSIM4gbd * vbd_jct;
          }
          else
          {   switch(model->BSIM4dioMod)
              {   case 0:
                      evbd = exp(vbd_jct / Nvtmd);
                      T1 = model->BSIM4xjbvd * exp(-(model->BSIM4bvd + vbd_jct) / Nvtmd);
                      /* WDLiu: Magic T1 in this form; different from BSIM4 beta. */
                      here->BSIM4gbd = DrainSatCurrent * (evbd + T1) / Nvtmd + ckt->CKTgmin;
                      here->BSIM4cbd = DrainSatCurrent * (evbd + here->BSIM4XExpBVD
                                     - T1 - 1.0) + ckt->CKTgmin * vbd_jct;
                      break;
                  case 1:
		      T2 = vbd_jct / Nvtmd;
                      if (T2 < -EXP_THRESHOLD)
                      {   here->BSIM4gbd = ckt->CKTgmin;
                          here->BSIM4cbd = DrainSatCurrent * (MIN_EXP - 1.0)
                                         + ckt->CKTgmin * vbd_jct;
                      }
                      else if (vbd_jct <= here->BSIM4vjdmFwd)
                      {   evbd = exp(T2);
                          here->BSIM4gbd = DrainSatCurrent * evbd / Nvtmd + ckt->CKTgmin;
                          here->BSIM4cbd = DrainSatCurrent * (evbd - 1.0)
                                         + ckt->CKTgmin * vbd_jct;
                      }
                      else
                      {   T0 = here->BSIM4IVjdmFwd / Nvtmd;
                          here->BSIM4gbd = T0 + ckt->CKTgmin;
                          here->BSIM4cbd = here->BSIM4IVjdmFwd - DrainSatCurrent + T0
                                         * (vbd_jct - here->BSIM4vjdmFwd) + ckt->CKTgmin * vbd_jct;
                      }
                      break;
                  case 2:
                      if (vbd_jct < here->BSIM4vjdmRev)
                      {   T0 = vbd_jct / Nvtmd;
                          if (T0 < -EXP_THRESHOLD)
                          {    evbd = MIN_EXP;
                               devbd_dvb = 0.0;
                          }
                          else
                          {    evbd = exp(T0);
                               devbd_dvb = evbd / Nvtmd;
                          }

                          T1 = evbd - 1.0;
                          T2 = here->BSIM4IVjdmRev + here->BSIM4DslpRev
                             * (vbd_jct - here->BSIM4vjdmRev);
                          here->BSIM4gbd = devbd_dvb * T2 + T1 * here->BSIM4DslpRev + ckt->CKTgmin;
                          here->BSIM4cbd = T1 * T2 + ckt->CKTgmin * vbd_jct;
                      }
                      else if (vbd_jct <= here->BSIM4vjdmFwd)
                      {   T0 = vbd_jct / Nvtmd;
                          if (T0 < -EXP_THRESHOLD)
                          {    evbd = MIN_EXP;
                               devbd_dvb = 0.0;
                          }
                          else
                          {    evbd = exp(T0);
                               devbd_dvb = evbd / Nvtmd;
                          }

                          T1 = (model->BSIM4bvd + vbd_jct) / Nvtmd;
                          if (T1 > EXP_THRESHOLD)
                          {   T2 = MIN_EXP;
                              T3 = 0.0;
                          }
                          else
                          {   T2 = exp(-T1);
                              T3 = -T2 /Nvtmd;
                          }     
                          here->BSIM4gbd = DrainSatCurrent * (devbd_dvb - model->BSIM4xjbvd * T3)
                                         + ckt->CKTgmin;
                          here->BSIM4cbd = DrainSatCurrent * (evbd + here->BSIM4XExpBVD - 1.0
                                         - model->BSIM4xjbvd * T2) + ckt->CKTgmin * vbd_jct;
                      }
                      else
                      {   here->BSIM4gbd = here->BSIM4DslpFwd + ckt->CKTgmin;
                          here->BSIM4cbd = here->BSIM4IVjdmFwd + here->BSIM4DslpFwd * (vbd_jct
                                         - here->BSIM4vjdmFwd) + ckt->CKTgmin * vbd_jct;
                      }
                      break;
                  default: break;
              }
          } 

	  /* trap-assisted tunneling and recombination current for reverse bias  */
          Nvtmrssw = model->BSIM4vtm0 * model->BSIM4njtsswtemp;
          Nvtmrsswg = model->BSIM4vtm0 * model->BSIM4njtsswgtemp;
          Nvtmrs = model->BSIM4vtm0 * model->BSIM4njtstemp;

        if ((model->BSIM4vtss - vbs) < 1e-3)
        { T9 = 1.0e3; 
          T0 = - vbs / Nvtmrs * T9;
          DEXP(T0, T1, T10);
          dT1_dVb = T10 / Nvtmrs * T9; 
        } else {
          T9 = 1.0 / (model->BSIM4vtss - vbs);
          T0 = -vbs / Nvtmrs * model->BSIM4vtss * T9;
          dT0_dVb = model->BSIM4vtss / Nvtmrs * (T9 + vbs * T9 * T9) ;
          DEXP(T0, T1, T10);
          dT1_dVb = T10 * dT0_dVb;
        }

        if ((model->BSIM4vtsd - vbd) < 1e-3)
        { T9 = 1.0e3; 
          T0 = -vbd / Nvtmrs * T9;
          DEXP(T0, T2, T10);
          dT2_dVb = T10 / Nvtmrs * T9; 
        } else {
          T9 = 1.0 / (model->BSIM4vtsd - vbd);
          T0 = -vbd / Nvtmrs * model->BSIM4vtsd * T9;
          dT0_dVb = model->BSIM4vtsd / Nvtmrs * (T9 + vbd * T9 * T9) ;
          DEXP(T0, T2, T10);
          dT2_dVb = T10 * dT0_dVb;
        }
        
        if ((model->BSIM4vtssws - vbs) < 1e-3)
        { T9 = 1.0e3; 
          T0 = -vbs / Nvtmrssw * T9;
          DEXP(T0, T3, T10);
          dT3_dVb = T10 / Nvtmrssw * T9; 
        } else {
          T9 = 1.0 / (model->BSIM4vtssws - vbs);
          T0 = -vbs / Nvtmrssw * model->BSIM4vtssws * T9;
          dT0_dVb = model->BSIM4vtssws / Nvtmrssw * (T9 + vbs * T9 * T9) ;
          DEXP(T0, T3, T10);
          dT3_dVb = T10 * dT0_dVb;
        }
        if ((model->BSIM4vtsswd - vbd) < 1e-3)
        { T9 = 1.0e3; 
          T0 = -vbd / Nvtmrssw * T9;
          DEXP(T0, T4, T10);
          dT4_dVb = T10 / Nvtmrssw * T9; 
        } else {
          T9 = 1.0 / (model->BSIM4vtsswd - vbd);
          T0 = -vbd / Nvtmrssw * model->BSIM4vtsswd * T9;
          dT0_dVb = model->BSIM4vtsswd / Nvtmrssw * (T9 + vbd * T9 * T9) ;
          DEXP(T0, T4, T10);
          dT4_dVb = T10 * dT0_dVb;
        }

        if ((model->BSIM4vtsswgs - vbs) < 1e-3)
        { T9 = 1.0e3; 
          T0 = -vbs / Nvtmrsswg * T9;
          DEXP(T0, T5, T10);
          dT5_dVb = T10 / Nvtmrsswg * T9; 
        } else {
          T9 = 1.0 / (model->BSIM4vtsswgs - vbs);
          T0 = -vbs / Nvtmrsswg * model->BSIM4vtsswgs * T9;
          dT0_dVb = model->BSIM4vtsswgs / Nvtmrsswg * (T9 + vbs * T9 * T9) ;
          DEXP(T0, T5, T10);
          dT5_dVb = T10 * dT0_dVb;
        }
        if ((model->BSIM4vtsswgd - vbd) < 1e-3)
        { T9 = 1.0e3; 
          T0 = -vbd / Nvtmrsswg * T9;
          DEXP(T0, T4, T10);
          dT6_dVb = T10 / Nvtmrsswg * T9; 
        } else {
          T9 = 1.0 / (model->BSIM4vtsswgd - vbd);
          T0 = -vbd / Nvtmrsswg * model->BSIM4vtsswgd * T9;
          dT0_dVb = model->BSIM4vtsswgd / Nvtmrsswg * (T9 + vbd * T9 * T9) ;
          DEXP(T0, T6, T10);
          dT6_dVb = T10 * dT0_dVb;
        }

	  here->BSIM4gbs += here->BSIM4SjctTempRevSatCur * dT1_dVb
	  			+ here->BSIM4SswTempRevSatCur * dT3_dVb
	  			+ here->BSIM4SswgTempRevSatCur * dT5_dVb; 
	  here->BSIM4cbs -= here->BSIM4SjctTempRevSatCur * (T1 - 1.0)
	  			+ here->BSIM4SswTempRevSatCur * (T3 - 1.0)
	  			+ here->BSIM4SswgTempRevSatCur * (T5 - 1.0); 
	  here->BSIM4gbd += here->BSIM4DjctTempRevSatCur * dT2_dVb
	  			+ here->BSIM4DswTempRevSatCur * dT4_dVb
	  			+ here->BSIM4DswgTempRevSatCur * dT6_dVb; 
	  here->BSIM4cbd -= here->BSIM4DjctTempRevSatCur * (T2 - 1.0) 
	  			+ here->BSIM4DswTempRevSatCur * (T4 - 1.0)
	  			+ here->BSIM4DswgTempRevSatCur * (T6 - 1.0); 

          /* End of diode DC model */