b3v1ald.c

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

		  else if (model->BSIM3v1Axpart < 0.5)
		  {   /* 40/60 Charge petition model */
		      T1 = T1 / 12.0;
		      T2 = 0.5 * CoxWL / (T1 * T1);
		      T3 = Vgsteff * (2.0 * T0 * T0 / 3.0 + Vgsteff
			 * (Vgsteff - 4.0 * T0 / 3.0))
			 - 2.0 * T0 * T0 * T0 / 15.0;
		      qsrc = -T2 * T3;
		      T7 = 4.0 / 3.0 * Vgsteff * (Vgsteff - T0)
			 + 0.4 * T0 * T0;
		      T4 = -2.0 * qsrc / T1 - T2 * (Vgsteff * (3.0
			 * Vgsteff - 8.0 * T0 / 3.0)
			 + 2.0 * T0 * T0 / 3.0);
		      T5 = (qsrc / T1 + T2 * T7) * AbulkCV;
		      T6 = (qsrc / T1 * VdseffCV + T2 * T7 * VdseffCV);
                      Csg = (T4 + T5 * dVdseffCV_dVg);
                      Csd = T5 * dVdseffCV_dVd + Csg * dVgsteff_dVd;
                      Csb = (T5 * dVdseffCV_dVb + T6 * dAbulkCV_dVb)
			  + Csg * dVgsteff_dVb;
		      Csg *= dVgsteff_dVg;
                  }
		  else
		  {   /* 50/50 Charge petition model */
                      qsrc = -0.5 * (qgate + qbulk);
                      Csg = -0.5 * (Cgg1 + Cbg1);
                      Csb = -0.5 * (Cgb1 + Cbb1); 
                      Csd = -0.5 * (Cgd1 + Cbd1); 
                  }

		  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->BSIM3v1Acggb = Cgg;
	          here->BSIM3v1Acgsb = -(Cgg + Cgd + Cgb);
	          here->BSIM3v1Acgdb = Cgd;
                  here->BSIM3v1Acdgb = -(Cgg + Cbg + Csg);
	          here->BSIM3v1Acdsb = (Cgg + Cgd + Cgb + Cbg + Cbd + Cbb
			          + Csg + Csd + Csb);
	          here->BSIM3v1Acddb = -(Cgd + Cbd + Csd);
                  here->BSIM3v1Acbgb = Cbg;
	          here->BSIM3v1Acbsb = -(Cbg + Cbd + Cbb);
	          here->BSIM3v1Acbdb = Cbd;

	      }

/* Non-quasi-static Model */

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

                  here->BSIM3v1Acqgb = -(here->BSIM3v1Acggb + here->BSIM3v1Acbgb);
                  here->BSIM3v1Acqdb = -(here->BSIM3v1Acgdb + here->BSIM3v1Acbdb);
                  here->BSIM3v1Acqsb = -(here->BSIM3v1Acgsb + here->BSIM3v1Acbsb);
                  here->BSIM3v1Acqbb =  here->BSIM3v1Acggb + here->BSIM3v1Acgdb 
                                  + here->BSIM3v1Acgsb + here->BSIM3v1Acbgb 
                                  + here->BSIM3v1Acbdb + here->BSIM3v1Acbsb;

                  here->BSIM3v1Acggb = here->BSIM3v1Acgsb = here->BSIM3v1Acgdb = 0.0;
                  here->BSIM3v1Acdgb = here->BSIM3v1Acdsb = here->BSIM3v1Acddb = 0.0;
                  here->BSIM3v1Acbgb = here->BSIM3v1Acbsb = here->BSIM3v1Acbdb = 0.0;

	          T0 = pParam->BSIM3v1AleffCV * pParam->BSIM3v1AleffCV;
                  here->BSIM3v1Atconst = pParam->BSIM3v1Au0temp * pParam->BSIM3v1Aelm
				    / CoxWL / T0;

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

                  gtau_drift = fabs(here->BSIM3v1Atconst * qcheq);
                  gtau_diff = 16.0 * pParam->BSIM3v1Au0temp * model->BSIM3v1Avtm / T0;
 
                  here->BSIM3v1Agtau =  gtau_drift + gtau_diff;

                  *(ckt->CKTstate0 + here->BSIM3v1Aqcheq) = qcheq;
 
                  if (ckt->CKTmode & MODEINITTRAN)
                     *(ckt->CKTstate1 + here->BSIM3v1Aqcheq) =
                                   *(ckt->CKTstate0 + here->BSIM3v1Aqcheq);
              
                  error = NIintegrate(ckt, &geq, &ceq, 0.0, here->BSIM3v1Aqcheq);
                  if (error) return (error);
              }
              else
              {   here->BSIM3v1Acqgb = here->BSIM3v1Acqdb = here->BSIM3v1Acqsb 
                                  = here->BSIM3v1Acqbb = 0.0;
                  here->BSIM3v1Agtau = 0.0; 
              }
          }

