b3v0ld.c

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

		  qgate += Qac0 + Qsub0;
		  qbulk -= (Qac0 + Qsub0);
                  qdrn = -(qgate + qbulk + qsrc);

		  Cgg = dQac0_dVg + dQsub0_dVg + Cgg1;
		  Cgd = dQac0_dVd + dQsub0_dVd + Cgd1;
		  Cgb = dQac0_dVb + dQsub0_dVb + Cgb1;

		  Cbg = Cbg1 - dQac0_dVg - dQsub0_dVg;
		  Cbd = Cbd1 - dQac0_dVd - dQsub0_dVd;
		  Cbb = Cbb1 - dQac0_dVb - dQsub0_dVb;

		  Cgb *= dVbseff_dVb;
		  Cbb *= dVbseff_dVb;
		  Csb *= dVbseff_dVb;

                  here->BSIM3v0cggb = Cgg;
	          here->BSIM3v0cgsb = -(Cgg + Cgd + Cgb);
	          here->BSIM3v0cgdb = Cgd;
                  here->BSIM3v0cdgb = -(Cgg + Cbg + Csg);
	          here->BSIM3v0cdsb = (Cgg + Cgd + Cgb + Cbg + Cbd + Cbb
			          + Csg + Csd + Csb);
	          here->BSIM3v0cddb = -(Cgd + Cbd + Csd);
                  here->BSIM3v0cbgb = Cbg;
	          here->BSIM3v0cbsb = -(Cbg + Cbd + Cbb);
	          here->BSIM3v0cbdb = Cbd;

	      }

/* Non-quasi-static Model */

              if (here->BSIM3v0nqsMod)
              {   
                  qcheq = -qbulk - qgate;
                  qbulk = qgate = qdrn = qsrc = 0.0;

                  here->BSIM3v0cqgb = -(here->BSIM3v0cggb + here->BSIM3v0cbgb);
                  here->BSIM3v0cqdb = -(here->BSIM3v0cgdb + here->BSIM3v0cbdb);
                  here->BSIM3v0cqsb = -(here->BSIM3v0cgsb + here->BSIM3v0cbsb);
                  here->BSIM3v0cqbb =  here->BSIM3v0cggb + here->BSIM3v0cgdb 
                                  + here->BSIM3v0cgsb + here->BSIM3v0cbgb 
                                  + here->BSIM3v0cbdb + here->BSIM3v0cbsb;

                  here->BSIM3v0cggb = here->BSIM3v0cgsb = here->BSIM3v0cgdb = 0.0;
                  here->BSIM3v0cdgb = here->BSIM3v0cdsb = here->BSIM3v0cddb = 0.0;
                  here->BSIM3v0cbgb = here->BSIM3v0cbsb = here->BSIM3v0cbdb = 0.0;

	          T0 = pParam->BSIM3v0leffCV * pParam->BSIM3v0leffCV;
                  here->BSIM3v0tconst = pParam->BSIM3v0u0temp * pParam->BSIM3v0elm
				    / CoxWL / T0;

                  if (qcheq == 0.0)
		      here->BSIM3v0tconst = 0.0;
                  else if (qcheq < 0.0)
		      here->BSIM3v0tconst = -here->BSIM3v0tconst;

                  gtau_drift = fabs(here->BSIM3v0tconst * qcheq);
                  gtau_diff = 16.0 * pParam->BSIM3v0u0temp * model->BSIM3v0vtm / T0;
 
                  here->BSIM3v0gtau =  gtau_drift + gtau_diff;

                  *(ckt->CKTstate0 + here->BSIM3v0qcheq) = qcheq;
 
                  if (ckt->CKTmode & MODEINITTRAN)
                     *(ckt->CKTstate1 + here->BSIM3v0qcheq) =
                                   *(ckt->CKTstate0 + here->BSIM3v0qcheq);
              
                  error = NIintegrate(ckt, &geq, &ceq, 0.0, here->BSIM3v0qcheq);
                  if (error) return (error);
              }
              else
              {   here->BSIM3v0cqgb = here->BSIM3v0cqdb = here->BSIM3v0cqsb 
                                  = here->BSIM3v0cqbb = 0.0;
                  here->BSIM3v0gtau = 0.0; 
              }
          }

