b3v0ld.c

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

/**********
Copyright 1990 Regents of the University of California.  All rights reserved.
Author: 1991 JianHui Huang and Min-Chie Jeng.
File: b3v0ld.c          1/3/92
Modified by Mansun Chan  (1995)
**********/

#include "ngspice.h"
#include "cktdefs.h"
#include "bsim3v0def.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
BSIM3v0load(GENmodel *inModel, CKTcircuit *ckt)
{
BSIM3v0model *model = (BSIM3v0model*)inModel;
BSIM3v0instance *here;
double SourceSatCurrent, DrainSatCurrent;
double ag0, qgd, qgs, qgb, von, cbhat = 0.0, VgstNVt, ExpVgst = 0.0;
double cdrain, cdhat = 0.0, cdreq, ceqbd, ceqbs, ceqqb, ceqqd, ceqqg, ceq, geq;
double czbd, czbdsw, czbs, czbssw, evbd, evbs, arg, sarg;
double delvbd, delvbs, delvds, delvgd, delvgs;
double Vfbeff, dVfbeff_dVg, dVfbeff_dVd, dVfbeff_dVb, V3, V4;
double gcbdb, gcbgb, gcbsb, gcddb, gcdgb, gcdsb, gcgdb, gcggb, gcgsb, gcsdb;
double gcsgb, gcssb, tol, PhiB, PhiBSW, MJ, MJSW;
double vbd, vbs, vds, vgb, vgd, vgs, vgdo, xfact;
double qgate = 0.0, qbulk = 0.0, qdrn = 0.0, qsrc, cqgate, cqbulk, cqdrn;
double Vds, Vgs, Vbs, Gmbs, FwdSum, RevSum;
double Vgs_eff, Vfb, dVfb_dVb, dVfb_dVd;
double Phis, dPhis_dVb, sqrtPhis, dsqrtPhis_dVb, Vth, dVth_dVb, dVth_dVd;
double Vgst, dVgs_eff_dVg;
double n, dn_dVb, Vtm;
double ExpArg;
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;
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, 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, dT4_dVg, dT4_dVd, dT4_dVb;
double T5;
double T6;
double T7;
double T8;
double T10;
double 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, Pmos_factor;
double tempv, a1;

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;
double dAbulk_dVg, dn_dVd ;
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 = 0.0, Weff, dWeff_dVg, dWeff_dVb;
double AbulkCV, dAbulkCV_dVb;
double qgdo, qgso, cgdo, cgso;

double qcheq, qdef, gqdef, cqdef, cqcheq, gtau_diff, gtau_drift;
double gcqdb,gcqsb,gcqgb,gcqbb;
double dxpart, sxpart;

double gbspsp, gbbdp, gbbsp, gbspg, gbspb, gbspdp; 
double gbdpdp, gbdpg, gbdpb, gbdpsp; 
double Cgg, Cgd, Cgb;
double Csg, Csd, Csb, Cbg, Cbd, Cbb;
double Cgg1, Cgb1, Cgd1, Cbg1, Cbb1, Cbd1, Qac0, Qsub0;
double dQac0_dVg, dQac0_dVd, dQac0_dVb, dQsub0_dVg, dQsub0_dVd, dQsub0_dVb;
   
struct bsim3v0SizeDependParam *pParam;
int ByPass, Check, ChargeComputationNeeded = 0, error;
double m = 0.0;

for (; model != NULL; model = model->BSIM3v0nextModel)
{    for (here = model->BSIM3v0instances; here != NULL; 
          here = here->BSIM3v0nextInstance)
     {    
     
          if (here->BSIM3v0owner != ARCHme)
                  continue;
		  
          Check = 1;
          ByPass = 0;
	  pParam = here->pParam;
          if ((ckt->CKTmode & MODEINITSMSIG))
	  {   vbs = *(ckt->CKTstate0 + here->BSIM3v0vbs);
              vgs = *(ckt->CKTstate0 + here->BSIM3v0vgs);
              vds = *(ckt->CKTstate0 + here->BSIM3v0vds);
              qdef = *(ckt->CKTstate0 + here->BSIM3v0qcdump);
          }
	  else if ((ckt->CKTmode & MODEINITTRAN))
	  {   vbs = *(ckt->CKTstate1 + here->BSIM3v0vbs);
              vgs = *(ckt->CKTstate1 + here->BSIM3v0vgs);
              vds = *(ckt->CKTstate1 + here->BSIM3v0vds);
              qdef = *(ckt->CKTstate1 + here->BSIM3v0qcdump);
          }
	  else if ((ckt->CKTmode & MODEINITJCT) && !here->BSIM3v0off)
	  {   vds = model->BSIM3v0type * here->BSIM3v0icVDS;
              vgs = model->BSIM3v0type * here->BSIM3v0icVGS;
              vbs = model->BSIM3v0type * here->BSIM3v0icVBS;
              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 = pParam->BSIM3v0vth0 + 0.1;
                  vds = 0.1;
              }
          }
	  else if ((ckt->CKTmode & (MODEINITJCT | MODEINITFIX)) && 
                  (here->BSIM3v0off)) 
          {    qdef = vbs = vgs = vds = 0.0;
	  }
          else
	  {
#ifndef PREDICTOR
               if ((ckt->CKTmode & MODEINITPRED))
	       {   xfact = ckt->CKTdelta / ckt->CKTdeltaOld[1];
                   *(ckt->CKTstate0 + here->BSIM3v0vbs) = 
                         *(ckt->CKTstate1 + here->BSIM3v0vbs);
                   vbs = (1.0 + xfact)* (*(ckt->CKTstate1 + here->BSIM3v0vbs))
                         - (xfact * (*(ckt->CKTstate2 + here->BSIM3v0vbs)));
                   *(ckt->CKTstate0 + here->BSIM3v0vgs) = 
                         *(ckt->CKTstate1 + here->BSIM3v0vgs);
                   vgs = (1.0 + xfact)* (*(ckt->CKTstate1 + here->BSIM3v0vgs))
                         - (xfact * (*(ckt->CKTstate2 + here->BSIM3v0vgs)));
                   *(ckt->CKTstate0 + here->BSIM3v0vds) = 
                         *(ckt->CKTstate1 + here->BSIM3v0vds);
                   vds = (1.0 + xfact)* (*(ckt->CKTstate1 + here->BSIM3v0vds))
                         - (xfact * (*(ckt->CKTstate2 + here->BSIM3v0vds)));
                   *(ckt->CKTstate0 + here->BSIM3v0vbd) = 
                         *(ckt->CKTstate0 + here->BSIM3v0vbs)
                         - *(ckt->CKTstate0 + here->BSIM3v0vds);
                   qdef = (1.0 + xfact)* (*(ckt->CKTstate1 + here->BSIM3v0qcdump))
                           -(xfact * (*(ckt->CKTstate2 + here->BSIM3v0qcdump)));
               }
	       else
	       {
#endif /* PREDICTOR */
                   vbs = model->BSIM3v0type
                       * (*(ckt->CKTrhsOld + here->BSIM3v0bNode)
                       - *(ckt->CKTrhsOld + here->BSIM3v0sNodePrime));
                   vgs = model->BSIM3v0type
                       * (*(ckt->CKTrhsOld + here->BSIM3v0gNode) 
                       - *(ckt->CKTrhsOld + here->BSIM3v0sNodePrime));
                   vds = model->BSIM3v0type
                       * (*(ckt->CKTrhsOld + here->BSIM3v0dNodePrime)
                       - *(ckt->CKTrhsOld + here->BSIM3v0sNodePrime));
                   qdef = *(ckt->CKTrhsOld + here->BSIM3v0qNode);
#ifndef PREDICTOR
               }
#endif /* PREDICTOR */

               vbd = vbs - vds;
               vgd = vgs - vds;
               vgdo = *(ckt->CKTstate0 + here->BSIM3v0vgs)
                    - *(ckt->CKTstate0 + here->BSIM3v0vds);
               delvbs = vbs - *(ckt->CKTstate0 + here->BSIM3v0vbs);
               delvbd = vbd - *(ckt->CKTstate0 + here->BSIM3v0vbd);
               delvgs = vgs - *(ckt->CKTstate0 + here->BSIM3v0vgs);
               delvds = vds - *(ckt->CKTstate0 + here->BSIM3v0vds);
               delvgd = vgd - vgdo;

               if (here->BSIM3v0mode >= 0) 
	       {   cdhat = here->BSIM3v0cd - here->BSIM3v0gbd * delvbd 
                         + here->BSIM3v0gmbs * delvbs + here->BSIM3v0gm * delvgs
                         + here->BSIM3v0gds * delvds;
	       }
               else
	       {   cdhat = here->BSIM3v0cd - (here->BSIM3v0gbd - here->BSIM3v0gmbs)
                         * delvbd - here->BSIM3v0gm * delvgd 
                         + here->BSIM3v0gds * delvds;
               
	       }
               cbhat = here->BSIM3v0cbs + here->BSIM3v0cbd + here->BSIM3v0gbd
                     * delvbd + here->BSIM3v0gbs * delvbs;

#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->BSIM3v0vbs))) + ckt->CKTvoltTol)))
               if ((fabs(delvbd) < (ckt->CKTreltol * MAX(fabs(vbd),
                   fabs(*(ckt->CKTstate0+here->BSIM3v0vbd))) + ckt->CKTvoltTol)))
               if ((fabs(delvgs) < (ckt->CKTreltol * MAX(fabs(vgs),
                   fabs(*(ckt->CKTstate0+here->BSIM3v0vgs))) + ckt->CKTvoltTol)))
               if ((fabs(delvds) < (ckt->CKTreltol * MAX(fabs(vds),
                   fabs(*(ckt->CKTstate0+here->BSIM3v0vds))) + ckt->CKTvoltTol)))
               if ((fabs(cdhat - here->BSIM3v0cd) < ckt->CKTreltol 
                   * MAX(fabs(cdhat),fabs(here->BSIM3v0cd)) + ckt->CKTabstol))
	       {   tempv = MAX(fabs(cbhat),fabs(here->BSIM3v0cbs 
                         + here->BSIM3v0cbd)) + ckt->CKTabstol;
                   if ((fabs(cbhat - (here->BSIM3v0cbs + here->BSIM3v0cbd))
                       < ckt->CKTreltol * tempv))
		   {   /* bypass code */
                       vbs = *(ckt->CKTstate0 + here->BSIM3v0vbs);
                       vbd = *(ckt->CKTstate0 + here->BSIM3v0vbd);
                       vgs = *(ckt->CKTstate0 + here->BSIM3v0vgs);
                       vds = *(ckt->CKTstate0 + here->BSIM3v0vds);
                       qcheq = *(ckt->CKTstate0 + here->BSIM3v0qcheq);

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

                       cdrain = here->BSIM3v0mode * (here->BSIM3v0cd
                              + here->BSIM3v0cbd); 
                       if ((ckt->CKTmode & (MODETRAN | MODEAC)) || 
                           ((ckt->CKTmode & MODETRANOP) && 
                           (ckt->CKTmode & MODEUIC)))
		       {   ByPass = 1;
                           goto line755;
                       }
		       else
		       {   goto line850;
		       }
                   }
               }

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

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

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

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

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

          m = here->BSIM3v0m;

          SourceSatCurrent = here->BSIM3v0sourceArea*model->BSIM3v0jctSatCurDensity;
	  if (here->BSIM3v0sourceArea <= 0.0)
              SourceSatCurrent = 1.0e-14;
          if (SourceSatCurrent <= 0.0)
	  {   here->BSIM3v0gbs = ckt->CKTgmin;
              here->BSIM3v0cbs = here->BSIM3v0gbs * vbs;
          }
	  else if (vbs <= -0.5)
	  {   here->BSIM3v0gbs = ckt->CKTgmin;
              here->BSIM3v0cbs = -SourceSatCurrent + here->BSIM3v0gbs * vbs;
          }
	  else if (vbs < 0.5)
	  {   evbs = exp(vbs / CONSTvt0);
              here->BSIM3v0gbs = SourceSatCurrent * evbs / CONSTvt0 
                             + ckt->CKTgmin;
              here->BSIM3v0cbs = SourceSatCurrent * (evbs - 1.0) 
                             + ckt->CKTgmin * vbs;
          }
	  else
	  {   evbs = exp(0.5 / CONSTvt0);
              here->BSIM3v0gbs = SourceSatCurrent * evbs / CONSTvt0 
                             + ckt->CKTgmin;
              here->BSIM3v0cbs = SourceSatCurrent * (evbs - 1.0) 
                             + ckt->CKTgmin * 0.5;
          }

          DrainSatCurrent = here->BSIM3v0drainArea * model->BSIM3v0jctSatCurDensity;
	  if (here->BSIM3v0drainArea <= 0.0)
              DrainSatCurrent = 1.0e-14;
          if (DrainSatCurrent <= 0.0)
	  {   here->BSIM3v0gbd = ckt->CKTgmin;
              here->BSIM3v0cbd = here->BSIM3v0gbd * vbd;
          }