b3temp.c

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

                  pParam->BSIM3tconst = pParam->BSIM3u0temp * pParam->BSIM3elm / (model->BSIM3cox
                                      * pParam->BSIM3weffCV * pParam->BSIM3leffCV * T0);

                  if (!model->BSIM3npeakGiven && model->BSIM3gamma1Given)
                  {   T0 = pParam->BSIM3gamma1 * model->BSIM3cox;
                      pParam->BSIM3npeak = 3.021E22 * T0 * T0;
                  }

		  pParam->BSIM3phi = 2.0 * Vtm0 
			           * log(pParam->BSIM3npeak / ni);

	          pParam->BSIM3sqrtPhi = sqrt(pParam->BSIM3phi);
	          pParam->BSIM3phis3 = pParam->BSIM3sqrtPhi * pParam->BSIM3phi;

                  pParam->BSIM3Xdep0 = sqrt(2.0 * EPSSI / (Charge_q
				     * pParam->BSIM3npeak * 1.0e6))
                                     * pParam->BSIM3sqrtPhi; 
                  pParam->BSIM3sqrtXdep0 = sqrt(pParam->BSIM3Xdep0);
                  pParam->BSIM3litl = sqrt(3.0 * pParam->BSIM3xj
				    * model->BSIM3tox);
                  pParam->BSIM3vbi = Vtm0 * log(1.0e20
			           * pParam->BSIM3npeak / (ni * ni));
                  pParam->BSIM3cdep0 = sqrt(Charge_q * EPSSI
				     * pParam->BSIM3npeak * 1.0e6 / 2.0
				     / pParam->BSIM3phi);

                  pParam->BSIM3ldeb = sqrt(EPSSI * Vtm0 / (Charge_q
                                    * pParam->BSIM3npeak * 1.0e6)) / 3.0;
                  pParam->BSIM3acde *= pow((pParam->BSIM3npeak / 2.0e16), -0.25);


                  if (model->BSIM3k1Given || model->BSIM3k2Given)
	          {   if (!model->BSIM3k1Given)
	              {   fprintf(stdout, "Warning: k1 should be specified with k2.\n");
                          pParam->BSIM3k1 = 0.53;
                      }
                      if (!model->BSIM3k2Given)
	              {   fprintf(stdout, "Warning: k2 should be specified with k1.\n");
                          pParam->BSIM3k2 = -0.0186;
                      }
                      if (model->BSIM3nsubGiven)
                          fprintf(stdout, "Warning: nsub is ignored because k1 or k2 is given.\n");
                      if (model->BSIM3xtGiven)
                          fprintf(stdout, "Warning: xt is ignored because k1 or k2 is given.\n");
                      if (model->BSIM3vbxGiven)
                          fprintf(stdout, "Warning: vbx is ignored because k1 or k2 is given.\n");
                      if (model->BSIM3gamma1Given)
                          fprintf(stdout, "Warning: gamma1 is ignored because k1 or k2 is given.\n");
                      if (model->BSIM3gamma2Given)
                          fprintf(stdout, "Warning: gamma2 is ignored because k1 or k2 is given.\n");
                  }
                  else
	          {   if (!model->BSIM3vbxGiven)
                          pParam->BSIM3vbx = pParam->BSIM3phi - 7.7348e-4 
                                           * pParam->BSIM3npeak
					   * pParam->BSIM3xt * pParam->BSIM3xt;
	              if (pParam->BSIM3vbx > 0.0)
		          pParam->BSIM3vbx = -pParam->BSIM3vbx;
	              if (pParam->BSIM3vbm > 0.0)
                          pParam->BSIM3vbm = -pParam->BSIM3vbm;
           
                      if (!model->BSIM3gamma1Given)
                          pParam->BSIM3gamma1 = 5.753e-12
					      * sqrt(pParam->BSIM3npeak)
                                              / model->BSIM3cox;
                      if (!model->BSIM3gamma2Given)
                          pParam->BSIM3gamma2 = 5.753e-12
					      * sqrt(pParam->BSIM3nsub)
                                              / model->BSIM3cox;

                      T0 = pParam->BSIM3gamma1 - pParam->BSIM3gamma2;
                      T1 = sqrt(pParam->BSIM3phi - pParam->BSIM3vbx)
			 - pParam->BSIM3sqrtPhi;
                      T2 = sqrt(pParam->BSIM3phi * (pParam->BSIM3phi
			 - pParam->BSIM3vbm)) - pParam->BSIM3phi;
                      pParam->BSIM3k2 = T0 * T1 / (2.0 * T2 + pParam->BSIM3vbm);
                      pParam->BSIM3k1 = pParam->BSIM3gamma2 - 2.0
				      * pParam->BSIM3k2 * sqrt(pParam->BSIM3phi
				      - pParam->BSIM3vbm);
                  }
 
		  if (pParam->BSIM3k2 < 0.0)
		  {   T0 = 0.5 * pParam->BSIM3k1 / pParam->BSIM3k2;
                      pParam->BSIM3vbsc = 0.9 * (pParam->BSIM3phi - T0 * T0);
		      if (pParam->BSIM3vbsc > -3.0)
		          pParam->BSIM3vbsc = -3.0;
		      else if (pParam->BSIM3vbsc < -30.0)
		          pParam->BSIM3vbsc = -30.0;
		  }
		  else
		  {   pParam->BSIM3vbsc = -30.0;
		  }
		  if (pParam->BSIM3vbsc > pParam->BSIM3vbm)
		      pParam->BSIM3vbsc = pParam->BSIM3vbm;

                  if (!model->BSIM3vfbGiven)
                  {   if (model->BSIM3vth0Given)
                      {   pParam->BSIM3vfb = model->BSIM3type * pParam->BSIM3vth0
                                           - pParam->BSIM3phi - pParam->BSIM3k1
                                           * pParam->BSIM3sqrtPhi;
                      }
                      else
                      {   pParam->BSIM3vfb = -1.0;
                      }
                  }
                  if (!model->BSIM3vth0Given)
                  {   pParam->BSIM3vth0 = model->BSIM3type * (pParam->BSIM3vfb
                                        + pParam->BSIM3phi + pParam->BSIM3k1
                                        * pParam->BSIM3sqrtPhi);
                  }

                  pParam->BSIM3k1ox = pParam->BSIM3k1 * model->BSIM3tox
                                    / model->BSIM3toxm;
                  pParam->BSIM3k2ox = pParam->BSIM3k2 * model->BSIM3tox
                                    / model->BSIM3toxm;

                  T1 = sqrt(EPSSI / EPSOX * model->BSIM3tox
		     * pParam->BSIM3Xdep0);
                  T0 = exp(-0.5 * pParam->BSIM3dsub * pParam->BSIM3leff / T1);
                  pParam->BSIM3theta0vb0 = (T0 + 2.0 * T0 * T0);

                  T0 = exp(-0.5 * pParam->BSIM3drout * pParam->BSIM3leff / T1);
                  T2 = (T0 + 2.0 * T0 * T0);
                  pParam->BSIM3thetaRout = pParam->BSIM3pdibl1 * T2
				         + pParam->BSIM3pdibl2;

                  tmp = sqrt(pParam->BSIM3Xdep0);
                  tmp1 = pParam->BSIM3vbi - pParam->BSIM3phi;
                  tmp2 = model->BSIM3factor1 * tmp;

                  T0 = -0.5 * pParam->BSIM3dvt1w * pParam->BSIM3weff
                     * pParam->BSIM3leff / tmp2;
                  if (T0 > -EXP_THRESHOLD)
                  {   T1 = exp(T0);
                      T2 = T1 * (1.0 + 2.0 * T1);
                  }
                  else
                  {   T1 = MIN_EXP;
                      T2 = T1 * (1.0 + 2.0 * T1);
                  }
                  T0 = pParam->BSIM3dvt0w * T2;
                  T2 = T0 * tmp1;

                  T0 = -0.5 * pParam->BSIM3dvt1 * pParam->BSIM3leff / tmp2;
                  if (T0 > -EXP_THRESHOLD)
                  {   T1 = exp(T0);
                      T3 = T1 * (1.0 + 2.0 * T1);
                  }
                  else
                  {   T1 = MIN_EXP;
                      T3 = T1 * (1.0 + 2.0 * T1);
                  }
                  T3 = pParam->BSIM3dvt0 * T3 * tmp1;

                  T4 = model->BSIM3tox * pParam->BSIM3phi
                     / (pParam->BSIM3weff + pParam->BSIM3w0);

                  T0 = sqrt(1.0 + pParam->BSIM3nlx / pParam->BSIM3leff);
                  T5 = pParam->BSIM3k1ox * (T0 - 1.0) * pParam->BSIM3sqrtPhi
                     + (pParam->BSIM3kt1 + pParam->BSIM3kt1l / pParam->BSIM3leff)
                     * (TRatio - 1.0);

                  tmp3 = model->BSIM3type * pParam->BSIM3vth0
                       - T2 - T3 + pParam->BSIM3k3 * T4 + T5;
                  pParam->BSIM3vfbzb = tmp3 - pParam->BSIM3phi - pParam->BSIM3k1
                                     * pParam->BSIM3sqrtPhi;
                  /* End of vfbzb */
              }
	      else /* !Size_Not_Found */
	      {
	          /* va: pParam might be uninitialized, if !Size_Not_Found */
	          pParam = here->pParam;
	      }

              /* process source/drain series resistance */
              /* acm model */
              if (model->BSIM3acmMod == 0)
              {
	        here->BSIM3drainConductance = model->BSIM3sheetResistance 
			                              * here->BSIM3drainSquares;
	        here->BSIM3sourceConductance = model->BSIM3sheetResistance 
			                           * here->BSIM3sourceSquares;
              } 
              else 
              {
                if (here->BSIM3drainSquaresGiven)
                {
                  here->BSIM3drainConductance = (model->BSIM3ld + model->BSIM3ldif)/(here->BSIM3w + model->BSIM3xw)*model->BSIM3rd
                                               + model->BSIM3sheetResistance * here->BSIM3drainSquares + model->BSIM3rdc;
                }
                else
                {
                  here->BSIM3drainConductance = ((model->BSIM3ld + model->BSIM3ldif)*model->BSIM3rd 
                                               + model->BSIM3hdif*model->BSIM3sheetResistance)/(here->BSIM3w + model->BSIM3xw) + model->BSIM3rdc;
                }
                if (here->BSIM3sourceSquaresGiven)
                {
                  here->BSIM3sourceConductance = (model->BSIM3ld + model->BSIM3ldif)/(here->BSIM3w + model->BSIM3xw)*model->BSIM3rs
                                               + model->BSIM3sheetResistance * here->BSIM3sourceSquares + model->BSIM3rsc;
                }
                else
                {
                  here->BSIM3sourceConductance = ((model->BSIM3ld + model->BSIM3ldif)*model->BSIM3rs 
                                               + model->BSIM3hdif*model->BSIM3sheetResistance)/(here->BSIM3w + model->BSIM3xw) + model->BSIM3rsc;
                }
              }
              if (here->BSIM3drainConductance > 0.0)
                  here->BSIM3drainConductance = 1.0
		  			      / here->BSIM3drainConductance;
	      else
                  here->BSIM3drainConductance = 0.0;

              if (here->BSIM3sourceConductance > 0.0) 
                  here->BSIM3sourceConductance = 1.0
					       / here->BSIM3sourceConductance;
	      else
                  here->BSIM3sourceConductance = 0.0;

	      here->BSIM3cgso = pParam->BSIM3cgso;
	      here->BSIM3cgdo = pParam->BSIM3cgdo;

              Nvtm = model->BSIM3vtm * model->BSIM3jctEmissionCoeff;
              if (model->BSIM3acmMod == 0)
              {
                if ((here->BSIM3sourceArea <= 0.0) &&
                    (here->BSIM3sourcePerimeter <= 0.0))
                {   SourceSatCurrent = 1.0e-14;
                }
                else
                {   SourceSatCurrent = here->BSIM3sourceArea
                                     * model->BSIM3jctTempSatCurDensity
                                     + here->BSIM3sourcePerimeter
                                     * model->BSIM3jctSidewallTempSatCurDensity;
                }
                if ((SourceSatCurrent > 0.0) && (model->BSIM3ijth > 0.0))
                {   here->BSIM3vjsm = Nvtm * log(model->BSIM3ijth
                                    / SourceSatCurrent + 1.0);
  			/* Added revision dependent code */
  			switch (model->BSIM3intVersion) {
  			case BSIM3V324:
  			case BSIM3V323:
  			case BSIM3V322:
  				here->BSIM3IsEvjsm =
  					SourceSatCurrent * exp(here->BSIM3vjsm / Nvtm);
  				break;
  			case BSIM3V32:
  			default:
  				/* Do nothing */
  				break;
  			}
                }
  
                if ((here->BSIM3drainArea <= 0.0) &&
                    (here->BSIM3drainPerimeter <= 0.0))
                {   DrainSatCurrent = 1.0e-14;
                }
                else
                {   DrainSatCurrent = here->BSIM3drainArea
                                    * model->BSIM3jctTempSatCurDensity
                                    + here->BSIM3drainPerimeter
                                    * model->BSIM3jctSidewallTempSatCurDensity;
                }
                if ((DrainSatCurrent > 0.0) && (model->BSIM3ijth > 0.0))
                {   here->BSIM3vjdm = Nvtm * log(model->BSIM3ijth
                                    / DrainSatCurrent + 1.0);
  			/* Added revision dependent code */
  			switch (model->BSIM3intVersion) {
  			case BSIM3V324:
  			case BSIM3V323:
  			case BSIM3V322:
  				here->BSIM3IsEvjdm = 
  					DrainSatCurrent * exp(here->BSIM3vjdm / Nvtm);
  				break;
  			case BSIM3V32:
  			default:
  				/* Do nothing */
  				break;
  			}
                }
              }
              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) && (model->BSIM3ijth > 0.0))
                {   here->BSIM3vjsm = Nvtm * log(model->BSIM3ijth
                                    / SourceSatCurrent + 1.0);
  		    /* Added revision dependent code */
  		    switch (model->BSIM3intVersion) {
  		    case BSIM3V324:
  		    case BSIM3V323:
  		    case BSIM3V322:
  		    	here->BSIM3IsEvjsm =
  		    		SourceSatCurrent * exp(here->BSIM3vjsm / Nvtm);
  		    	break;
  		    case BSIM3V32:
  		    default:
  		    	/* Do nothing */
  			break;
  		    }
                }

                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) && (model->BSIM3ijth > 0.0))
                {   here->BSIM3vjdm = Nvtm * log(model->BSIM3ijth
                                    / DrainSatCurrent + 1.0);
  		    /* Added revision dependent code */
  		    switch (model->BSIM3intVersion) {
  		    case BSIM3V324:
  		    case BSIM3V323:
  		    case BSIM3V322:
  		    	here->BSIM3IsEvjdm = 
  		    		DrainSatCurrent * exp(here->BSIM3vjdm / Nvtm);
  		    	break;
  		    case BSIM3V32:
  		    default:
  		    	/* Do nothing */
  			break;
  		    }
                }
              }
         }
    }
    return(OK);
}