b3ld.c

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

/**** BSIM3v3.2.4, Released by Xuemei Xi 12/21/2001 ****/

/**********
 * Copyright 2001 Regents of the University of California. All rights reserved.
 * File: b3ld.c of BSIM3v3.2.4
 * Author: 1991 JianHui Huang and Min-Chie Jeng.
 * Modified by Mansun Chan (1995).
 * Author: 1997-1999 Weidong Liu.
 * Author: 2001 Xuemei Xi
 * Modified by Xuemei Xi, 10/05, 12/21, 2001.
 * Modified by Paolo Nenzi 2002 and Dietmar Warning 2003
 **********/

#include "ngspice.h"
#include "cktdefs.h"
#include "bsim3def.h"
#include "trandefs.h"
#include "const.h"
#include "sperror.h"
#include "devdefs.h"
#include "suffix.h"

#define MAX_EXP 5.834617425e14
#define MIN_EXP 1.713908431e-15
#define EXP_THRESHOLD 34.0
#define EPSOX 3.453133e-11
#define EPSSI 1.03594e-10
#define Charge_q 1.60219e-19
#define DELTA_1 0.02
#define DELTA_2 0.02
#define DELTA_3 0.02
#define DELTA_4 0.02


int
BSIM3load (GENmodel *inModel, CKTcircuit *ckt)
{
BSIM3model *model = (BSIM3model*)inModel;
BSIM3instance *here;
double SourceSatCurrent, DrainSatCurrent;
double ag0, qgd, qgs, qgb, von, cbhat, VgstNVt, ExpVgst;
double cdrain, cdhat, cdreq, ceqbd, ceqbs, ceqqb, ceqqd, ceqqg, ceq, geq;
double czbd, czbdsw, czbdswg, czbs, czbssw, czbsswg, evbd, evbs, arg, sarg;
double delvbd, delvbs, delvds, delvgd, delvgs;
double Vfbeff, dVfbeff_dVg, dVfbeff_dVd = 0.0, dVfbeff_dVb, V3, V4;
double gcbdb, gcbgb, gcbsb, gcddb, gcdgb, gcdsb, gcgdb, gcggb, gcgsb, gcsdb;
double gcsgb, gcssb, MJ, MJSW, MJSWG;
double vbd, vbs, vds, vgb, vgd, vgs, vgdo, xfact;
double qgate = 0.0, qbulk = 0.0, qdrn = 0.0, qsrc;
double qinoi, cqgate, cqbulk, cqdrn;
double Vds, Vgs, Vbs, Gmbs, FwdSum, RevSum;
double Vgs_eff, Vfb, dVfb_dVb = 0.0, dVfb_dVd = 0.0;
double Phis, dPhis_dVb, sqrtPhis, dsqrtPhis_dVb, Vth, dVth_dVb, dVth_dVd;
double Vgst, dVgst_dVg, dVgst_dVb, dVgs_eff_dVg, Nvtm;
double Vtm;
double n, dn_dVb, dn_dVd, voffcv, noff, dnoff_dVd, dnoff_dVb;
double ExpArg, V0, CoxWLcen, QovCox, LINK;
double DeltaPhi, dDeltaPhi_dVg, dDeltaPhi_dVd, dDeltaPhi_dVb;
double Cox, Tox, Tcen, dTcen_dVg, dTcen_dVd, dTcen_dVb;
double Ccen, Coxeff, dCoxeff_dVg, dCoxeff_dVd, dCoxeff_dVb;
double Denomi, dDenomi_dVg, dDenomi_dVd, dDenomi_dVb;
double ueff, dueff_dVg, dueff_dVd, dueff_dVb; 
double Esat, Vdsat;
double EsatL, dEsatL_dVg, dEsatL_dVd, dEsatL_dVb;
double dVdsat_dVg, dVdsat_dVb, dVdsat_dVd, Vasat, dAlphaz_dVg, dAlphaz_dVb; 
double dVasat_dVg, dVasat_dVb, dVasat_dVd, Va, dVa_dVd, dVa_dVg, dVa_dVb; 
double Vbseff, dVbseff_dVb, VbseffCV, dVbseffCV_dVb; 
double Arg1, One_Third_CoxWL, Two_Third_CoxWL, Alphaz, CoxWL; 
double T0, dT0_dVg, dT0_dVd, dT0_dVb;
double T1, dT1_dVg, dT1_dVd, dT1_dVb;
double T2, dT2_dVg, dT2_dVd, dT2_dVb;
double T3, dT3_dVg, dT3_dVd, dT3_dVb;
double T4;
double T5;
double T6;
double T7;
double T8;
double T9;
double T10; 
double T11, T12;
double tmp, Abulk, dAbulk_dVb, Abulk0, dAbulk0_dVb;
double VACLM, dVACLM_dVg, dVACLM_dVd, dVACLM_dVb;
double VADIBL, dVADIBL_dVg, dVADIBL_dVd, dVADIBL_dVb;
double Xdep, dXdep_dVb, lt1, dlt1_dVb, ltw, dltw_dVb, Delt_vth, dDelt_vth_dVb;
double Theta0, dTheta0_dVb;
double TempRatio, tmp1, tmp2, tmp3, tmp4;
double DIBL_Sft, dDIBL_Sft_dVd, Lambda, dLambda_dVg;
double Idtot, Ibtot;
double tempv, a1, ScalingFactor;

double Vgsteff, dVgsteff_dVg, dVgsteff_dVd, dVgsteff_dVb; 
double Vdseff, dVdseff_dVg, dVdseff_dVd, dVdseff_dVb; 
double VdseffCV, dVdseffCV_dVg, dVdseffCV_dVd, dVdseffCV_dVb; 
double diffVds, dAbulk_dVg;
double beta, dbeta_dVg, dbeta_dVd, dbeta_dVb;
double gche, dgche_dVg, dgche_dVd, dgche_dVb;
double fgche1, dfgche1_dVg, dfgche1_dVd, dfgche1_dVb;
double fgche2, dfgche2_dVg, dfgche2_dVd, dfgche2_dVb;
double Idl, dIdl_dVg, dIdl_dVd, dIdl_dVb;
double Idsa, dIdsa_dVg, dIdsa_dVd, dIdsa_dVb;
double Ids, Gm, Gds, Gmb;
double Isub, Gbd, Gbg, Gbb;
double VASCBE, dVASCBE_dVg, dVASCBE_dVd, dVASCBE_dVb;
double CoxWovL;
double Rds, dRds_dVg, dRds_dVb, WVCox, WVCoxRds;
double Vgst2Vtm, VdsatCV, dVdsatCV_dVg, dVdsatCV_dVb;
double Leff, Weff, dWeff_dVg, dWeff_dVb;
double AbulkCV, dAbulkCV_dVb;
double qgdo, qgso, cgdo, cgso;

double qcheq = 0.0, qdef, gqdef = 0.0, cqdef, cqcheq, gtau_diff, gtau_drift;
double gcqdb = 0.0,gcqsb = 0.0, gcqgb = 0.0,gcqbb = 0.0;
double dxpart, sxpart, ggtg, ggtd, ggts, ggtb;
double ddxpart_dVd, ddxpart_dVg, ddxpart_dVb, ddxpart_dVs;
double dsxpart_dVd, dsxpart_dVg, dsxpart_dVb, dsxpart_dVs;

double gbspsp, gbbdp, gbbsp, gbspg, gbspb, gbspdp; 
double gbdpdp, gbdpg, gbdpb, gbdpsp; 
double Cgg, Cgd, Cgb, Cdg, Cdd, Cds;
double Csg, Csd, Css, Csb, Cbg, Cbd, Cbb;
double Cgg1, Cgb1, Cgd1, Cbg1, Cbb1, Cbd1, Qac0, Qsub0;
double dQac0_dVg, dQac0_dVd = 0.0, dQac0_dVb, dQsub0_dVg;
double dQsub0_dVd, dQsub0_dVb;
   
double m;

struct bsim3SizeDependParam *pParam;
int ByPass, Check, ChargeComputationNeeded, error;

ScalingFactor = 1.0e-9;
ChargeComputationNeeded =  
                 ((ckt->CKTmode & (MODEAC | MODETRAN | MODEINITSMSIG)) ||
                 ((ckt->CKTmode & MODETRANOP) && (ckt->CKTmode & MODEUIC)))
                 ? 1 : 0;
for (; model != NULL; model = model->BSIM3nextModel)
{    for (here = model->BSIM3instances; here != NULL; 
          here = here->BSIM3nextInstance)
     {    
	  if (here->BSIM3owner != ARCHme)
	    continue;
     	  Check = 1;
          ByPass = 0;
	  pParam = here->pParam;
          if ((ckt->CKTmode & MODEINITSMSIG))
	  {   vbs = *(ckt->CKTstate0 + here->BSIM3vbs);
              vgs = *(ckt->CKTstate0 + here->BSIM3vgs);
              vds = *(ckt->CKTstate0 + here->BSIM3vds);
              qdef = *(ckt->CKTstate0 + here->BSIM3qdef);
          }
	  else if ((ckt->CKTmode & MODEINITTRAN))
	  {   vbs = *(ckt->CKTstate1 + here->BSIM3vbs);
              vgs = *(ckt->CKTstate1 + here->BSIM3vgs);
              vds = *(ckt->CKTstate1 + here->BSIM3vds);
              qdef = *(ckt->CKTstate1 + here->BSIM3qdef);
          }
	  else if ((ckt->CKTmode & MODEINITJCT) && !here->BSIM3off)
	  {   vds = model->BSIM3type * here->BSIM3icVDS;
              vgs = model->BSIM3type * here->BSIM3icVGS;
              vbs = model->BSIM3type * here->BSIM3icVBS;
              qdef = 0.0;

              if ((vds == 0.0) && (vgs == 0.0) && (vbs == 0.0) && 
                  ((ckt->CKTmode & (MODETRAN | MODEAC|MODEDCOP |
                   MODEDCTRANCURVE)) || (!(ckt->CKTmode & MODEUIC))))
	      {   vbs = 0.0;
                  vgs = model->BSIM3type * pParam->BSIM3vth0 + 0.1;
                  vds = 0.1;
              }
          }
	  else if ((ckt->CKTmode & (MODEINITJCT | MODEINITFIX)) && 
                  (here->BSIM3off)) 
          {    qdef = vbs = vgs = vds = 0.0;
	  }
          else
	  {
#ifndef PREDICTOR
               if ((ckt->CKTmode & MODEINITPRED))
	       {   xfact = ckt->CKTdelta / ckt->CKTdeltaOld[1];
                   *(ckt->CKTstate0 + here->BSIM3vbs) = 
                         *(ckt->CKTstate1 + here->BSIM3vbs);
                   vbs = (1.0 + xfact)* (*(ckt->CKTstate1 + here->BSIM3vbs))
                         - (xfact * (*(ckt->CKTstate2 + here->BSIM3vbs)));
                   *(ckt->CKTstate0 + here->BSIM3vgs) = 
                         *(ckt->CKTstate1 + here->BSIM3vgs);
                   vgs = (1.0 + xfact)* (*(ckt->CKTstate1 + here->BSIM3vgs))
                         - (xfact * (*(ckt->CKTstate2 + here->BSIM3vgs)));
                   *(ckt->CKTstate0 + here->BSIM3vds) = 
                         *(ckt->CKTstate1 + here->BSIM3vds);
                   vds = (1.0 + xfact)* (*(ckt->CKTstate1 + here->BSIM3vds))
                         - (xfact * (*(ckt->CKTstate2 + here->BSIM3vds)));
                   *(ckt->CKTstate0 + here->BSIM3vbd) = 
                         *(ckt->CKTstate0 + here->BSIM3vbs)
                         - *(ckt->CKTstate0 + here->BSIM3vds);
                   *(ckt->CKTstate0 + here->BSIM3qdef) =
                         *(ckt->CKTstate1 + here->BSIM3qdef);
                   qdef = (1.0 + xfact)* (*(ckt->CKTstate1 + here->BSIM3qdef))
                        -(xfact * (*(ckt->CKTstate2 + here->BSIM3qdef)));
               }
	       else
	       {
#endif /* PREDICTOR */
                   vbs = model->BSIM3type
                       * (*(ckt->CKTrhsOld + here->BSIM3bNode)
                       - *(ckt->CKTrhsOld + here->BSIM3sNodePrime));
                   vgs = model->BSIM3type
                       * (*(ckt->CKTrhsOld + here->BSIM3gNode) 
                       - *(ckt->CKTrhsOld + here->BSIM3sNodePrime));
                   vds = model->BSIM3type
                       * (*(ckt->CKTrhsOld + here->BSIM3dNodePrime)
                       - *(ckt->CKTrhsOld + here->BSIM3sNodePrime));
                   qdef = model->BSIM3type
                        * (*(ckt->CKTrhsOld + here->BSIM3qNode));
#ifndef PREDICTOR
               }
#endif /* PREDICTOR */

               vbd = vbs - vds;
               vgd = vgs - vds;
               vgdo = *(ckt->CKTstate0 + here->BSIM3vgs)
                    - *(ckt->CKTstate0 + here->BSIM3vds);
               delvbs = vbs - *(ckt->CKTstate0 + here->BSIM3vbs);
               delvbd = vbd - *(ckt->CKTstate0 + here->BSIM3vbd);
               delvgs = vgs - *(ckt->CKTstate0 + here->BSIM3vgs);
               delvds = vds - *(ckt->CKTstate0 + here->BSIM3vds);
               delvgd = vgd - vgdo;

               if (here->BSIM3mode >= 0)
               {   Idtot = here->BSIM3cd + here->BSIM3csub - here->BSIM3cbd;
                   cdhat = Idtot - here->BSIM3gbd * delvbd
                         + (here->BSIM3gmbs + here->BSIM3gbbs) * delvbs
                         + (here->BSIM3gm + here->BSIM3gbgs) * delvgs
                         + (here->BSIM3gds + here->BSIM3gbds) * delvds;
                   Ibtot = here->BSIM3cbs + here->BSIM3cbd - here->BSIM3csub;
                   cbhat = Ibtot + here->BSIM3gbd * delvbd
                         + (here->BSIM3gbs - here->BSIM3gbbs) * delvbs
                         - here->BSIM3gbgs * delvgs
                         - here->BSIM3gbds * delvds;
               }
               else
               {   Idtot = here->BSIM3cd - here->BSIM3cbd;
                   cdhat = Idtot - (here->BSIM3gbd - here->BSIM3gmbs) * delvbd
                         + here->BSIM3gm * delvgd
                         - here->BSIM3gds * delvds;
                   Ibtot = here->BSIM3cbs + here->BSIM3cbd - here->BSIM3csub;
                   cbhat = Ibtot + here->BSIM3gbs * delvbs
                         + (here->BSIM3gbd - here->BSIM3gbbs) * delvbd
                         - here->BSIM3gbgs * delvgd
                         + here->BSIM3gbds * delvds;
               }

#ifndef NOBYPASS
           /* following should be one big if connected by && all over
            * the place, but some C compilers can't handle that, so
            * we split it up here to let them digest it in stages
            */

               if ((!(ckt->CKTmode & MODEINITPRED)) && (ckt->CKTbypass))
               if ((fabs(delvbs) < (ckt->CKTreltol * MAX(fabs(vbs),
                   fabs(*(ckt->CKTstate0+here->BSIM3vbs))) + ckt->CKTvoltTol)))
               if ((fabs(delvbd) < (ckt->CKTreltol * MAX(fabs(vbd),
                   fabs(*(ckt->CKTstate0+here->BSIM3vbd))) + ckt->CKTvoltTol)))
               if ((fabs(delvgs) < (ckt->CKTreltol * MAX(fabs(vgs),
                   fabs(*(ckt->CKTstate0+here->BSIM3vgs))) + ckt->CKTvoltTol)))
               if ((fabs(delvds) < (ckt->CKTreltol * MAX(fabs(vds),
                   fabs(*(ckt->CKTstate0+here->BSIM3vds))) + ckt->CKTvoltTol)))
               if ((fabs(cdhat - Idtot) < ckt->CKTreltol
                   * MAX(fabs(cdhat),fabs(Idtot)) + ckt->CKTabstol))
               {   tempv = MAX(fabs(cbhat),fabs(Ibtot)) + ckt->CKTabstol;
                   if ((fabs(cbhat - Ibtot)) < ckt->CKTreltol * tempv)
		   {   /* bypass code */
                       vbs = *(ckt->CKTstate0 + here->BSIM3vbs);
                       vbd = *(ckt->CKTstate0 + here->BSIM3vbd);
                       vgs = *(ckt->CKTstate0 + here->BSIM3vgs);
                       vds = *(ckt->CKTstate0 + here->BSIM3vds);
                       qdef = *(ckt->CKTstate0 + here->BSIM3qdef);

                       vgd = vgs - vds;
                       vgb = vgs - vbs;

                       cdrain = here->BSIM3cd;
                       if ((ckt->CKTmode & (MODETRAN | MODEAC)) || 
                           ((ckt->CKTmode & MODETRANOP) && 
                           (ckt->CKTmode & MODEUIC)))
		       {   ByPass = 1;
                           qgate = here->BSIM3qgate;
                           qbulk = here->BSIM3qbulk;
                           qdrn = here->BSIM3qdrn;
			   goto line755;
                       }
		       else
		       {   goto line850;
		       }
                   }
               }

#endif /*NOBYPASS*/
               von = here->BSIM3von;
               if (*(ckt->CKTstate0 + here->BSIM3vds) >= 0.0)
	       {   vgs = DEVfetlim(vgs, *(ckt->CKTstate0+here->BSIM3vgs), von);
                   vds = vgs - vgd;
                   vds = DEVlimvds(vds, *(ckt->CKTstate0 + here->BSIM3vds));
                   vgd = vgs - vds;

               }
	       else
	       {   vgd = DEVfetlim(vgd, vgdo, von);
                   vds = vgs - vgd;
                   vds = -DEVlimvds(-vds, -(*(ckt->CKTstate0+here->BSIM3vds)));
                   vgs = vgd + vds;
               }

               if (vds >= 0.0)
	       {   vbs = DEVpnjlim(vbs, *(ckt->CKTstate0 + here->BSIM3vbs),
                                   CONSTvt0, model->BSIM3vcrit, &Check);
                   vbd = vbs - vds;

               }
	       else
	       {   vbd = DEVpnjlim(vbd, *(ckt->CKTstate0 + here->BSIM3vbd),
                                   CONSTvt0, model->BSIM3vcrit, &Check); 
                   vbs = vbd + vds;
               }
          }

          /* determine DC current and derivatives */
          vbd = vbs - vds;
          vgd = vgs - vds;
          vgb = vgs - vbs;

          /* Source/drain junction diode DC model begins */
          Nvtm = model->BSIM3vtm * model->BSIM3jctEmissionCoeff;
          /* acm model */
          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;