b3soitemp.c

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

/**********
Copyright 1990 Regents of the University of California.  All rights reserved.
Author: 1998 Samuel Fung, Dennis Sinitsky and Stephen Tang
File: b3soitemp.c          98/5/01
Modified by Pin Su	99/2/15
Modified by Pin Su 99/4/30
Modified by Pin Su, Wei Jin 99/9/27
Modified by Pin Su 00/3/1
Modified by Pin Su 01/2/15
Modified by Pin Su and Hui Wan 02/3/5
Modified by Pin Su 02/5/20
Modified by Paolo Nenzi 2002
**********/

/* Lmin, Lmax, Wmin, Wmax */

#include "ngspice.h"
#include "smpdefs.h"
#include "cktdefs.h"
#include "b3soidef.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 Charge_q 1.60219e-19
#define Eg300 1.115   /*  energy gap at 300K  */

#define MAX_EXPL 2.688117142e+43
#define MIN_EXPL 3.720075976e-44
#define EXPL_THRESHOLD 100.0
#define DEXP(A,B) {                                                        \
        if (A > EXPL_THRESHOLD) {                                              \
            B = MAX_EXPL*(1.0+(A)-EXPL_THRESHOLD);                              \
        } else if (A < -EXPL_THRESHOLD)  {                                                \
            B = MIN_EXPL;                                                      \
        } else   {                                                            \
            B = exp(A);                                                       \
        }                                                                     \
    }

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

