b3v1sld.c

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

                  dVASCBE_dVg = T1 * dVdseff_dVg;
                  dVASCBE_dVd = -T1 * (1.0 - dVdseff_dVd);
                  dVASCBE_dVb = T1 * dVdseff_dVb;
              }
	      else
	      {   VASCBE = MAX_EXP * Leff/pParam->BSIM3v1Spscbe2;
                  dVASCBE_dVg = dVASCBE_dVd = dVASCBE_dVb = 0.0;
              }
	  }
	  else
	  {   VASCBE = MAX_EXP;
              dVASCBE_dVg = dVASCBE_dVd = dVASCBE_dVb = 0.0;
	  }

/* Calculate Ids */
          CoxWovL = model->BSIM3v1Scox * Weff / Leff;
          beta = ueff * CoxWovL;
          dbeta_dVg = CoxWovL * dueff_dVg + beta * dWeff_dVg / Weff;
          dbeta_dVd = CoxWovL * dueff_dVd;
          dbeta_dVb = CoxWovL * dueff_dVb + beta * dWeff_dVb / Weff;

          T0 = 1.0 - 0.5 * Abulk * Vdseff / Vgst2Vtm;
          dT0_dVg = -0.5 * (Abulk * dVdseff_dVg 
		  - Abulk * Vdseff / Vgst2Vtm + Vdseff * dAbulk_dVg) / Vgst2Vtm;
          dT0_dVd = -0.5 * Abulk * dVdseff_dVd / Vgst2Vtm;
          dT0_dVb = -0.5 * (Abulk * dVdseff_dVb + dAbulk_dVb * Vdseff)
                  / Vgst2Vtm;

          fgche1 = Vgsteff * T0;
          dfgche1_dVg = Vgsteff * dT0_dVg + T0; 
          dfgche1_dVd = Vgsteff * dT0_dVd; 
          dfgche1_dVb = Vgsteff * dT0_dVb; 

          T9 = Vdseff / EsatL;
          fgche2 = 1.0 + T9;
          dfgche2_dVg = (dVdseff_dVg - T9 * dEsatL_dVg) / EsatL;
          dfgche2_dVd = (dVdseff_dVd - T9 * dEsatL_dVd) / EsatL;
          dfgche2_dVb = (dVdseff_dVb - T9 * dEsatL_dVb) / EsatL;
 
          gche = beta * fgche1 / fgche2;
          dgche_dVg = (beta * dfgche1_dVg + fgche1 * dbeta_dVg
		    - gche * dfgche2_dVg) / fgche2;
          dgche_dVd = (beta * dfgche1_dVd + fgche1 * dbeta_dVd
		    - gche * dfgche2_dVd) / fgche2;
          dgche_dVb = (beta * dfgche1_dVb + fgche1 * dbeta_dVb
		    - gche * dfgche2_dVb) / fgche2;

          T0 = 1.0 + gche * Rds;
          T9 = Vdseff / T0;
          Idl = gche * T9;

          dIdl_dVg = (gche * dVdseff_dVg + T9 * dgche_dVg) / T0
                   - Idl * gche / T0 * dRds_dVg ; 

          dIdl_dVd = (gche * dVdseff_dVd + T9 * dgche_dVd) / T0; 
          dIdl_dVb = (gche * dVdseff_dVb + T9 * dgche_dVb 
                   - Idl * dRds_dVb * gche) / T0; 

          T9 =  diffVds / Va;
          T0 =  1.0 + T9;
          Idsa = Idl * T0;
          dIdsa_dVg = T0 * dIdl_dVg - Idl * (dVdseff_dVg + T9 * dVa_dVg) / Va;
          dIdsa_dVd = T0 * dIdl_dVd + Idl * (1.0 - dVdseff_dVd
		    - T9 * dVa_dVd) / Va;
          dIdsa_dVb = T0 * dIdl_dVb - Idl * (dVdseff_dVb + T9 * dVa_dVb) / Va;

          T9 = diffVds / VASCBE;
          T0 = 1.0 + T9;
          Ids = Idsa * T0;

          Gm = T0 * dIdsa_dVg - Idsa * (dVdseff_dVg + T9 * dVASCBE_dVg) / VASCBE;
          Gds = T0 * dIdsa_dVd + Idsa * (1.0 - dVdseff_dVd
	      - T9 * dVASCBE_dVd) / VASCBE;
          Gmb = T0 * dIdsa_dVb - Idsa * (dVdseff_dVb
	      + T9 * dVASCBE_dVb) / VASCBE;

          Gds += Gm * dVgsteff_dVd;
	  Gmb += Gm * dVgsteff_dVb;
	  Gm *= dVgsteff_dVg;
	  Gmb *= dVbseff_dVb;