finished: /* returning Values to Calling Routine */
          /*
           *  COMPUTE EQUIVALENT DRAIN CURRENT SOURCE
           */
          here->BSIM3v0cd = here->BSIM3v0mode * cdrain - here->BSIM3v0cbd;
          if (ChargeComputationNeeded)
	  {   /*  charge storage elements
               *  bulk-drain and bulk-source depletion capacitances
               *  czbd : zero bias drain junction capacitance
               *  czbs : zero bias source junction capacitance
               *  czbdsw:zero bias drain junction sidewall capacitance
               *  czbssw:zero bias source junction sidewall capacitance
               */

              czbd = model->BSIM3v0unitAreaJctCap * here->BSIM3v0drainArea;
              czbs = model->BSIM3v0unitAreaJctCap * here->BSIM3v0sourceArea;
              czbdsw = model->BSIM3v0unitLengthSidewallJctCap 
		     * here->BSIM3v0drainPerimeter;
              czbssw = model->BSIM3v0unitLengthSidewallJctCap 
		     * here->BSIM3v0sourcePerimeter;
              PhiB = model->BSIM3v0bulkJctPotential;
              PhiBSW = model->BSIM3v0sidewallJctPotential;
              MJ = model->BSIM3v0bulkJctBotGradingCoeff;
              MJSW = model->BSIM3v0bulkJctSideGradingCoeff;

              /* Source Bulk Junction */
	      if (vbs == 0.0)
	      {   *(ckt->CKTstate0 + here->BSIM3v0qbs) = 0.0;
                  here->BSIM3v0capbs = czbs + czbssw;
	      }
	      else if (vbs < 0.0)
	      {   if (czbs > 0.0)
		  {   arg = 1.0 - vbs / PhiB;
		      if (MJ == 0.5)
                          sarg = 1.0 / sqrt(arg);
		      else
                          sarg = exp(-MJ * log(arg));
                      *(ckt->CKTstate0 + here->BSIM3v0qbs) = PhiB * czbs 
					* (1.0 - arg * sarg) / (1.0 - MJ);
		      here->BSIM3v0capbs = czbs * sarg;
		  }
		  else
		  {   *(ckt->CKTstate0 + here->BSIM3v0qbs) = 0.0;
		      here->BSIM3v0capbs = 0.0;
		  }
		  if (czbssw > 0.0)
		  {   arg = 1.0 - vbs / PhiBSW;
		      if (MJSW == 0.5)
                          sarg = 1.0 / sqrt(arg);
		      else
                          sarg = exp(-MJSW * log(arg));
                      *(ckt->CKTstate0 + here->BSIM3v0qbs) += PhiBSW * czbssw
				    * (1.0 - arg * sarg) / (1.0 - MJSW);
                      here->BSIM3v0capbs += czbssw * sarg;
		  }
              }
	      else
	      {   *(ckt->CKTstate0+here->BSIM3v0qbs) = vbs * (czbs + czbssw) 
			           + vbs * vbs * (czbs * MJ * 0.5 / PhiB 
                                   + czbssw * MJSW * 0.5 / PhiBSW);
                  here->BSIM3v0capbs = czbs + czbssw + vbs * (czbs * MJ /PhiB
		                   + czbssw * MJSW / PhiBSW );
              }

              /* Drain Bulk Junction */
	      if (vbd == 0.0)
	      {   *(ckt->CKTstate0 + here->BSIM3v0qbd) = 0.0;
                  here->BSIM3v0capbd = czbd + czbdsw;
	      }
	      else if (vbd < 0.0)
	      {   if (czbd > 0.0)
		  {   arg = 1.0 - vbd / PhiB;
		      if (MJ == 0.5)
                          sarg = 1.0 / sqrt(arg);
		      else
                          sarg = exp(-MJ * log(arg));
                      *(ckt->CKTstate0 + here->BSIM3v0qbd) = PhiB * czbd 
			           * (1.0 - arg * sarg) / (1.0 - MJ);
                      here->BSIM3v0capbd = czbd * sarg;
		  }
		  else
		  {   *(ckt->CKTstate0 + here->BSIM3v0qbd) = 0.0;
                      here->BSIM3v0capbd = 0.0;
		  }
		  if (czbdsw > 0.0)
		  {   arg = 1.0 - vbd / PhiBSW;
		      if (MJSW == 0.5)
                          sarg = 1.0 / sqrt(arg);
		      else
                          sarg = exp(-MJSW * log(arg));
                      *(ckt->CKTstate0 + here->BSIM3v0qbd) += PhiBSW * czbdsw 
			               * (1.0 - arg * sarg) / (1.0 - MJSW);
                      here->BSIM3v0capbd += czbdsw * sarg;
		  }
              }
	      else
	      {   *(ckt->CKTstate0+here->BSIM3v0qbd) = vbd * (czbd + czbdsw)
			      + vbd * vbd * (czbd * MJ * 0.5 / PhiB 
                              + czbdsw * MJSW * 0.5 / PhiBSW);
                  here->BSIM3v0capbd = czbd + czbdsw + vbd * (czbd * MJ / PhiB
			      + czbdsw * MJSW / PhiBSW );
              }
          }

          /*
           *  check convergence
           */
          if ((here->BSIM3v0off == 0) || (!(ckt->CKTmode & MODEINITFIX)))
	  {   if (Check == 1)
	      {   ckt->CKTnoncon++;
#ifndef NEWCONV
              } 
	      else
	      {   tol = ckt->CKTreltol * MAX(fabs(cdhat), fabs(here->BSIM3v0cd))
		      + ckt->CKTabstol;
                  if (fabs(cdhat - here->BSIM3v0cd) >= tol)
		  {   ckt->CKTnoncon++;
                  }
		  else
		  {   tol = ckt->CKTreltol * MAX(fabs(cbhat), 
			    fabs(here->BSIM3v0cbs + here->BSIM3v0cbd)) 
			    + ckt->CKTabstol;
                      if (fabs(cbhat - (here->BSIM3v0cbs + here->BSIM3v0cbd)) 
			  > tol)
		      {   ckt->CKTnoncon++;
                      }
                  }
#endif /* NEWCONV */
              }
          }
          *(ckt->CKTstate0 + here->BSIM3v0vbs) = vbs;
          *(ckt->CKTstate0 + here->BSIM3v0vbd) = vbd;
          *(ckt->CKTstate0 + here->BSIM3v0vgs) = vgs;
          *(ckt->CKTstate0 + here->BSIM3v0vds) = vds;

          /* bulk and channel charge plus overlaps */

          if (!ChargeComputationNeeded)
              goto line850; 
         