/* v2.0 release */
double tmp3, T7;


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

	 Tnom = model->B3SOItnom;
	 TempRatio = Temp / Tnom;

	 model->B3SOIvcrit = CONSTvt0 * log(CONSTvt0 / (CONSTroot2 * 1.0e-14));
         model->B3SOIfactor1 = sqrt(EPSSI / EPSOX * model->B3SOItox);

         Vtm0 = KboQ * Tnom;
         Eg0 = 1.16 - 7.02e-4 * Tnom * Tnom / (Tnom + 1108.0);
         model->B3SOIeg0 = Eg0; 
         model->B3SOIvtm = 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->B3SOIvtm));


         /* loop through all the instances of the model */
	 /* MCJ: Length and Width not initialized */
         for (here = model->B3SOIinstances; here != NULL;
              here = here->B3SOInextInstance) 
	 {    
              
	      if (here->B3SOIowner != ARCHme)
                      continue;

	      here->B3SOIrbodyext = here->B3SOIbodySquares *
                                    model->B3SOIrbsh;
	      pSizeDependParamKnot = model->pSizeDependParamKnot;
              Size_Not_Found = 1;
	      while ((pSizeDependParamKnot != NULL) && Size_Not_Found)
	      {   if ((here->B3SOIl == pSizeDependParamKnot->Length)
		      && (here->B3SOIw == pSizeDependParamKnot->Width)
                      && (here->B3SOIrth0 == pSizeDependParamKnot->Rth0)
                      && (here->B3SOIcth0 == pSizeDependParamKnot->Cth0))
                  {   Size_Not_Found = 0;
		      here->pParam = pSizeDependParamKnot;
		      pParam = here->pParam; /* v2.2.3 bug fix */
		  }
		  else
		  {   pLastKnot = pSizeDependParamKnot;
		      pSizeDependParamKnot = pSizeDependParamKnot->pNext;
		  }
              }

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

		  Ldrn = here->B3SOIl;
		  Wdrn = here->B3SOIw;
                  pParam->Length = Ldrn;
                  pParam->Width = Wdrn;
                  pParam->Rth0 = here->B3SOIrth0;
                  pParam->Cth0 = here->B3SOIcth0;
		  
                  T0 = pow(Ldrn, model->B3SOILln);
                  T1 = pow(Wdrn, model->B3SOILwn);
                  tmp1 = model->B3SOILl / T0 + model->B3SOILw / T1
                       + model->B3SOILwl / (T0 * T1);
                  pParam->B3SOIdl = model->B3SOILint + tmp1;

/* v2.2.3 */
                  tmp1 = model->B3SOILlc / T0 + model->B3SOILwc / T1
                       + model->B3SOILwlc / (T0 * T1);
                  pParam->B3SOIdlc = model->B3SOIdlc + tmp1;

/* v3.0 */
                  pParam->B3SOIdlcig = model->B3SOIdlcig + tmp1;


                  T2 = pow(Ldrn, model->B3SOIWln);
                  T3 = pow(Wdrn, model->B3SOIWwn);
                  tmp2 = model->B3SOIWl / T2 + model->B3SOIWw / T3
                       + model->B3SOIWwl / (T2 * T3);
                  pParam->B3SOIdw = model->B3SOIWint + tmp2;

/* v2.2.3 */
                  tmp2 = model->B3SOIWlc / T2 + model->B3SOIWwc / T3
                       + model->B3SOIWwlc / (T2 * T3);
                  pParam->B3SOIdwc = model->B3SOIdwc + tmp2;


                  pParam->B3SOIleff = here->B3SOIl - 2.0 * pParam->B3SOIdl;
                  if (pParam->B3SOIleff <= 0.0)
	          {   IFuid namarray[2];
                      namarray[0] = model->B3SOImodName;
                      namarray[1] = here->B3SOIname;
                      (*(SPfrontEnd->IFerror))(ERR_FATAL,
                      "B3SOI: mosfet %s, model %s: Effective channel length <= 0",
                       namarray);
                      return(E_BADPARM);
                  }

                  pParam->B3SOIweff = here->B3SOIw - here->B3SOInbc * model->B3SOIdwbc
                     - (2.0 - here->B3SOInbc) * pParam->B3SOIdw;
                  if (pParam->B3SOIweff <= 0.0)
	          {   IFuid namarray[2];
                      namarray[0] = model->B3SOImodName;
                      namarray[1] = here->B3SOIname;
                      (*(SPfrontEnd->IFerror))(ERR_FATAL,
                      "B3SOI: mosfet %s, model %s: Effective channel width <= 0",
                       namarray);
                      return(E_BADPARM);
                  }

                  pParam->B3SOIwdiod = pParam->B3SOIweff / here->B3SOInseg + here->B3SOIpdbcp;
                  pParam->B3SOIwdios = pParam->B3SOIweff / here->B3SOInseg + here->B3SOIpsbcp;

                  pParam->B3SOIleffCV = here->B3SOIl - 2.0 * pParam->B3SOIdlc;
                  if (pParam->B3SOIleffCV <= 0.0)
	          {   IFuid namarray[2];
                      namarray[0] = model->B3SOImodName;
                      namarray[1] = here->B3SOIname;
                      (*(SPfrontEnd->IFerror))(ERR_FATAL,
                      "B3SOI: mosfet %s, model %s: Effective channel length for C-V <= 0",
                       namarray);
                      return(E_BADPARM);
                  }

                  pParam->B3SOIweffCV = here->B3SOIw - here->B3SOInbc * model->B3SOIdwbc
                     - (2.0 - here->B3SOInbc) * pParam->B3SOIdwc;
                  if (pParam->B3SOIweffCV <= 0.0)
	          {   IFuid namarray[2];
                      namarray[0] = model->B3SOImodName;
                      namarray[1] = here->B3SOIname;
                      (*(SPfrontEnd->IFerror))(ERR_FATAL,
                      "B3SOI: mosfet %s, model %s: Effective channel width for C-V <= 0",
                       namarray);
                      return(E_BADPARM);
                  }

                  pParam->B3SOIwdiodCV = pParam->B3SOIweffCV / here->B3SOInseg + here->B3SOIpdbcp;
                  pParam->B3SOIwdiosCV = pParam->B3SOIweffCV / here->B3SOInseg + here->B3SOIpsbcp;

                  pParam->B3SOIleffCVb = here->B3SOIl - 2.0 * pParam->B3SOIdlc - model->B3SOIdlcb;
                  if (pParam->B3SOIleffCVb <= 0.0)
                  {  
                     IFuid namarray[2];
                     namarray[0] = model->B3SOImodName;
                     namarray[1] = here->B3SOIname;
                     (*(SPfrontEnd->IFerror))(ERR_FATAL,
                     "B3SOI: mosfet %s, model %s: Effective channel length for C-V (body) <= 0",
                     namarray);
                     return(E_BADPARM);
                  }

                  pParam->B3SOIleffCVbg = pParam->B3SOIleffCVb + 2 * model->B3SOIdlbg;
                  if (pParam->B3SOIleffCVbg <= 0.0)
                  { 
                     IFuid namarray[2];
                     namarray[0] = model->B3SOImodName;
                     namarray[1] = here->B3SOIname;
                     (*(SPfrontEnd->IFerror))(ERR_FATAL,
                     "B3SOI: mosfet %s, model %s: Effective channel length for C-V (backgate) <= 0",
                     namarray);
                     return(E_BADPARM);
                  }

                  /* Not binned - START */
		  pParam->B3SOIat = model->B3SOIat;
		  pParam->B3SOIgamma1 = model->B3SOIgamma1;
		  pParam->B3SOIgamma2 = model->B3SOIgamma2;
		  pParam->B3SOIvbx = model->B3SOIvbx;
		  pParam->B3SOIvbm = model->B3SOIvbm;
		  pParam->B3SOIxt = model->B3SOIxt;
		  pParam->B3SOIkt1 = model->B3SOIkt1;
		  pParam->B3SOIkt1l = model->B3SOIkt1l;
		  pParam->B3SOIkt2 = model->B3SOIkt2;
		  pParam->B3SOIua1 = model->B3SOIua1;
		  pParam->B3SOIub1 = model->B3SOIub1;
		  pParam->B3SOIuc1 = model->B3SOIuc1;
		  pParam->B3SOIute = model->B3SOIute;
		  pParam->B3SOIprt = model->B3SOIprt;
                  /* Not binned - END */

		  /* CV model */
		  pParam->B3SOIcgsl = model->B3SOIcgsl;
		  pParam->B3SOIcgdl = model->B3SOIcgdl;
		  pParam->B3SOIckappa = model->B3SOIckappa;
		  pParam->B3SOIcf = model->B3SOIcf;
		  pParam->B3SOIclc = model->B3SOIclc;
		  pParam->B3SOIcle = model->B3SOIcle;

                  pParam->B3SOIabulkCVfactor = 1.0 + pow((pParam->B3SOIclc / pParam->B3SOIleff),
					     pParam->B3SOIcle);

                  /* Added for binning - START */
		  if (model->B3SOIbinUnit == 1)
		  {   Inv_L = 1.0e-6 / pParam->B3SOIleff;
		      Inv_W = 1.0e-6 / pParam->B3SOIweff;
		      Inv_LW = 1.0e-12 / (pParam->B3SOIleff
			     * pParam->B3SOIweff);
		  }
		  else
		  {   Inv_L = 1.0 / pParam->B3SOIleff;
		      Inv_W = 1.0 / pParam->B3SOIweff;
		      Inv_LW = 1.0 / (pParam->B3SOIleff
			     * pParam->B3SOIweff);
		  }
		  pParam->B3SOInpeak = model->B3SOInpeak
				     + model->B3SOIlnpeak * Inv_L
				     + model->B3SOIwnpeak * Inv_W
				     + model->B3SOIpnpeak * Inv_LW;
		  pParam->B3SOInsub = model->B3SOInsub
				    + model->B3SOIlnsub * Inv_L
				    + model->B3SOIwnsub * Inv_W
				    + model->B3SOIpnsub * Inv_LW;
		  pParam->B3SOIngate = model->B3SOIngate
				     + model->B3SOIlngate * Inv_L
				     + model->B3SOIwngate * Inv_W
				     + model->B3SOIpngate * Inv_LW;
		  pParam->B3SOIvth0 = model->B3SOIvth0
				    + model->B3SOIlvth0 * Inv_L
				    + model->B3SOIwvth0 * Inv_W
				    + model->B3SOIpvth0 * Inv_LW;
		  pParam->B3SOIk1 = model->B3SOIk1
				  + model->B3SOIlk1 * Inv_L
				  + model->B3SOIwk1 * Inv_W
				  + model->B3SOIpk1 * Inv_LW;
		  pParam->B3SOIk2 = model->B3SOIk2
				  + model->B3SOIlk2 * Inv_L
				  + model->B3SOIwk2 * Inv_W
				  + model->B3SOIpk2 * Inv_LW;
		  pParam->B3SOIk1w1 = model->B3SOIk1w1
				  + model->B3SOIlk1w1 * Inv_L
				  + model->B3SOIwk1w1 * Inv_W
				  + model->B3SOIpk1w1 * Inv_LW;
		  pParam->B3SOIk1w2 = model->B3SOIk1w2
				  + model->B3SOIlk1w2 * Inv_L
				  + model->B3SOIwk1w2 * Inv_W
				  + model->B3SOIpk1w2 * Inv_LW;
		  pParam->B3SOIk3 = model->B3SOIk3
				  + model->B3SOIlk3 * Inv_L
				  + model->B3SOIwk3 * Inv_W
				  + model->B3SOIpk3 * Inv_LW;
		  pParam->B3SOIk3b = model->B3SOIk3b
				   + model->B3SOIlk3b * Inv_L
				   + model->B3SOIwk3b * Inv_W
				   + model->B3SOIpk3b * Inv_LW;
		  pParam->B3SOIkb1 = model->B3SOIkb1
				   + model->B3SOIlkb1 * Inv_L
				   + model->B3SOIwkb1 * Inv_W
				   + model->B3SOIpkb1 * Inv_LW;
		  pParam->B3SOIw0 = model->B3SOIw0
				  + model->B3SOIlw0 * Inv_L
				  + model->B3SOIww0 * Inv_W
				  + model->B3SOIpw0 * Inv_LW;
		  pParam->B3SOInlx = model->B3SOInlx
				   + model->B3SOIlnlx * Inv_L
				   + model->B3SOIwnlx * Inv_W
				   + model->B3SOIpnlx * Inv_LW;
		  pParam->B3SOIdvt0 = model->B3SOIdvt0
				    + model->B3SOIldvt0 * Inv_L
				    + model->B3SOIwdvt0 * Inv_W
				    + model->B3SOIpdvt0 * Inv_LW;
		  pParam->B3SOIdvt1 = model->B3SOIdvt1
				    + model->B3SOIldvt1 * Inv_L
				    + model->B3SOIwdvt1 * Inv_W
				    + model->B3SOIpdvt1 * Inv_LW;
		  pParam->B3SOIdvt2 = model->B3SOIdvt2
				    + model->B3SOIldvt2 * Inv_L
				    + model->B3SOIwdvt2 * Inv_W
				    + model->B3SOIpdvt2 * Inv_LW;
		  pParam->B3SOIdvt0w = model->B3SOIdvt0w
				    + model->B3SOIldvt0w * Inv_L
				    + model->B3SOIwdvt0w * Inv_W
				    + model->B3SOIpdvt0w * Inv_LW;
		  pParam->B3SOIdvt1w = model->B3SOIdvt1w
				    + model->B3SOIldvt1w * Inv_L
				    + model->B3SOIwdvt1w * Inv_W
				    + model->B3SOIpdvt1w * Inv_LW;
		  pParam->B3SOIdvt2w = model->B3SOIdvt2w
				    + model->B3SOIldvt2w * Inv_L
				    + model->B3SOIwdvt2w * Inv_W
				    + model->B3SOIpdvt2w * Inv_LW;
		  pParam->B3SOIu0 = model->B3SOIu0
				  + model->B3SOIlu0 * Inv_L
				  + model->B3SOIwu0 * Inv_W
				  + model->B3SOIpu0 * Inv_LW;
		  pParam->B3SOIua = model->B3SOIua
				  + model->B3SOIlua * Inv_L
				  + model->B3SOIwua * Inv_W
				  + model->B3SOIpua * Inv_LW;