finished: /* returning Values to Calling Routine */
          /*
           *  COMPUTE EQUIVALENT DRAIN CURRENT SOURCE
           */
          here->BSIM3v1Acd = here->BSIM3v1Amode * cdrain - here->BSIM3v1Acbd;
          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->BSIM3v1AunitAreaJctCap * here->BSIM3v1AdrainArea;
              czbs = model->BSIM3v1AunitAreaJctCap * here->BSIM3v1AsourceArea;
              czbdsw = model->BSIM3v1AunitLengthSidewallJctCap 
		     * here->BSIM3v1AdrainPerimeter;
              czbssw = model->BSIM3v1AunitLengthSidewallJctCap 
		     * here->BSIM3v1AsourcePerimeter;
              PhiB = model->BSIM3v1AbulkJctPotential;
              PhiBSW = model->BSIM3v1AsidewallJctPotential;
              MJ = model->BSIM3v1AbulkJctBotGradingCoeff;
              MJSW = model->BSIM3v1AbulkJctSideGradingCoeff;

              /* Source Bulk Junction */
	      if (vbs == 0.0)
	      {   *(ckt->CKTstate0 + here->BSIM3v1Aqbs) = 0.0;
                  here->BSIM3v1Acapbs = 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->BSIM3v1Aqbs) = PhiB * czbs 
					* (1.0 - arg * sarg) / (1.0 - MJ);
		      here->BSIM3v1Acapbs = czbs * sarg;
		  }
		  else
		  {   *(ckt->CKTstate0 + here->BSIM3v1Aqbs) = 0.0;
		      here->BSIM3v1Acapbs = 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->BSIM3v1Aqbs) += PhiBSW * czbssw
				    * (1.0 - arg * sarg) / (1.0 - MJSW);
                      here->BSIM3v1Acapbs += czbssw * sarg;
		  }
              }
	      else
	      {   *(ckt->CKTstate0+here->BSIM3v1Aqbs) = vbs * (czbs + czbssw) 
			           + vbs * vbs * (czbs * MJ * 0.5 / PhiB 
                                   + czbssw * MJSW * 0.5 / PhiBSW);
                  here->BSIM3v1Acapbs = czbs + czbssw + vbs * (czbs * MJ /PhiB
		                   + czbssw * MJSW / PhiBSW );
              }

              /* Drain Bulk Junction */
	      if (vbd == 0.0)
	      {   *(ckt->CKTstate0 + here->BSIM3v1Aqbd) = 0.0;
                  here->BSIM3v1Acapbd = 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->BSIM3v1Aqbd) = PhiB * czbd 
			           * (1.0 - arg * sarg) / (1.0 - MJ);
                      here->BSIM3v1Acapbd = czbd * sarg;
		  }
		  else
		  {   *(ckt->CKTstate0 + here->BSIM3v1Aqbd) = 0.0;
                      here->BSIM3v1Acapbd = 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->BSIM3v1Aqbd) += PhiBSW * czbdsw 
			               * (1.0 - arg * sarg) / (1.0 - MJSW);
                      here->BSIM3v1Acapbd += czbdsw * sarg;
		  }
              }
	      else
	      {   *(ckt->CKTstate0+here->BSIM3v1Aqbd) = vbd * (czbd + czbdsw)
			      + vbd * vbd * (czbd * MJ * 0.5 / PhiB 
                              + czbdsw * MJSW * 0.5 / PhiBSW);
                  here->BSIM3v1Acapbd = czbd + czbdsw + vbd * (czbd * MJ / PhiB
			      + czbdsw * MJSW / PhiBSW );
              }
          }

          /*
           *  check convergence
           */
          if ((here->BSIM3v1Aoff == 0) || (!(ckt->CKTmode & MODEINITFIX)))
	  {   if (Check == 1)
	      {   ckt->CKTnoncon++;
              }
          }
          *(ckt->CKTstate0 + here->BSIM3v1Avbs) = vbs;
          *(ckt->CKTstate0 + here->BSIM3v1Avbd) = vbd;
          *(ckt->CKTstate0 + here->BSIM3v1Avgs) = vgs;
          *(ckt->CKTstate0 + here->BSIM3v1Avds) = vds;

          /* bulk and channel charge plus overlaps */

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

	  if (model->BSIM3v1AcapMod == 1)
	  {   if (vgd < 0.0)
	      {   T1 = sqrt(1.0 - 4.0 * vgd / pParam->BSIM3v1Ackappa);
	          cgdo = pParam->BSIM3v1Acgdo + pParam->BSIM3v1AweffCV
		       * pParam->BSIM3v1Acgdl / T1;
	          qgdo = pParam->BSIM3v1Acgdo * vgd - pParam->BSIM3v1AweffCV * 0.5
		       * pParam->BSIM3v1Acgdl * pParam->BSIM3v1Ackappa * (T1 - 1.0);
	      }
	      else
	      {   cgdo = pParam->BSIM3v1Acgdo + pParam->BSIM3v1AweffCV
		       * pParam->BSIM3v1Acgdl;
	          qgdo = (pParam->BSIM3v1AweffCV * pParam->BSIM3v1Acgdl
		       + pParam->BSIM3v1Acgdo) * vgd;
	      }

	      if (vgs < 0.0)
	      {   T1 = sqrt(1.0 - 4.0 * vgs / pParam->BSIM3v1Ackappa);
	          cgso = pParam->BSIM3v1Acgso + pParam->BSIM3v1AweffCV
		       * pParam->BSIM3v1Acgsl / T1;
	          qgso = pParam->BSIM3v1Acgso * vgs - pParam->BSIM3v1AweffCV * 0.5
		       * pParam->BSIM3v1Acgsl * pParam->BSIM3v1Ackappa * (T1 - 1.0);
	      }
	      else
	      {   cgso = pParam->BSIM3v1Acgso + pParam->BSIM3v1AweffCV
		       * pParam->BSIM3v1Acgsl;
	          qgso = (pParam->BSIM3v1AweffCV * pParam->BSIM3v1Acgsl
		       + pParam->BSIM3v1Acgso) * vgs;
	      }
	  }
	  else
	  {   T0 = vgd + DELTA_1;
	      T1 = sqrt(T0 * T0 + 4.0 * DELTA_1);
	      T2 = 0.5 * (T0 - T1);

	      T3 = pParam->BSIM3v1AweffCV * pParam->BSIM3v1Acgdl;
	      T4 = sqrt(1.0 - 4.0 * T2 / pParam->BSIM3v1Ackappa);
	      cgdo = pParam->BSIM3v1Acgdo + T3 - T3 * (1.0 - 1.0 / T4)
		   * (0.5 - 0.5 * T0 / T1);
	      qgdo = (pParam->BSIM3v1Acgdo + T3) * vgd - T3 * (T2
		   + 0.5 * pParam->BSIM3v1Ackappa * (T4 - 1.0));

	      T0 = vgs + DELTA_1;
	      T1 = sqrt(T0 * T0 + 4.0 * DELTA_1);
	      T2 = 0.5 * (T0 - T1);
	      T3 = pParam->BSIM3v1AweffCV * pParam->BSIM3v1Acgsl;
	      T4 = sqrt(1.0 - 4.0 * T2 / pParam->BSIM3v1Ackappa);
	      cgso = pParam->BSIM3v1Acgso + T3 - T3 * (1.0 - 1.0 / T4)
		   * (0.5 - 0.5 * T0 / T1);
	      qgso = (pParam->BSIM3v1Acgso + T3) * vgs - T3 * (T2
		   + 0.5 * pParam->BSIM3v1Ackappa * (T4 - 1.0));
	  }

          if (here->BSIM3v1Amode > 0)
	  {   gcdgb = (here->BSIM3v1Acdgb - cgdo) * ag0;
              gcddb = (here->BSIM3v1Acddb + here->BSIM3v1Acapbd + cgdo) * ag0;
              gcdsb = here->BSIM3v1Acdsb * ag0;
              gcsgb = -(here->BSIM3v1Acggb + here->BSIM3v1Acbgb + here->BSIM3v1Acdgb
	            + cgso) * ag0;
              gcsdb = -(here->BSIM3v1Acgdb + here->BSIM3v1Acbdb + here->BSIM3v1Acddb)
		    * ag0;
              gcssb = (here->BSIM3v1Acapbs + cgso - (here->BSIM3v1Acgsb
		    + here->BSIM3v1Acbsb + here->BSIM3v1Acdsb)) * ag0;
              gcggb = (here->BSIM3v1Acggb + cgdo + cgso + pParam->BSIM3v1Acgbo ) * ag0;
              gcgdb = (here->BSIM3v1Acgdb - cgdo) * ag0;
              gcgsb = (here->BSIM3v1Acgsb - cgso) * ag0;
              gcbgb = (here->BSIM3v1Acbgb - pParam->BSIM3v1Acgbo) * ag0;
              gcbdb = (here->BSIM3v1Acbdb - here->BSIM3v1Acapbd) * ag0;
              gcbsb = (here->BSIM3v1Acbsb - here->BSIM3v1Acapbs) * ag0;
 
              gcqgb = here->BSIM3v1Acqgb * ag0;
              gcqdb = here->BSIM3v1Acqdb * ag0;
              gcqsb = here->BSIM3v1Acqsb * ag0;
              gcqbb = here->BSIM3v1Acqbb * ag0;

              T0 = here->BSIM3v1Atconst * qdef;
              here->BSIM3v1Agtg = T0 * here->BSIM3v1Acqgb;
              here->BSIM3v1Agtb = T0 * here->BSIM3v1Acqbb;
              here->BSIM3v1Agtd = T0 * here->BSIM3v1Acqdb;
              here->BSIM3v1Agts = T0 * here->BSIM3v1Acqsb;
 
              sxpart = 0.6;
              dxpart = 0.4;

              /* compute total terminal charge */
              qgd = qgdo;
              qgs = qgso;
              qgb = pParam->BSIM3v1Acgbo * vgb;
              qgate += qgd + qgs + qgb;
              qbulk -= qgb;
              qdrn -= qgd;
              qsrc = -(qgate + qbulk + qdrn);
	  }
	  else
	  {   gcsgb = (here->BSIM3v1Acdgb - cgso) * ag0;
              gcsdb = here->BSIM3v1Acdsb * ag0;
              gcssb = (here->BSIM3v1Acddb + here->BSIM3v1Acapbs + cgso) * ag0;

              gcdgb = -(here->BSIM3v1Acggb + here->BSIM3v1Acbgb + here->BSIM3v1Acdgb
		    + cgdo) * ag0;
              gcdsb = -(here->BSIM3v1Acgdb + here->BSIM3v1Acbdb +