/* calculate substrate current Isub */
          if ((pParam->BSIM3v1Salpha0 <= 0.0) || (pParam->BSIM3v1Sbeta0 <= 0.0))
	  {   Isub = Gbd = Gbb = Gbg = 0.0;
          }
	  else
	  {   T2 = pParam->BSIM3v1Salpha0 / Leff;
	      if (diffVds > pParam->BSIM3v1Sbeta0 / EXP_THRESHOLD)
	      {   T0 = -pParam->BSIM3v1Sbeta0 / diffVds;
		  T1 = T2 * diffVds * exp(T0);
		  T3 = T1 / diffVds * (T0 - 1.0);
                  dT1_dVg = T3 * dVdseff_dVg;
                  dT1_dVd = -T3 * (1.0 - dVdseff_dVd);
                  dT1_dVb = T3 * dVdseff_dVb;
              }
	      else
	      {   T3 = T2 * MIN_EXP;
		  T1 = T3 * diffVds;
                  dT1_dVg = -T3 * dVdseff_dVg;
                  dT1_dVd = T3 * (1.0 - dVdseff_dVd);
                  dT1_dVb = -T3 * dVdseff_dVb;
              }
              Isub = T1 * Idsa;
              Gbg = T1 * dIdsa_dVg + Idsa * dT1_dVg;
              Gbd = T1 * dIdsa_dVd + Idsa * dT1_dVd;
              Gbb = T1 * dIdsa_dVb + Idsa * dT1_dVb;

              Gbd += Gbg * dVgsteff_dVd;
	      Gbb += Gbg * dVgsteff_dVb;
	      Gbg *= dVgsteff_dVg;
	      Gbb *= dVbseff_dVb; /* bug fixing */
          }
         
          if (Gmb < -1e-12 || Gds < 0 || Gm < -1e-12) printf("@ vds=%g vgs=%g vbs=%g Id=%g\n",Vds, Vgs, Vbs, Ids);
          if (Gds < 0)
          {
              printf("WARNING: negative Gds = %g for %s %s\n",Gds,
                 model->BSIM3v1Stype == 1 ? "nfet" : "pfet", here->BSIM3v1Sname);
              /* Gds = 1e-15;*/
          }
          if (Gm < -1e-12)
          {
              printf("WARNING: negative Gm = %g for %s %s\n",Gm,
                 model->BSIM3v1Stype == 1 ? "nfet" : "pfet", here->BSIM3v1Sname);
              /* Gm = 1e-15; */
          }
          if (Gmb < -1e-12)
          {
              printf("WARNING: negative Gmb = %g for %s %s\n",Gmb,
                 model->BSIM3v1Stype == 1 ? "nfet" : "pfet", here->BSIM3v1Sname);
              /* Gmb = 0; */
          }

          cdrain = Ids;
          here->BSIM3v1Sgds = Gds;
          here->BSIM3v1Sgm = Gm;
          here->BSIM3v1Sgmbs = Gmb;
                   
          here->BSIM3v1Sgbbs = Gbb;
          here->BSIM3v1Sgbgs = Gbg;
          here->BSIM3v1Sgbds = Gbd;

          here->BSIM3v1Scsub = Isub - (Gbb * Vbseff + Gbd * Vds + Gbg * Vgs);

