b3v1temp.c

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

				    + model->BSIM3v1ldvt1w * Inv_L
				    + model->BSIM3v1wdvt1w * Inv_W
				    + model->BSIM3v1pdvt1w * Inv_LW;
		  pParam->BSIM3v1dvt2w = model->BSIM3v1dvt2w
				    + model->BSIM3v1ldvt2w * Inv_L
				    + model->BSIM3v1wdvt2w * Inv_W
				    + model->BSIM3v1pdvt2w * Inv_LW;
		  pParam->BSIM3v1drout = model->BSIM3v1drout
				     + model->BSIM3v1ldrout * Inv_L
				     + model->BSIM3v1wdrout * Inv_W
				     + model->BSIM3v1pdrout * Inv_LW;
		  pParam->BSIM3v1dsub = model->BSIM3v1dsub
				    + model->BSIM3v1ldsub * Inv_L
				    + model->BSIM3v1wdsub * Inv_W
				    + model->BSIM3v1pdsub * Inv_LW;
		  pParam->BSIM3v1vth0 = model->BSIM3v1vth0
				    + model->BSIM3v1lvth0 * Inv_L
				    + model->BSIM3v1wvth0 * Inv_W
				    + model->BSIM3v1pvth0 * Inv_LW;
		  pParam->BSIM3v1ua = model->BSIM3v1ua
				  + model->BSIM3v1lua * Inv_L
				  + model->BSIM3v1wua * Inv_W
				  + model->BSIM3v1pua * Inv_LW;
		  pParam->BSIM3v1ua1 = model->BSIM3v1ua1
				   + model->BSIM3v1lua1 * Inv_L
				   + model->BSIM3v1wua1 * Inv_W
				   + model->BSIM3v1pua1 * Inv_LW;
		  pParam->BSIM3v1ub = model->BSIM3v1ub
				  + model->BSIM3v1lub * Inv_L
				  + model->BSIM3v1wub * Inv_W
				  + model->BSIM3v1pub * Inv_LW;
		  pParam->BSIM3v1ub1 = model->BSIM3v1ub1
				   + model->BSIM3v1lub1 * Inv_L
				   + model->BSIM3v1wub1 * Inv_W
				   + model->BSIM3v1pub1 * Inv_LW;
		  pParam->BSIM3v1uc = model->BSIM3v1uc
				  + model->BSIM3v1luc * Inv_L
				  + model->BSIM3v1wuc * Inv_W
				  + model->BSIM3v1puc * Inv_LW;
		  pParam->BSIM3v1uc1 = model->BSIM3v1uc1
				   + model->BSIM3v1luc1 * Inv_L
				   + model->BSIM3v1wuc1 * Inv_W
				   + model->BSIM3v1puc1 * Inv_LW;
		  pParam->BSIM3v1u0 = model->BSIM3v1u0
				  + model->BSIM3v1lu0 * Inv_L
				  + model->BSIM3v1wu0 * Inv_W
				  + model->BSIM3v1pu0 * Inv_LW;
		  pParam->BSIM3v1ute = model->BSIM3v1ute
				   + model->BSIM3v1lute * Inv_L
				   + model->BSIM3v1wute * Inv_W
				   + model->BSIM3v1pute * Inv_LW;
		  pParam->BSIM3v1voff = model->BSIM3v1voff
				    + model->BSIM3v1lvoff * Inv_L
				    + model->BSIM3v1wvoff * Inv_W
				    + model->BSIM3v1pvoff * Inv_LW;
		  pParam->BSIM3v1delta = model->BSIM3v1delta
				     + model->BSIM3v1ldelta * Inv_L
				     + model->BSIM3v1wdelta * Inv_W
				     + model->BSIM3v1pdelta * Inv_LW;
		  pParam->BSIM3v1rdsw = model->BSIM3v1rdsw
				    + model->BSIM3v1lrdsw * Inv_L
				    + model->BSIM3v1wrdsw * Inv_W
				    + model->BSIM3v1prdsw * Inv_LW;
		  pParam->BSIM3v1prwg = model->BSIM3v1prwg
				    + model->BSIM3v1lprwg * Inv_L
				    + model->BSIM3v1wprwg * Inv_W
				    + model->BSIM3v1pprwg * Inv_LW;
		  pParam->BSIM3v1prwb = model->BSIM3v1prwb
				    + model->BSIM3v1lprwb * Inv_L
				    + model->BSIM3v1wprwb * Inv_W
				    + model->BSIM3v1pprwb * Inv_LW;
		  pParam->BSIM3v1prt = model->BSIM3v1prt
				    + model->BSIM3v1lprt * Inv_L
				    + model->BSIM3v1wprt * Inv_W
				    + model->BSIM3v1pprt * Inv_LW;
		  pParam->BSIM3v1eta0 = model->BSIM3v1eta0
				    + model->BSIM3v1leta0 * Inv_L
				    + model->BSIM3v1weta0 * Inv_W
				    + model->BSIM3v1peta0 * Inv_LW;
		  pParam->BSIM3v1etab = model->BSIM3v1etab
				    + model->BSIM3v1letab * Inv_L
				    + model->BSIM3v1wetab * Inv_W
				    + model->BSIM3v1petab * Inv_LW;
		  pParam->BSIM3v1pclm = model->BSIM3v1pclm
				    + model->BSIM3v1lpclm * Inv_L
				    + model->BSIM3v1wpclm * Inv_W
				    + model->BSIM3v1ppclm * Inv_LW;
		  pParam->BSIM3v1pdibl1 = model->BSIM3v1pdibl1
				      + model->BSIM3v1lpdibl1 * Inv_L
				      + model->BSIM3v1wpdibl1 * Inv_W
				      + model->BSIM3v1ppdibl1 * Inv_LW;
		  pParam->BSIM3v1pdibl2 = model->BSIM3v1pdibl2
				      + model->BSIM3v1lpdibl2 * Inv_L
				      + model->BSIM3v1wpdibl2 * Inv_W
				      + model->BSIM3v1ppdibl2 * Inv_LW;
		  pParam->BSIM3v1pdiblb = model->BSIM3v1pdiblb
				      + model->BSIM3v1lpdiblb * Inv_L
				      + model->BSIM3v1wpdiblb * Inv_W
				      + model->BSIM3v1ppdiblb * Inv_LW;
		  pParam->BSIM3v1pscbe1 = model->BSIM3v1pscbe1
				      + model->BSIM3v1lpscbe1 * Inv_L
				      + model->BSIM3v1wpscbe1 * Inv_W
				      + model->BSIM3v1ppscbe1 * Inv_LW;
		  pParam->BSIM3v1pscbe2 = model->BSIM3v1pscbe2
				      + model->BSIM3v1lpscbe2 * Inv_L
				      + model->BSIM3v1wpscbe2 * Inv_W
				      + model->BSIM3v1ppscbe2 * Inv_LW;
		  pParam->BSIM3v1pvag = model->BSIM3v1pvag
				    + model->BSIM3v1lpvag * Inv_L
				    + model->BSIM3v1wpvag * Inv_W
				    + model->BSIM3v1ppvag * Inv_LW;
		  pParam->BSIM3v1wr = model->BSIM3v1wr
				  + model->BSIM3v1lwr * Inv_L
				  + model->BSIM3v1wwr * Inv_W
				  + model->BSIM3v1pwr * Inv_LW;
		  pParam->BSIM3v1dwg = model->BSIM3v1dwg
				   + model->BSIM3v1ldwg * Inv_L
				   + model->BSIM3v1wdwg * Inv_W
				   + model->BSIM3v1pdwg * Inv_LW;
		  pParam->BSIM3v1dwb = model->BSIM3v1dwb
				   + model->BSIM3v1ldwb * Inv_L
				   + model->BSIM3v1wdwb * Inv_W
				   + model->BSIM3v1pdwb * Inv_LW;
		  pParam->BSIM3v1b0 = model->BSIM3v1b0
				  + model->BSIM3v1lb0 * Inv_L
				  + model->BSIM3v1wb0 * Inv_W
				  + model->BSIM3v1pb0 * Inv_LW;
		  pParam->BSIM3v1b1 = model->BSIM3v1b1
				  + model->BSIM3v1lb1 * Inv_L
				  + model->BSIM3v1wb1 * Inv_W
				  + model->BSIM3v1pb1 * Inv_LW;
		  pParam->BSIM3v1alpha0 = model->BSIM3v1alpha0
				      + model->BSIM3v1lalpha0 * Inv_L
				      + model->BSIM3v1walpha0 * Inv_W
				      + model->BSIM3v1palpha0 * Inv_LW;
		  pParam->BSIM3v1beta0 = model->BSIM3v1beta0
				     + model->BSIM3v1lbeta0 * Inv_L
				     + model->BSIM3v1wbeta0 * Inv_W
				     + model->BSIM3v1pbeta0 * Inv_LW;
		  /* CV model */
		  pParam->BSIM3v1elm = model->BSIM3v1elm
				  + model->BSIM3v1lelm * Inv_L
				  + model->BSIM3v1welm * Inv_W
				  + model->BSIM3v1pelm * Inv_LW;
		  pParam->BSIM3v1cgsl = model->BSIM3v1cgsl
				    + model->BSIM3v1lcgsl * Inv_L
				    + model->BSIM3v1wcgsl * Inv_W
				    + model->BSIM3v1pcgsl * Inv_LW;
		  pParam->BSIM3v1cgdl = model->BSIM3v1cgdl
				    + model->BSIM3v1lcgdl * Inv_L
				    + model->BSIM3v1wcgdl * Inv_W
				    + model->BSIM3v1pcgdl * Inv_LW;
		  pParam->BSIM3v1ckappa = model->BSIM3v1ckappa
				      + model->BSIM3v1lckappa * Inv_L
				      + model->BSIM3v1wckappa * Inv_W
				      + model->BSIM3v1pckappa * Inv_LW;
		  pParam->BSIM3v1cf = model->BSIM3v1cf
				  + model->BSIM3v1lcf * Inv_L
				  + model->BSIM3v1wcf * Inv_W
				  + model->BSIM3v1pcf * Inv_LW;
		  pParam->BSIM3v1clc = model->BSIM3v1clc
				   + model->BSIM3v1lclc * Inv_L
				   + model->BSIM3v1wclc * Inv_W
				   + model->BSIM3v1pclc * Inv_LW;
		  pParam->BSIM3v1cle = model->BSIM3v1cle
				   + model->BSIM3v1lcle * Inv_L
				   + model->BSIM3v1wcle * Inv_W
				   + model->BSIM3v1pcle * Inv_LW;
		  pParam->BSIM3v1vfbcv = model->BSIM3v1vfbcv
				  + model->BSIM3v1lvfbcv * Inv_L
				  + model->BSIM3v1wvfbcv * Inv_W
				  + model->BSIM3v1pvfbcv * Inv_LW;
                  pParam->BSIM3v1abulkCVfactor = 1.0 + pow((pParam->BSIM3v1clc
					     / pParam->BSIM3v1leff),
					     pParam->BSIM3v1cle);

	          T0 = (TRatio - 1.0);
	          pParam->BSIM3v1ua = pParam->BSIM3v1ua + pParam->BSIM3v1ua1 * T0;
	          pParam->BSIM3v1ub = pParam->BSIM3v1ub + pParam->BSIM3v1ub1 * T0;
	          pParam->BSIM3v1uc = pParam->BSIM3v1uc + pParam->BSIM3v1uc1 * T0;
                  if (pParam->BSIM3v1u0 > 1.0) 
                      pParam->BSIM3v1u0 = pParam->BSIM3v1u0 / 1.0e4;

                  pParam->BSIM3v1u0temp = pParam->BSIM3v1u0
				      * pow(TRatio, pParam->BSIM3v1ute); 
                  pParam->BSIM3v1vsattemp = pParam->BSIM3v1vsat - pParam->BSIM3v1at 
			                * T0;
	          pParam->BSIM3v1rds0 = (pParam->BSIM3v1rdsw + pParam->BSIM3v1prt * T0)
                                    / pow(pParam->BSIM3v1weff * 1E6, pParam->BSIM3v1wr);

		  if (BSIM3v1checkModel(model, here, ckt))
		  {   IFuid namarray[2];
                      namarray[0] = model->BSIM3v1modName;
                      namarray[1] = here->BSIM3v1name;
                      (*(SPfrontEnd->IFerror)) (ERR_FATAL, "Fatal error(s) detected during BSIM3V3.1 parameter checking for %s in model %s", namarray);
                      return(E_BADPARM);   
		  }

                  pParam->BSIM3v1cgdo = (model->BSIM3v1cgdo + pParam->BSIM3v1cf)
				    * pParam->BSIM3v1weffCV;
                  pParam->BSIM3v1cgso = (model->BSIM3v1cgso + pParam->BSIM3v1cf)
				    * pParam->BSIM3v1weffCV;
                  pParam->BSIM3v1cgbo = model->BSIM3v1cgbo * pParam->BSIM3v1leffCV;

                  if (!model->BSIM3v1npeakGiven && model->BSIM3v1gamma1Given)
                  {   T0 = pParam->BSIM3v1gamma1 * model->BSIM3v1cox;
                      pParam->BSIM3v1npeak = 3.021E22 * T0 * T0;
                  }

		  pParam->BSIM3v1phi = 2.0 * Vtm0 
			           * log(pParam->BSIM3v1npeak / ni);

	          pParam->BSIM3v1sqrtPhi = sqrt(pParam->BSIM3v1phi);
	          pParam->BSIM3v1phis3 = pParam->BSIM3v1sqrtPhi * pParam->BSIM3v1phi;

                  pParam->BSIM3v1Xdep0 = sqrt(2.0 * EPSSI / (Charge_q
				     * pParam->BSIM3v1npeak * 1.0e6))
                                     * pParam->BSIM3v1sqrtPhi; 
                  pParam->BSIM3v1sqrtXdep0 = sqrt(pParam->BSIM3v1Xdep0);
                  pParam->BSIM3v1litl = sqrt(3.0 * pParam->BSIM3v1xj
				    * model->BSIM3v1tox);
                  pParam->BSIM3v1vbi = Vtm0 * log(1.0e20
			           * pParam->BSIM3v1npeak / (ni * ni));
                  pParam->BSIM3v1cdep0 = sqrt(Charge_q * EPSSI
				     * pParam->BSIM3v1npeak * 1.0e6 / 2.0
				     / pParam->BSIM3v1phi);
        
                  if (model->BSIM3v1k1Given || model->BSIM3v1k2Given)
	          {   if (!model->BSIM3v1k1Given)
	              {   fprintf(stdout, "Warning: k1 should be specified with k2.\n");
                          pParam->BSIM3v1k1 = 0.53;
                      }
                      if (!model->BSIM3v1k2Given)
	              {   fprintf(stdout, "Warning: k2 should be specified with k1.\n");
                          pParam->BSIM3v1k2 = -0.0186;
                      }
                      if (model->BSIM3v1nsubGiven)
                          fprintf(stdout, "Warning: nsub is ignored because k1 or k2 is given.\n");
                      if (model->BSIM3v1xtGiven)
                          fprintf(stdout, "Warning: xt is ignored because k1 or k2 is given.\n");
                      if (model->BSIM3v1vbxGiven)
                          fprintf(stdout, "Warning: vbx is ignored because k1 or k2 is given.\n");
                      if (model->BSIM3v1vbmGiven)
                          fprintf(stdout, "Warning: vbm is ignored because k1 or k2 is given.\n");
                      if (model->BSIM3v1gamma1Given)
                          fprintf(stdout, "Warning: gamma1 is ignored because k1 or k2 is given.\n");
                      if (model->BSIM3v1gamma2Given)
                          fprintf(stdout, "Warning: gamma2 is ignored because k1 or k2 is given.\n");
                  }
                  else
	          {   if (!model->BSIM3v1vbxGiven)
                          pParam->BSIM3v1vbx = pParam->BSIM3v1phi - 7.7348e-4 
                                           * pParam->BSIM3v1npeak
					   * pParam->BSIM3v1xt * pParam->BSIM3v1xt;
	              if (pParam->BSIM3v1vbx > 0.0)
		          pParam->BSIM3v1vbx = -pParam->BSIM3v1vbx;
	              if (pParam->BSIM3v1vbm > 0.0)
                          pParam->BSIM3v1vbm = -pParam->BSIM3v1vbm;
           
                      if (!model->BSIM3v1gamma1Given)
                          pParam->BSIM3v1gamma1 = 5.753e-12
					      * sqrt(pParam->BSIM3v1npeak)
                                              / model->BSIM3v1cox;
                      if (!model->BSIM3v1gamma2Given)
                          pParam->BSIM3v1gamma2 = 5.753e-12
					      * sqrt(pParam->BSIM3v1nsub)
                                              / model->BSIM3v1cox;

                      T0 = pParam->BSIM3v1gamma1 - pParam->BSIM3v1gamma2;
                      T1 = sqrt(pParam->BSIM3v1phi - pParam->BSIM3v1vbx)
			 - pParam->BSIM3v1sqrtPhi;
                      T2 = sqrt(pParam->BSIM3v1phi * (pParam->BSIM3v1phi
			 - pParam->BSIM3v1vbm)) - pParam->BSIM3v1phi;
                      pParam->BSIM3v1k2 = T0 * T1 / (2.0 * T2 + pParam->BSIM3v1vbm);
                      pParam->BSIM3v1k1 = pParam->BSIM3v1gamma2 - 2.0
				      * pParam->BSIM3v1k2 * sqrt(pParam->BSIM3v1phi
				      - pParam->BSIM3v1vbm);
                  }
 
		  if (pParam->BSIM3v1k2 < 0.0)
		  {   T0 = 0.5 * pParam->BSIM3v1k1 / pParam->BSIM3v1k2;
                      pParam->BSIM3v1vbsc = 0.9 * (pParam->BSIM3v1phi - T0 * T0);
		      if (pParam->BSIM3v1vbsc > -3.0)
		          pParam->BSIM3v1vbsc = -3.0;
		      else if (pParam->BSIM3v1vbsc < -30.0)
		          pParam->BSIM3v1vbsc = -30.0;
		  }
		  else
		  {   pParam->BSIM3v1vbsc = -30.0;
		  }
		  if (pParam->BSIM3v1vbsc > pParam->BSIM3v1vbm)
		      pParam->BSIM3v1vbsc = pParam->BSIM3v1vbm;

	          if (model->BSIM3v1vth0Given)
		  {   pParam->BSIM3v1vfb = model->BSIM3v1type * pParam->BSIM3v1vth0 
                                       - pParam->BSIM3v1phi - pParam->BSIM3v1k1 
                                       * pParam->BSIM3v1sqrtPhi;
		  }
		  else
		  {   pParam->BSIM3v1vfb = -1.0;
		      pParam->BSIM3v1vth0 = model->BSIM3v1type * (pParam->BSIM3v1vfb
                                        + pParam->BSIM3v1phi + pParam->BSIM3v1k1 
                                        * pParam->BSIM3v1sqrtPhi);
		  }
                  T1 = sqrt(EPSSI / EPSOX * model->BSIM3v1tox
		     * pParam->BSIM3v1Xdep0);
                  T0 = exp(-0.5 * pParam->BSIM3v1dsub * pParam->BSIM3v1leff / T1);
                  pParam->BSIM3v1theta0vb0 = (T0 + 2.0 * T0 * T0);

                  T0 = exp(-0.5 * pParam->BSIM3v1drout * pParam->BSIM3v1leff / T1);
                  T2 = (T0 + 2.0 * T0 * T0);
                  pParam->BSIM3v1thetaRout = pParam->BSIM3v1pdibl1 * T2
				         + pParam->BSIM3v1pdibl2;
	      }

              /* process source/drain series resistance */
              here->BSIM3v1drainConductance = model->BSIM3v1sheetResistance 
		                              * here->BSIM3v1drainSquares;
              if (here->BSIM3v1drainConductance > 0.0)
                  here->BSIM3v1drainConductance = 1.0
					      / here->BSIM3v1drainConductance;
	      else
                  here->BSIM3v1drainConductance = 0.0;
                  
              here->BSIM3v1sourceConductance = model->BSIM3v1sheetResistance 
		                           * here->BSIM3v1sourceSquares;
              if (here->BSIM3v1sourceConductance > 0.0) 
                  here->BSIM3v1sourceConductance = 1.0
					       / here->BSIM3v1sourceConductance;
	      else
                  here->BSIM3v1sourceConductance = 0.0;
	      here->BSIM3v1cgso = pParam->BSIM3v1cgso;
	      here->BSIM3v1cgdo = pParam->BSIM3v1cgdo;
         }
    }
    return(OK);
}