b3v1sld.c

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

	                    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;
			    qgate = CoxWL * (Vgs_eff - Vfb - pParam->BSIM3v1Sphi
				  - 0.5 * (Vds - T3));

			    T5 = T3 / T1;
                            here->BSIM3v1Scggb = CoxWL * (1.0 - T5 * dVdsat_dVg)
					    * dVgs_eff_dVg;
                            tmp = -CoxWL * T5 * dVdsat_dVb;
                            here->BSIM3v1Scgdb = CoxWL * (T2 - 0.5 + 0.5 * T5);
                            here->BSIM3v1Scgsb = -(here->BSIM3v1Scggb 
					+ here->BSIM3v1Scgdb + tmp);

			    T6 = 1.0 / Vdsat;
                            dAlphaz_dVg = T6 * (1.0 - Alphaz * dVdsat_dVg);
                            dAlphaz_dVb = -T6 * (dVth_dVb + Alphaz * dVdsat_dVb);

			    T6 = 8.0 * Vdsat * Vdsat - 6.0 * Vdsat * Vds
			       + 1.2 * Vds * Vds;
			    T8 = T2 / T1;
			    T7 = Vds - T1 - T8 * T6;
			    qdrn = T4 * T7;
			    T7 *= T9;
			    tmp = T8 / T1;
			    tmp1 = T4 * (2.0 - 4.0 * tmp * T6
				 + T8 * (16.0 * Vdsat - 6.0 * Vds));

                            here->BSIM3v1Scdgb = (T7 * dAlphaz_dVg - tmp1
					    * dVdsat_dVg) * dVgs_eff_dVg;
                            T10 = T7 * dAlphaz_dVb - tmp1 * dVdsat_dVb;
                            here->BSIM3v1Scddb = T4 * (2.0 - (1.0 / (3.0 * T1
					    * T1) + 2.0 * tmp) * T6 + T8
					    * (6.0 * Vdsat - 2.4 * Vds));
                            here->BSIM3v1Scdsb = -(here->BSIM3v1Scdgb 
					    + T10 + here->BSIM3v1Scddb);

			    T7 = 2.0 * (T1 + T3);
			    qbulk = -(qgate - T4 * T7);
			    T7 *= T9;
			    T0 = 4.0 * T4 * (1.0 - T5);
			    T12 = (-T7 * dAlphaz_dVg - here->BSIM3v1Scdgb
				- T0 * dVdsat_dVg) * dVgs_eff_dVg;
			    T11 = -T7 * dAlphaz_dVb - T10 - T0 * dVdsat_dVb;
			    T10 = -4.0 * T4 * (T2 - 0.5 + 0.5 * T5) 
				- here->BSIM3v1Scddb;
                            tmp = -(T10 + T11 + T12);

                            here->BSIM3v1Scbgb = -(here->BSIM3v1Scggb 
					    + here->BSIM3v1Scdgb + T12);
                            here->BSIM3v1Scbdb = -(here->BSIM3v1Scgdb
					    + here->BSIM3v1Scddb + T11);
                            here->BSIM3v1Scbsb = -(here->BSIM3v1Scgsb
					    + here->BSIM3v1Scdsb + tmp);
                        }
                    }
		    else
		    {   /* 50/50 partitioning */
		        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.5 * 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;
       
                            here->BSIM3v1Scdgb = -One_Third_CoxWL * dVgs_eff_dVg;
                            here->BSIM3v1Scddb = 0.0;
			    T4 = One_Third_CoxWL * dVth_dVb;
                            here->BSIM3v1Scdsb = -(T4 + here->BSIM3v1Scdgb);

	                    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;
			    qgate = CoxWL * (Vgs_eff - Vfb - pParam->BSIM3v1Sphi
				  - 0.5 * (Vds - T3));

			    T5 = T3 / T1;
                            here->BSIM3v1Scggb = CoxWL * (1.0 - T5 * dVdsat_dVg)
					    * dVgs_eff_dVg;
                            tmp = -CoxWL * T5 * dVdsat_dVb;
                            here->BSIM3v1Scgdb = CoxWL * (T2 - 0.5 + 0.5 * T5);
                            here->BSIM3v1Scgsb = -(here->BSIM3v1Scggb 
					+ here->BSIM3v1Scgdb + tmp);

			    T6 = 1.0 / Vdsat;
                            dAlphaz_dVg = T6 * (1.0 - Alphaz * dVdsat_dVg);
                            dAlphaz_dVb = -T6 * (dVth_dVb + Alphaz * dVdsat_dVb);

			    T7 = T1 + T3;
			    qdrn = -T4 * T7;
			    qbulk = - (qgate + qdrn + qdrn);
			    T7 *= T9;
			    T0 = T4 * (2.0 * T5 - 2.0);

                            here->BSIM3v1Scdgb = (T0 * dVdsat_dVg - T7
					    * dAlphaz_dVg) * dVgs_eff_dVg;
			    T12 = T0 * dVdsat_dVb - T7 * dAlphaz_dVb;
                            here->BSIM3v1Scddb = T4 * (1.0 - 2.0 * T2 - T5);
                            here->BSIM3v1Scdsb = -(here->BSIM3v1Scdgb + T12
                                        + here->BSIM3v1Scddb);

                            here->BSIM3v1Scbgb = -(here->BSIM3v1Scggb
					+ 2.0 * here->BSIM3v1Scdgb);
                            here->BSIM3v1Scbdb = -(here->BSIM3v1Scgdb
					+ 2.0 * here->BSIM3v1Scddb);
                            here->BSIM3v1Scbsb = -(here->BSIM3v1Scgsb
					+ 2.0 * here->BSIM3v1Scdsb);
                        }
	            }
		 }

          } 
	  else
	  {   if (Vbseff < 0.0)
	      {   VbseffCV = Vbseff;
                  dVbseffCV_dVb = 1.0;
              }
	      else
	      {   VbseffCV = pParam->BSIM3v1Sphi - Phis;
                  dVbseffCV_dVb = -dPhis_dVb;
              }

              CoxWL = model->BSIM3v1Scox * pParam->BSIM3v1SweffCV
		    * pParam->BSIM3v1SleffCV;
	      Vfb = Vth - pParam->BSIM3v1Sphi - pParam->BSIM3v1Sk1 * sqrtPhis;

	      dVfb_dVb = dVth_dVb - pParam->BSIM3v1Sk1 * dsqrtPhis_dVb;
              dVfb_dVd = dVth_dVd;

              if ((VgstNVt > -EXP_THRESHOLD) && (VgstNVt < EXP_THRESHOLD))
	      {   ExpVgst *= ExpVgst;
                  Vgsteff = n * Vtm * log(1.0 + ExpVgst);
                  dVgsteff_dVg = ExpVgst / (1.0 + ExpVgst);
                  dVgsteff_dVd = -dVgsteff_dVg * (dVth_dVd + (Vgs_eff - Vth)
			       / n * dn_dVd) + Vgsteff / n * dn_dVd;
                  dVgsteff_dVb = -dVgsteff_dVg * (dVth_dVb + (Vgs_eff - Vth)
			       / n * dn_dVb) + Vgsteff / n * dn_dVb;
	          dVgsteff_dVg *= dVgs_eff_dVg;
              }

	      if (model->BSIM3v1ScapMod == 1)
	      {   Arg1 = Vgs_eff - VbseffCV - Vfb - Vgsteff;

                  if (Arg1 <= 0.0)
	          {   qgate = CoxWL * Arg1;
                      Cgg = CoxWL * (dVgs_eff_dVg - dVgsteff_dVg);
                      Cgd = -CoxWL * (dVfb_dVd + dVgsteff_dVd);
                      Cgb = -CoxWL * (dVfb_dVb + dVbseffCV_dVb + dVgsteff_dVb);
                  }
	          else
	          {   T0 = 0.5 * pParam->BSIM3v1Sk1;
		      T1 = sqrt(T0 * T0 + Arg1);
                      T2 = CoxWL * T0 / T1;
		      
                      qgate = CoxWL * pParam->BSIM3v1Sk1 * (T1 - T0);

                      Cgg = T2 * (dVgs_eff_dVg - dVgsteff_dVg);
                      Cgd = -T2 * (dVfb_dVd + dVgsteff_dVd);
                      Cgb = -T2 * (dVfb_dVb + dVbseffCV_dVb + dVgsteff_dVb);
                  }
	          qbulk = -qgate;
	          Cbg = -Cgg;
	          Cbd = -Cgd;
	          Cbb = -Cgb;

                  One_Third_CoxWL = CoxWL / 3.0;
                  Two_Third_CoxWL = 2.0 * One_Third_CoxWL;
                  AbulkCV = Abulk0 * pParam->BSIM3v1SabulkCVfactor;
                  dAbulkCV_dVb = pParam->BSIM3v1SabulkCVfactor * dAbulk0_dVb;
	          VdsatCV = Vgsteff / AbulkCV;
                  if (VdsatCV < Vds)
	          {   dVdsatCV_dVg = 1.0 / AbulkCV;
	              dVdsatCV_dVb = -VdsatCV * dAbulkCV_dVb / AbulkCV;
		      T0 = Vgsteff - VdsatCV / 3.0;
                      dT0_dVg = 1.0 - dVdsatCV_dVg / 3.0;
                      dT0_dVb = -dVdsatCV_dVb / 3.0;
                      qgate += CoxWL * T0;
                      Cgg1 = CoxWL * dT0_dVg; 
                      Cgb1 = CoxWL * dT0_dVb + Cgg1 * dVgsteff_dVb;
                      Cgd1 = Cgg1 * dVgsteff_dVd;
		      Cgg1 *= dVgsteff_dVg;
		      Cgg += Cgg1;
		      Cgb += Cgb1;
		      Cgd += Cgd1;

		      T0 = VdsatCV - Vgsteff;
		      dT0_dVg = dVdsatCV_dVg - 1.0;
		      dT0_dVb = dVdsatCV_dVb;
                      qbulk += One_Third_CoxWL * T0;
                      Cbg1 = One_Third_CoxWL * dT0_dVg;
		      Cbb1 = One_Third_CoxWL * dT0_dVb + Cbg1 * dVgsteff_dVb;
		      Cbd1 = Cbg1 * dVgsteff_dVd;
		      Cbg1 *= dVgsteff_dVg;
		      Cbg += Cbg1;
		      Cbb += Cbb1;
                      Cbd += Cbd1;

                      if (model->BSIM3v1Sxpart > 0.5)
		          T0 = -Two_Third_CoxWL;
                      else if (model->BSIM3v1Sxpart < 0.5)
		          T0 = -0.4 * CoxWL;
                      else
		          T0 = -One_Third_CoxWL;

                      qsrc = T0 * Vgsteff;
                      Csg = T0 * dVgsteff_dVg;
                      Csb = T0 * dVgsteff_dVb;
                      Csd = T0 * dVgsteff_dVd;
		      Cgb *= dVbseff_dVb;
		      Cbb *= dVbseff_dVb;
		      Csb *= dVbseff_dVb;
                  }
	          else
	          {   T0 = AbulkCV * Vds;
                      T1 = 12.0 * (Vgsteff - 0.5 * T0 + 1.e-20);
		      T2 = Vds / T1;
		      T3 = T0 * T2;
                      dT3_dVg = -12.0 * T2 * T2 * AbulkCV;
                      dT3_dVd = 6.0 * T0 * (4.0 * Vgsteff - T0) / T1 / T1 - 0.5;
                      dT3_dVb = 12.0 * T2 * T2 * dAbulkCV_dVb * Vgsteff;

                      qgate += CoxWL * (Vgsteff - 0.5 * Vds + T3);
                      Cgg1 = CoxWL * (1.0 + dT3_dVg);
                      Cgb1 = CoxWL * dT3_dVb + Cgg1 * dVgsteff_dVb;
                      Cgd1 = CoxWL * dT3_dVd + Cgg1 * dVgsteff_dVd;
		      Cgg1 *= dVgsteff_dVg;
		      Cgg += Cgg1;
		      Cgb += Cgb1;
		      Cgd += Cgd1;

                      qbulk += CoxWL * (1.0 - AbulkCV) * (0.5 * Vds - T3);
		      Cbg1 = -CoxWL * ((1.0 - AbulkCV) * dT3_dVg);
		      Cbb1 = -CoxWL * ((1.0 - AbulkCV) * dT3_dVb
		           + (0.5 * Vds - T3) * dAbulkCV_dVb)
		           + Cbg1 * dVgsteff_dVb;
		      Cbd1 = -CoxWL * (1.0 - AbulkCV) * dT3_dVd
		           + Cbg1 * dVgsteff_dVd;
		      Cbg1 *= dVgsteff_dVg;
		      Cbg += Cbg1;
		      Cbb += Cbb1;
		      Cbd += Cbd1;

                      if (model->BSIM3v1Sxpart > 0.5)
		      {   /* 0/100 Charge petition model */
		          T1 = T1 + T1;
                          qsrc = -CoxWL * (0.5 * Vgsteff + 0.25 * T0
			       - T0 * T0 / T1);
		          Csg = -CoxWL * (0.5 + 24.0 * T0 * Vds / T1 / T1
			      * AbulkCV);
                          Csb = -CoxWL * (0.25 * Vds * dAbulkCV_dVb
			      - 12.0 * T0 * Vds / T1 / T1 * (4.0 * Vgsteff - T0)
			      * dAbulkCV_dVb) + Csg * dVgsteff_dVb;
		          Csd = -CoxWL * (0.25 * AbulkCV - 12.0 * AbulkCV * T0
			      / T1 / T1 * (4.0 * Vgsteff - T0))
			      + Csg * dVgsteff_dVd;
		          Csg *= dVgsteff_dVg;
                      }
		      else if (model->BSIM3v1Sxpart < 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;
		          T4 = 4.0 / 3.0 * Vgsteff * (Vgsteff - T0)
			     + 0.4 * T0 * T0;
		          Csg = -2.0 * qsrc / T1 - T2 * (Vgsteff * (3.0
			      * Vgsteff - 8.0 * T0 / 3.0)
			      + 2.0 * T0 * T0 / 3.0);
		          Csb = (qsrc / T1 * Vds + T2 * T4 * Vds) * dAbulkCV_dVb
		              + Csg * dVgsteff_dVb;
		          Csd = (qsrc / T1 + T2 * T4) * AbulkCV
			      + Csg * dVgsteff_dVd;
		          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); 
                      }
		      Cgb *= dVbseff_dVb;
		      Cbb *= dVbseff_dVb;
		      Csb *= dVbseff_dVb;
                  }
                  qdrn = -(qgate + qbulk + qsrc);
                  here->BSIM3v1Scggb = Cgg;
	          here->BSIM3v1Scgsb = -(Cgg + Cgd + Cgb);
	          here->BSIM3v1Scgdb = Cgd;
                  here->BSIM3v1Scdgb = -(Cgg + Cbg + Csg);
	          here->BSIM3v1Scdsb = (Cgg + Cgd + Cgb + Cbg + Cbd + Cbb
			          + Csg + Csd + Csb);
	          here->BSIM3v1Scddb = -(Cgd + Cbd + Csd);
                  here->BSIM3v1Scbgb = Cbg;
	          here->BSIM3v1Scbsb = -(Cbg + Cbd + Cbb);
	          here->BSIM3v1Scbdb = Cbd;
	      }
	      else if (model->BSIM3v1ScapMod == 2)

	      {   V3 = Vfb - Vgs_eff + VbseffCV - DELTA_3;