/* Calculate Qinv for Noise analysis */

          T1 = Vgsteff * (1.0 - 0.5 * Abulk * Vdseff / Vgst2Vtm);
          here->BSIM3v1Sqinv = -model->BSIM3v1Scox * Weff * Leff * T1;

          if ((model->BSIM3v1Sxpart < 0) || (!ChargeComputationNeeded))
	  {   qgate  = qdrn = qsrc = qbulk = 0.0;
              here->BSIM3v1Scggb = here->BSIM3v1Scgsb = here->BSIM3v1Scgdb = 0.0;
              here->BSIM3v1Scdgb = here->BSIM3v1Scdsb = here->BSIM3v1Scddb = 0.0;
              here->BSIM3v1Scbgb = here->BSIM3v1Scbsb = here->BSIM3v1Scbdb = 0.0;
              here->BSIM3v1Scqdb = here->BSIM3v1Scqsb = here->BSIM3v1Scqgb 
                              = here->BSIM3v1Scqbb = 0.0;
              here->BSIM3v1Sgtau = 0.0;
              goto finished;
          }
	  else if (model->BSIM3v1ScapMod == 0)
	  {
              if (Vbseff < 0.0)
	      {   Vbseff = Vbs;
                  dVbseff_dVb = 1.0;
              }
	      else
	      {   Vbseff = pParam->BSIM3v1Sphi - Phis;
                  dVbseff_dVb = -dPhis_dVb;
              }

         Vfb = pParam->BSIM3v1Svfbcv;
         Vth = Vfb + pParam->BSIM3v1Sphi + pParam->BSIM3v1Sk1 * sqrtPhis; 
         Vgst = Vgs_eff - Vth;
         dVth_dVb = pParam->BSIM3v1Sk1 * dsqrtPhis_dVb; 
         dVgst_dVb = -dVth_dVb;
         dVgst_dVg = dVgs_eff_dVg; 

         CoxWL = model->BSIM3v1Scox * pParam->BSIM3v1SweffCV
                 * pParam->BSIM3v1SleffCV;
         Arg1 = Vgs_eff - Vbseff - Vfb;
                if (Arg1 <= 0.0)
		{   qgate = CoxWL * Arg1;
                    qbulk = -qgate;
                    qdrn = 0.0;

                    here->BSIM3v1Scggb = CoxWL * dVgs_eff_dVg;
                    here->BSIM3v1Scgdb = 0.0;
                    here->BSIM3v1Scgsb = CoxWL * (dVbseff_dVb
				    - dVgs_eff_dVg);

                    here->BSIM3v1Scdgb = 0.0;
                    here->BSIM3v1Scddb = 0.0;
                    here->BSIM3v1Scdsb = 0.0;

                    here->BSIM3v1Scbgb = -CoxWL * dVgs_eff_dVg;
                    here->BSIM3v1Scbdb = 0.0;
                    here->BSIM3v1Scbsb = -here->BSIM3v1Scgsb;

                }
		else if (Vgst <= 0.0)
		{   T1 = 0.5 * pParam->BSIM3v1Sk1;
	            T2 = sqrt(T1 * T1 + Arg1);
	            qgate = CoxWL * pParam->BSIM3v1Sk1 * (T2 - T1);
                    qbulk = -qgate;
                    qdrn = 0.0;

	            T0 = CoxWL * T1 / T2;
	            here->BSIM3v1Scggb = T0 * dVgs_eff_dVg;
	            here->BSIM3v1Scgdb = 0.0;
                    here->BSIM3v1Scgsb = T0 * (dVbseff_dVb
				    - dVgs_eff_dVg);
   
                    here->BSIM3v1Scdgb = 0.0;
                    here->BSIM3v1Scddb = 0.0;
                    here->BSIM3v1Scdsb = 0.0;

                    here->BSIM3v1Scbgb = -here->BSIM3v1Scggb;
                    here->BSIM3v1Scbdb = 0.0;
                    here->BSIM3v1Scbsb = -here->BSIM3v1Scgsb;
                }
		else
		{   One_Third_CoxWL = CoxWL / 3.0;
                    Two_Third_CoxWL = 2.0 * One_Third_CoxWL;

                  AbulkCV = Abulk0 * pParam->BSIM3v1SabulkCVfactor;
                  dAbulkCV_dVb = pParam->BSIM3v1SabulkCVfactor * dAbulk0_dVb;
	          Vdsat = Vgst / AbulkCV;
	          dVdsat_dVg = dVgs_eff_dVg / AbulkCV;
	          dVdsat_dVb = - (Vdsat * dAbulkCV_dVb + dVth_dVb)/ AbulkCV; 

                    if (model->BSIM3v1Sxpart > 0.5)
		    {   /* 0/100 Charge petition model */
		        if (Vdsat <= Vds)
		        {   /* saturation region */
	                    T1 = Vdsat / 3.0;
	                    qgate = CoxWL * (Vgs_eff - Vfb
			          - pParam->BSIM3v1Sphi - T1);
	                    T2 = -Two_Third_CoxWL * Vgst;
	                    qbulk = -(qgate + T2);
	                    qdrn = 0.0;

	                    here->BSIM3v1Scggb = One_Third_CoxWL * (3.0
					    - dVdsat_dVg) * dVgs_eff_dVg;
	                    T2 = -One_Third_CoxWL * dVdsat_dVb;
	                    here->BSIM3v1Scgsb = -(here->BSIM3v1Scggb + T2);
        	            here->BSIM3v1Scgdb = 0.0;
       
                            here->BSIM3v1Scdgb = 0.0;
                            here->BSIM3v1Scddb = 0.0;
                            here->BSIM3v1Scdsb = 0.0;

	                    here->BSIM3v1Scbgb = -(here->BSIM3v1Scggb
					    - Two_Third_CoxWL * dVgs_eff_dVg);
	                    T3 = -(T2 + Two_Third_CoxWL * dVth_dVb);
	                    here->BSIM3v1Scbsb = -(here->BSIM3v1Scbgb + T3);
                            here->BSIM3v1Scbdb = 0.0;
	                }
		        else
		        {   /* linear region */
			    Alphaz = Vgst / Vdsat;
	                    T1 = 2.0 * Vdsat - Vds;
	                    T2 = Vds / (3.0 * T1);
	                    T3 = T2 * Vds;
	                    T9 = 0.25 * CoxWL;
	                    T4 = T9 * Alphaz;
	                    T7 = 2.0 * Vds - T1 - 3.0 * T3;
	                    T8 = T3 - T1 - 2.0 * Vds;
	                    qgate = CoxWL * (Vgs_eff - Vfb 
			          - pParam->BSIM3v1Sphi - 0.5 * (Vds - T3));
	                    T10 = T4 * T8;
	                    qdrn = T4 * T7;
	                    qbulk = -(qgate + qdrn + T10);
  
                            T5 = T3 / T1;
                            here->BSIM3v1Scggb = CoxWL * (1.0 - T5 * dVdsat_dVg)
					    * dVgs_eff_dVg;
                            T11 = -CoxWL * T5 * dVdsat_dVb;
                            here->BSIM3v1Scgdb = CoxWL * (T2 - 0.5 + 0.5 * T5);
                            here->BSIM3v1Scgsb = -(here->BSIM3v1Scggb + T11
                                            + here->BSIM3v1Scgdb);
                            T6 = 1.0 / Vdsat;
                            dAlphaz_dVg = T6 * (1.0 - Alphaz * dVdsat_dVg);
                            dAlphaz_dVb = -T6 * (dVth_dVb + Alphaz * dVdsat_dVb);
                            T7 = T9 * T7;
                            T8 = T9 * T8;
                            T9 = 2.0 * T4 * (1.0 - 3.0 * T5);
                            here->BSIM3v1Scdgb = (T7 * dAlphaz_dVg - T9
					    * dVdsat_dVg) * dVgs_eff_dVg;
                            T12 = T7 * dAlphaz_dVb - T9 * dVdsat_dVb;
                            here->BSIM3v1Scddb = T4 * (3.0 - 6.0 * T2 - 3.0 * T5);
                            here->BSIM3v1Scdsb = -(here->BSIM3v1Scdgb + T12
                                            + here->BSIM3v1Scddb);

                            T9 = 2.0 * T4 * (1.0 + T5);
                            T10 = (T8 * dAlphaz_dVg - T9 * dVdsat_dVg)
				* dVgs_eff_dVg;
                            T11 = T8 * dAlphaz_dVb - T9 * dVdsat_dVb;
                            T12 = T4 * (2.0 * T2 + T5 - 1.0); 
                            T0 = -(T10 + T11 + T12);

                            here->BSIM3v1Scbgb = -(here->BSIM3v1Scggb
					    + here->BSIM3v1Scdgb + T10);
                            here->BSIM3v1Scbdb = -(here->BSIM3v1Scgdb 
					    + here->BSIM3v1Scddb + T12);
                            here->BSIM3v1Scbsb = -(here->BSIM3v1Scgsb
					    + here->BSIM3v1Scdsb + T0);
                        }
                    }
		    else if (model->BSIM3v1Sxpart < 0.5)
		    {   /* 40/60 Charge petition model */
		        if (Vds >= Vdsat)
		        {   /* saturation region */
	                    T1 = Vdsat / 3.0;
	                    qgate = CoxWL * (Vgs_eff - Vfb
			          - pParam->BSIM3v1Sphi - T1);
	                    T2 = -Two_Third_CoxWL * Vgst;
	                    qbulk = -(qgate + T2);
	                    qdrn = 0.4 * T2;

	                    here->BSIM3v1Scggb = One_Third_CoxWL * (3.0 
					    - dVdsat_dVg) * dVgs_eff_dVg;
	                    T2 = -One_Third_CoxWL * dVdsat_dVb;
	                    here->BSIM3v1Scgsb = -(here->BSIM3v1Scggb + T2);
        	            here->BSIM3v1Scgdb = 0.0;
       
			    T3 = 0.4 * Two_Third_CoxWL;
                            here->BSIM3v1Scdgb = -T3 * dVgs_eff_dVg;
                            here->BSIM3v1Scddb = 0.0;
			    T4 = T3 * dVth_dVb;
                            here->BSIM3v1Scdsb = -(T4 + here->BSIM3v1Scdgb);

	                    here->BSIM3v1Scbgb = -(here->BSIM3v1Scggb 
					    - Two_Third_CoxWL * dVgs_eff_dVg);