b3soiddtemp.c

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

/**********
Copyright 1999 Regents of the University of California.  All rights reserved.
Author: Weidong Liu and Pin Su         Feb 1999
Author: 1998 Samuel Fung, Dennis Sinitsky and Stephen Tang
Modified by Pin Su, Wei Jin 99/9/27
File: b3soiddtemp.c          98/5/01
Modified by Paolo Nenzi 2002
**********/

/* 
 * Revision 2.1  99/9/27 Pin Su 
 * BSIMDD2.1 release
 */

/* Lmin, Lmax, Wmin, Wmax */

#include "ngspice.h"
#include "smpdefs.h"
#include "cktdefs.h"
#include "b3soidddef.h"
#include "const.h"
#include "sperror.h"
#include "suffix.h"

#define Kb 1.3806226e-23
#define KboQ 8.617087e-5  /* Kb / q  where q = 1.60219e-19 */
#define EPSOX 3.453133e-11
#define EPSSI 1.03594e-10
#define PI 3.141592654
#define MAX_EXP 5.834617425e14
#define MIN_EXP 1.713908431e-15
#define EXP_THRESHOLD 34.0
#define Charge_q 1.60219e-19


/* ARGSUSED */
int
B3SOIDDtemp(GENmodel *inModel, CKTcircuit *ckt)
{
B3SOIDDmodel *model = (B3SOIDDmodel*) inModel;
B3SOIDDinstance *here;
struct b3soiddSizeDependParam *pSizeDependParamKnot, *pLastKnot, *pParam=NULL;
double tmp, tmp1, tmp2, Eg, Eg0, ni, T0, T1, T2, T3, T4, T5, T6, Ldrn, Wdrn;
double Temp, TRatio, Inv_L, Inv_W, Inv_LW, Vtm0, Tnom;
double SDphi, SDgamma;
int Size_Not_Found;

    /*  loop through all the B3SOIDD device models */
    for (; model != NULL; model = model->B3SOIDDnextModel)
    {    Temp = ckt->CKTtemp;
         if (model->B3SOIDDGatesidewallJctPotential < 0.1)
             model->B3SOIDDGatesidewallJctPotential = 0.1;
         model->pSizeDependParamKnot = NULL;
	 pLastKnot = NULL;

	 Tnom = model->B3SOIDDtnom;
	 TRatio = Temp / Tnom;

	 model->B3SOIDDvcrit = CONSTvt0 * log(CONSTvt0 / (CONSTroot2 * 1.0e-14));
         model->B3SOIDDfactor1 = sqrt(EPSSI / EPSOX * model->B3SOIDDtox);

         Vtm0 = KboQ * Tnom;
         Eg0 = 1.16 - 7.02e-4 * Tnom * Tnom / (Tnom + 1108.0);
         model->B3SOIDDeg0 = Eg0; 
         model->B3SOIDDvtm = KboQ * Temp;

         Eg = 1.16 - 7.02e-4 * Temp * Temp / (Temp + 1108.0);
         /* ni is in cm^-3 */
         ni = 1.45e10 * (Temp / 300.15) * sqrt(Temp / 300.15) 
            * exp(21.5565981 - Eg / (2.0 * model->B3SOIDDvtm));


         /* loop through all the instances of the model */
	 /* MCJ: Length and Width not initialized */
         for (here = model->B3SOIDDinstances; here != NULL;
              here = here->B3SOIDDnextInstance) 
	 {    
              
	      if (here->B3SOIDDowner != ARCHme)
                      continue;
	      
	      here->B3SOIDDrbodyext = here->B3SOIDDbodySquares *
                                    model->B3SOIDDrbsh;
	      pSizeDependParamKnot = model->pSizeDependParamKnot;
              Size_Not_Found = 1;
	      while ((pSizeDependParamKnot != NULL) && Size_Not_Found)
	      {   if ((here->B3SOIDDl == pSizeDependParamKnot->Length)
		      && (here->B3SOIDDw == pSizeDependParamKnot->Width)
                      && (here->B3SOIDDrth0 == pSizeDependParamKnot->Rth0)
                      && (here->B3SOIDDcth0 == pSizeDependParamKnot->Cth0))
                  {   Size_Not_Found = 0;
		      here->pParam = pSizeDependParamKnot;
		  }
		  else
		  {   pLastKnot = pSizeDependParamKnot;
		      pSizeDependParamKnot = pSizeDependParamKnot->pNext;
		  }
              }

	      if (Size_Not_Found)
	      {   pParam = (struct b3soiddSizeDependParam *)tmalloc(
	                    sizeof(struct b3soiddSizeDependParam));
                  if (pLastKnot == NULL)
		      model->pSizeDependParamKnot = pParam;
                  else
		      pLastKnot->pNext = pParam;
                  pParam->pNext = NULL;
                  here->pParam = pParam;

		  Ldrn = here->B3SOIDDl;
		  Wdrn = here->B3SOIDDw;
                  pParam->Length = Ldrn;
                  pParam->Width = Wdrn;
                  pParam->Rth0 = here->B3SOIDDrth0;
                  pParam->Cth0 = here->B3SOIDDcth0;
		  
                  T0 = pow(Ldrn, model->B3SOIDDLln);
                  T1 = pow(Wdrn, model->B3SOIDDLwn);
                  tmp1 = model->B3SOIDDLl / T0 + model->B3SOIDDLw / T1
                       + model->B3SOIDDLwl / (T0 * T1);
                  pParam->B3SOIDDdl = model->B3SOIDDLint + tmp1;
                  pParam->B3SOIDDdlc = model->B3SOIDDdlc + tmp1;

                  T2 = pow(Ldrn, model->B3SOIDDWln);
                  T3 = pow(Wdrn, model->B3SOIDDWwn);
                  tmp2 = model->B3SOIDDWl / T2 + model->B3SOIDDWw / T3
                       + model->B3SOIDDWwl / (T2 * T3);
                  pParam->B3SOIDDdw = model->B3SOIDDWint + tmp2;
                  pParam->B3SOIDDdwc = model->B3SOIDDdwc + tmp2;

                  pParam->B3SOIDDleff = here->B3SOIDDl - 2.0 * pParam->B3SOIDDdl;
                  if (pParam->B3SOIDDleff <= 0.0)
	          {   IFuid namarray[2];
                      namarray[0] = model->B3SOIDDmodName;
                      namarray[1] = here->B3SOIDDname;
                      (*(SPfrontEnd->IFerror))(ERR_FATAL,
                      "B3SOIDD: mosfet %s, model %s: Effective channel length <= 0",
                       namarray);
                      return(E_BADPARM);
                  }

                  pParam->B3SOIDDweff = here->B3SOIDDw - 2.0 * pParam->B3SOIDDdw;
                  if (pParam->B3SOIDDweff <= 0.0)
	          {   IFuid namarray[2];
                      namarray[0] = model->B3SOIDDmodName;
                      namarray[1] = here->B3SOIDDname;
                      (*(SPfrontEnd->IFerror))(ERR_FATAL,
                      "B3SOIDD: mosfet %s, model %s: Effective channel width <= 0",
                       namarray);
                      return(E_BADPARM);
                  }

                  pParam->B3SOIDDleffCV = here->B3SOIDDl - 2.0 * pParam->B3SOIDDdlc;
                  if (pParam->B3SOIDDleffCV <= 0.0)
	          {   IFuid namarray[2];
                      namarray[0] = model->B3SOIDDmodName;
                      namarray[1] = here->B3SOIDDname;
                      (*(SPfrontEnd->IFerror))(ERR_FATAL,
                      "B3SOIDD: mosfet %s, model %s: Effective channel length for C-V <= 0",
                       namarray);
                      return(E_BADPARM);
                  }

                  pParam->B3SOIDDweffCV = here->B3SOIDDw - 2.0 * pParam->B3SOIDDdwc;
                  if (pParam->B3SOIDDweffCV <= 0.0)
	          {   IFuid namarray[2];
                      namarray[0] = model->B3SOIDDmodName;
                      namarray[1] = here->B3SOIDDname;
                      (*(SPfrontEnd->IFerror))(ERR_FATAL,
                      "B3SOIDD: mosfet %s, model %s: Effective channel width for C-V <= 0",
                       namarray);
                      return(E_BADPARM);
                  }

                  /* Not binned - START */
                  pParam->B3SOIDDat = model->B3SOIDDat;
                  pParam->B3SOIDDgamma1 = model->B3SOIDDgamma1;
                  pParam->B3SOIDDgamma2 = model->B3SOIDDgamma2;
                  pParam->B3SOIDDvbx = model->B3SOIDDvbx;
                  pParam->B3SOIDDvbm = model->B3SOIDDvbm;
                  pParam->B3SOIDDxt = model->B3SOIDDxt;
                  pParam->B3SOIDDkt1 = model->B3SOIDDkt1;
                  pParam->B3SOIDDkt1l = model->B3SOIDDkt1l;
                  pParam->B3SOIDDkt2 = model->B3SOIDDkt2;
                  pParam->B3SOIDDua1 = model->B3SOIDDua1;
                  pParam->B3SOIDDub1 = model->B3SOIDDub1;
                  pParam->B3SOIDDuc1 = model->B3SOIDDuc1;
                  pParam->B3SOIDDute = model->B3SOIDDute;
                  pParam->B3SOIDDprt = model->B3SOIDDprt;
                  /* Not binned - END */

		  /* CV model */
		  pParam->B3SOIDDcgsl = model->B3SOIDDcgsl;
		  pParam->B3SOIDDcgdl = model->B3SOIDDcgdl;
		  pParam->B3SOIDDckappa = model->B3SOIDDckappa;
		  pParam->B3SOIDDcf = model->B3SOIDDcf;
		  pParam->B3SOIDDclc = model->B3SOIDDclc;
		  pParam->B3SOIDDcle = model->B3SOIDDcle;

                  pParam->B3SOIDDabulkCVfactor = pow(1.0+(pParam->B3SOIDDclc
					     / pParam->B3SOIDDleff),
					     pParam->B3SOIDDcle);

/* Added for binning - START */
		  if (model->B3SOIDDbinUnit == 1)
		  {   Inv_L = 1.0e-6 / pParam->B3SOIDDleff;
		      Inv_W = 1.0e-6 / pParam->B3SOIDDweff;
		      Inv_LW = 1.0e-12 / (pParam->B3SOIDDleff
			     * pParam->B3SOIDDweff);
		  }
		  else
		  {   Inv_L = 1.0 / pParam->B3SOIDDleff;
		      Inv_W = 1.0 / pParam->B3SOIDDweff;
		      Inv_LW = 1.0 / (pParam->B3SOIDDleff
			     * pParam->B3SOIDDweff);
		  }
		  pParam->B3SOIDDnpeak = model->B3SOIDDnpeak
				     + model->B3SOIDDlnpeak * Inv_L
				     + model->B3SOIDDwnpeak * Inv_W
				     + model->B3SOIDDpnpeak * Inv_LW;
		  pParam->B3SOIDDnsub = model->B3SOIDDnsub
				    + model->B3SOIDDlnsub * Inv_L
				    + model->B3SOIDDwnsub * Inv_W
				    + model->B3SOIDDpnsub * Inv_LW;
		  pParam->B3SOIDDngate = model->B3SOIDDngate
				     + model->B3SOIDDlngate * Inv_L
				     + model->B3SOIDDwngate * Inv_W
				     + model->B3SOIDDpngate * Inv_LW;
		  pParam->B3SOIDDvth0 = model->B3SOIDDvth0
				    + model->B3SOIDDlvth0 * Inv_L
				    + model->B3SOIDDwvth0 * Inv_W
				    + model->B3SOIDDpvth0 * Inv_LW;
		  pParam->B3SOIDDk1 = model->B3SOIDDk1
				  + model->B3SOIDDlk1 * Inv_L
				  + model->B3SOIDDwk1 * Inv_W
				  + model->B3SOIDDpk1 * Inv_LW;
		  pParam->B3SOIDDk2 = model->B3SOIDDk2
				  + model->B3SOIDDlk2 * Inv_L
				  + model->B3SOIDDwk2 * Inv_W
				  + model->B3SOIDDpk2 * Inv_LW;
		  pParam->B3SOIDDk3 = model->B3SOIDDk3
				  + model->B3SOIDDlk3 * Inv_L
				  + model->B3SOIDDwk3 * Inv_W
				  + model->B3SOIDDpk3 * Inv_LW;
		  pParam->B3SOIDDk3b = model->B3SOIDDk3b
				   + model->B3SOIDDlk3b * Inv_L
				   + model->B3SOIDDwk3b * Inv_W
				   + model->B3SOIDDpk3b * Inv_LW;
		  pParam->B3SOIDDvbsa = model->B3SOIDDvbsa
				   + model->B3SOIDDlvbsa * Inv_L
				   + model->B3SOIDDwvbsa * Inv_W
				   + model->B3SOIDDpvbsa * Inv_LW;
		  pParam->B3SOIDDdelp = model->B3SOIDDdelp
				   + model->B3SOIDDldelp * Inv_L
				   + model->B3SOIDDwdelp * Inv_W
				   + model->B3SOIDDpdelp * Inv_LW;
		  pParam->B3SOIDDkb1 = model->B3SOIDDkb1
				   + model->B3SOIDDlkb1 * Inv_L
				   + model->B3SOIDDwkb1 * Inv_W
				   + model->B3SOIDDpkb1 * Inv_LW;
		  pParam->B3SOIDDkb3 = model->B3SOIDDkb3
				   + model->B3SOIDDlkb3 * Inv_L
				   + model->B3SOIDDwkb3 * Inv_W
				   + model->B3SOIDDpkb3 * Inv_LW;
		  pParam->B3SOIDDdvbd0 = model->B3SOIDDdvbd0
				   + model->B3SOIDDldvbd0 * Inv_L
				   + model->B3SOIDDwdvbd0 * Inv_W
				   + model->B3SOIDDpdvbd0 * Inv_LW;
		  pParam->B3SOIDDdvbd1 = model->B3SOIDDdvbd1
				   + model->B3SOIDDldvbd1 * Inv_L
				   + model->B3SOIDDwdvbd1 * Inv_W
				   + model->B3SOIDDpdvbd1 * Inv_LW;
		  pParam->B3SOIDDw0 = model->B3SOIDDw0
				  + model->B3SOIDDlw0 * Inv_L
				  + model->B3SOIDDww0 * Inv_W