line755:
          ag0 = ckt->CKTag[0];

	  if (model->BSIM3v0capMod == 1)
	  {   if (vgd < 0.0)
	      {   T1 = sqrt(1.0 - 4.0 * vgd / pParam->BSIM3v0ckappa);
	          cgdo = pParam->BSIM3v0cgdo + pParam->BSIM3v0weffCV
		       * pParam->BSIM3v0cgdl / T1;
	          qgdo = pParam->BSIM3v0cgdo * vgd - pParam->BSIM3v0weffCV * 0.5
		       * pParam->BSIM3v0cgdl * pParam->BSIM3v0ckappa * (T1 - 1.0);
	      }
	      else
	      {   cgdo = pParam->BSIM3v0cgdo + pParam->BSIM3v0weffCV
		       * pParam->BSIM3v0cgdl;
	          qgdo = (pParam->BSIM3v0weffCV * pParam->BSIM3v0cgdl
		       + pParam->BSIM3v0cgdo) * vgd;
	      }

	      if (vgs < 0.0)
	      {   T1 = sqrt(1.0 - 4.0 * vgs / pParam->BSIM3v0ckappa);
	          cgso = pParam->BSIM3v0cgso + pParam->BSIM3v0weffCV
		       * pParam->BSIM3v0cgsl / T1;
	          qgso = pParam->BSIM3v0cgso * vgs - pParam->BSIM3v0weffCV * 0.5
		       * pParam->BSIM3v0cgsl * pParam->BSIM3v0ckappa * (T1 - 1.0);
	      }
	      else
	      {   cgso = pParam->BSIM3v0cgso + pParam->BSIM3v0weffCV
		       * pParam->BSIM3v0cgsl;
	          qgso = (pParam->BSIM3v0weffCV * pParam->BSIM3v0cgsl
		       + pParam->BSIM3v0cgso) * vgs;
	      }
	  }
	  else
	  {   T0 = vgd + DELTA_1;
	      T1 = sqrt(T0 * T0 + 4.0 * DELTA_1);
	      T2 = 0.5 * (T0 - T1);

	      T3 = pParam->BSIM3v0weffCV * pParam->BSIM3v0cgdl;
	      T4 = sqrt(1.0 - 4.0 * T2 / pParam->BSIM3v0ckappa);
	      cgdo = pParam->BSIM3v0cgdo + T3 - T3 * (1.0 - 1.0 / T4)
		   * (0.5 - 0.5 * T0 / T1);
	      qgdo = (pParam->BSIM3v0cgdo + T3) * vgd - T3 * (T2
		   + 0.5 * pParam->BSIM3v0ckappa * (T4 - 1.0));

	      T0 = vgs + DELTA_1;
	      T1 = sqrt(T0 * T0 + 4.0 * DELTA_1);
	      T2 = 0.5 * (T0 - T1);
	      T3 = pParam->BSIM3v0weffCV * pParam->BSIM3v0cgsl;
	      T4 = sqrt(1.0 - 4.0 * T2 / pParam->BSIM3v0ckappa);
	      cgso = pParam->BSIM3v0cgso + T3 - T3 * (1.0 - 1.0 / T4)
		   * (0.5 - 0.5 * T0 / T1);
	      qgso = (pParam->BSIM3v0cgso + T3) * vgs - T3 * (T2
		   + 0.5 * pParam->BSIM3v0ckappa * (T4 - 1.0));
	  }

          if (here->BSIM3v0mode > 0)
	  {   gcdgb = (here->BSIM3v0cdgb - cgdo) * ag0;
              gcddb = (here->BSIM3v0cddb + here->BSIM3v0capbd + cgdo) * ag0;
              gcdsb = here->BSIM3v0cdsb * ag0;
              gcsgb = -(here->BSIM3v0cggb + here->BSIM3v0cbgb + here->BSIM3v0cdgb
	            + cgso) * ag0;
              gcsdb = -(here->BSIM3v0cgdb + here->BSIM3v0cbdb + here->BSIM3v0cddb)
		    * ag0;
              gcssb = (here->BSIM3v0capbs + cgso - (here->BSIM3v0cgsb
		    + here->BSIM3v0cbsb + here->BSIM3v0cdsb)) * ag0;
              gcggb = (here->BSIM3v0cggb + cgdo + cgso + pParam->BSIM3v0cgbo ) * ag0;
              gcgdb = (here->BSIM3v0cgdb - cgdo) * ag0;
              gcgsb = (here->BSIM3v0cgsb - cgso) * ag0;
              gcbgb = (here->BSIM3v0cbgb - pParam->BSIM3v0cgbo) * ag0;
              gcbdb = (here->BSIM3v0cbdb - here->BSIM3v0capbd) * ag0;
              gcbsb = (here->BSIM3v0cbsb - here->BSIM3v0capbs) * ag0;
 
              gcqgb = here->BSIM3v0cqgb * ag0;
              gcqdb = here->BSIM3v0cqdb * ag0;
              gcqsb = here->BSIM3v0cqsb * ag0;
              gcqbb = here->BSIM3v0cqbb * ag0;

              T0 = here->BSIM3v0tconst * qdef;
              here->BSIM3v0gtg = T0 * here->BSIM3v0cqgb;
              here->BSIM3v0gtb = T0 * here->BSIM3v0cqbb;
              here->BSIM3v0gtd = T0 * here->BSIM3v0cqdb;
              here->BSIM3v0gts = T0 * here->BSIM3v0cqsb;
 
              sxpart = 0.6;
              dxpart = 0.4;

              /* compute total terminal charge */
              qgd = qgdo;
              qgs = qgso;
              qgb = pParam->BSIM3v0cgbo * vgb;
              qgate += qgd + qgs + qgb;
              qbulk -= qgb;
              qdrn -= qgd;
              qsrc = -(qgate + qbulk + qdrn);
	  }
	  else
	  {   gcsgb = (here->BSIM3v0cdgb - cgso) * ag0;
              gcsdb = here->BSIM3v0cdsb * ag0;
              gcssb = (here->BSIM3v0cddb + here->BSIM3v0capbs + cgso) * ag0;

              gcdgb = -(here->BSIM3v0cggb + here->BSIM3v0cbgb + here->BSIM3v0cdgb
		    + cgdo) * ag0;
              gcdsb = -(here->BSIM3v0cgdb + here->BSIM3v0cbdb + here->BSIM3v0cddb)
		    * ag0;
              gcddb = (here->BSIM3v0capbd + cgdo - (here->BSIM3v0cgsb
		    + here->BSIM3v0cbsb + here->BSIM3v0cdsb)) * ag0;
              gcggb = (here->BSIM3v0cggb + cgdo + cgso + pParam->BSIM3v0cgbo ) * ag0;
              gcgdb = (here->BSIM3v0cgsb - cgdo) * ag0;
              gcgsb = (here->BSIM3v0cgdb - cgso) * ag0;
              gcbgb = (here->BSIM3v0cbgb - pParam->BSIM3v0cgbo) * ag0;