b4noi.c

来自「ngspice又一个电子CAD仿真软件代码.功能更全」· C语言 代码 · 共 489 行 · 第 1/2 页

			      }
			      else if (here->BSIM4rgateMod == 3)
			      {   NevalSrc(&noizDens[BSIM4RGNOIZ],
                                       &lnNdens[BSIM4RGNOIZ], ckt, THERMNOISE,
                                       here->BSIM4gNodeMid, here->BSIM4gNodeExt,
                                       here->BSIM4grgeltd * m);
			      }
			      else
			      {    noizDens[BSIM4RGNOIZ] = 0.0;
                                   lnNdens[BSIM4RGNOIZ] =
                                          log(MAX(noizDens[BSIM4RGNOIZ], N_MINLOG));
			      }


                              if (here->BSIM4rbodyMod)
                              {   NevalSrc(&noizDens[BSIM4RBPSNOIZ],
                                       &lnNdens[BSIM4RBPSNOIZ], ckt, THERMNOISE,
                                       here->BSIM4bNodePrime, here->BSIM4sbNode,
                                       here->BSIM4grbps * m);
                                  NevalSrc(&noizDens[BSIM4RBPDNOIZ],
                                       &lnNdens[BSIM4RBPDNOIZ], ckt, THERMNOISE,
                                       here->BSIM4bNodePrime, here->BSIM4dbNode,
                                       here->BSIM4grbpd * m);
                                  NevalSrc(&noizDens[BSIM4RBPBNOIZ],
                                       &lnNdens[BSIM4RBPBNOIZ], ckt, THERMNOISE,
                                       here->BSIM4bNodePrime, here->BSIM4bNode,
                                       here->BSIM4grbpb * m);
                                  NevalSrc(&noizDens[BSIM4RBSBNOIZ],
                                       &lnNdens[BSIM4RBSBNOIZ], ckt, THERMNOISE,
                                       here->BSIM4bNode, here->BSIM4sbNode,
                                       here->BSIM4grbsb * m);
                                  NevalSrc(&noizDens[BSIM4RBDBNOIZ],
                                       &lnNdens[BSIM4RBDBNOIZ], ckt, THERMNOISE,
                                       here->BSIM4bNode, here->BSIM4dbNode,
                                       here->BSIM4grbdb * m);
                              }
                              else
                              {   noizDens[BSIM4RBPSNOIZ] = noizDens[BSIM4RBPDNOIZ] = 0.0;   
                                  noizDens[BSIM4RBPBNOIZ] = 0.0;
                                  noizDens[BSIM4RBSBNOIZ] = noizDens[BSIM4RBDBNOIZ] = 0.0;
                                  lnNdens[BSIM4RBPSNOIZ] =
                                          log(MAX(noizDens[BSIM4RBPSNOIZ], N_MINLOG));
                                  lnNdens[BSIM4RBPDNOIZ] =
                                          log(MAX(noizDens[BSIM4RBPDNOIZ], N_MINLOG));
                                  lnNdens[BSIM4RBPBNOIZ] =
                                          log(MAX(noizDens[BSIM4RBPBNOIZ], N_MINLOG));
                                  lnNdens[BSIM4RBSBNOIZ] =
                                          log(MAX(noizDens[BSIM4RBSBNOIZ], N_MINLOG));
                                  lnNdens[BSIM4RBDBNOIZ] =
                                          log(MAX(noizDens[BSIM4RBDBNOIZ], N_MINLOG));
                              }


                              switch(model->BSIM4tnoiMod)
			      {  case 0:
				      T0 = m * here->BSIM4ueff * fabs(here->BSIM4qinv);
				      T1 = T0 * tmp + pParam->BSIM4leff
                                         * pParam->BSIM4leff;
		                      NevalSrc(&noizDens[BSIM4IDNOIZ],
				               &lnNdens[BSIM4IDNOIZ], ckt,
					       THERMNOISE, here->BSIM4dNodePrime,
                                               here->BSIM4sNodePrime,
					       (T0 / T1) * model->BSIM4ntnoi);
				      break;
				 case 1:
				      T0 = m * (here->BSIM4gm + here->BSIM4gmbs + here->BSIM4gds);
				      T0 *= T0;
				      igsquare = npart_theta * npart_theta * T0 / here->BSIM4IdovVds;
				      T1 = npart_beta * (here->BSIM4gm
					 + here->BSIM4gmbs) + here->BSIM4gds;
				      T2 = T1 * T1 / here->BSIM4IdovVds;
                                      NevalSrc(&noizDens[BSIM4IDNOIZ],
                                               &lnNdens[BSIM4IDNOIZ], ckt,
                                               THERMNOISE, here->BSIM4dNodePrime,
                                               here->BSIM4sNodePrime, (T2 - igsquare));
                                      break;
			      }

		              NevalSrc(&noizDens[BSIM4FLNOIZ], (double*) NULL,
				       ckt, N_GAIN, here->BSIM4dNodePrime,
				       here->BSIM4sNodePrime, (double) 0.0);

                              switch(model->BSIM4fnoiMod)
			      {  case 0:
			              noizDens[BSIM4FLNOIZ] *= m * model->BSIM4kf
					    * exp(model->BSIM4af
					    * log(MAX(fabs(here->BSIM4cd),
					    N_MINLOG)))
					    / (pow(data->freq, model->BSIM4ef)
					    * pParam->BSIM4leff
				            * pParam->BSIM4leff
					    * model->BSIM4coxe);
				      break;
			         case 1:
		                      Vds = *(ckt->CKTstates[0] + here->BSIM4vds);
			              if (Vds < 0.0)
			                  Vds = -Vds;

                                      Ssi = Eval1ovFNoise(Vds, model, here,
                                          data->freq, ckt->CKTtemp);
                                      T10 = model->BSIM4oxideTrapDensityA
                                          * CONSTboltz * ckt->CKTtemp;
                                      T11 = pParam->BSIM4weff * pParam->BSIM4leff
                                          * pow(data->freq, model->BSIM4ef) * 1.0e10
					  * here->BSIM4nstar * here->BSIM4nstar;
                                      Swi = T10 / T11 * here->BSIM4cd
                                          * here->BSIM4cd;
                                      T1 = Swi + Ssi;
                                      if (T1 > 0.0)
                                          noizDens[BSIM4FLNOIZ] *= m * (Ssi * Swi) / T1;
                                      else
                                          noizDens[BSIM4FLNOIZ] *= 0.0;
				      break;
			      }

		              lnNdens[BSIM4FLNOIZ] =
				     log(MAX(noizDens[BSIM4FLNOIZ], N_MINLOG));


                       	if(here->BSIM4mode >= 0) {  /* bugfix  */
                              NevalSrc(&noizDens[BSIM4IGSNOIZ],
                                   &lnNdens[BSIM4IGSNOIZ], ckt, SHOTNOISE,
                                   here->BSIM4gNodePrime, here->BSIM4sNodePrime,
                                   m * (here->BSIM4Igs + here->BSIM4Igcs));
                              NevalSrc(&noizDens[BSIM4IGDNOIZ],
                                   &lnNdens[BSIM4IGDNOIZ], ckt, SHOTNOISE,
                                   here->BSIM4gNodePrime, here->BSIM4dNodePrime,
                                   m * (here->BSIM4Igd + here->BSIM4Igcd));
			} else {
                              NevalSrc(&noizDens[BSIM4IGSNOIZ],
                                   &lnNdens[BSIM4IGSNOIZ], ckt, SHOTNOISE,
                                   here->BSIM4gNodePrime, here->BSIM4sNodePrime,
                                   m * (here->BSIM4Igs + here->BSIM4Igcd));
                              NevalSrc(&noizDens[BSIM4IGDNOIZ],
                                   &lnNdens[BSIM4IGDNOIZ], ckt, SHOTNOISE,
                                   here->BSIM4gNodePrime, here->BSIM4dNodePrime,
                                   m * (here->BSIM4Igd + here->BSIM4Igcs));
                        }
                              NevalSrc(&noizDens[BSIM4IGBNOIZ],
                                   &lnNdens[BSIM4IGBNOIZ], ckt, SHOTNOISE,
                                   here->BSIM4gNodePrime, here->BSIM4bNodePrime,
                                   m * here->BSIM4Igb);


		              noizDens[BSIM4TOTNOIZ] = noizDens[BSIM4RDNOIZ]
				     + noizDens[BSIM4RSNOIZ] + noizDens[BSIM4RGNOIZ]
				     + noizDens[BSIM4RBPSNOIZ] + noizDens[BSIM4RBPDNOIZ]
				     + noizDens[BSIM4RBPBNOIZ]
				     + noizDens[BSIM4RBSBNOIZ] + noizDens[BSIM4RBDBNOIZ]
				     + noizDens[BSIM4IDNOIZ] + noizDens[BSIM4FLNOIZ]
                                     + noizDens[BSIM4IGSNOIZ] + noizDens[BSIM4IGDNOIZ]
                                     + noizDens[BSIM4IGBNOIZ];
		              lnNdens[BSIM4TOTNOIZ] = 
				     log(MAX(noizDens[BSIM4TOTNOIZ], N_MINLOG));

		              *OnDens += noizDens[BSIM4TOTNOIZ];

		              if (data->delFreq == 0.0)
			      {   /* if we haven't done any previous 
				     integration, we need to initialize our
				     "history" variables.
				    */

			          for (i = 0; i < BSIM4NSRCS; i++)
				  {    here->BSIM4nVar[LNLSTDENS][i] =
					     lnNdens[i];
			          }

			          /* clear out our integration variables
				     if it's the first pass
				   */
			          if (data->freq ==
				      ((NOISEAN*) ckt->CKTcurJob)->NstartFreq)
				  {   for (i = 0; i < BSIM4NSRCS; i++)
				      {    here->BSIM4nVar[OUTNOIZ][i] = 0.0;
				           here->BSIM4nVar[INNOIZ][i] = 0.0;
			              }
			          }
		              }
			      else
			      {   /* data->delFreq != 0.0,
				     we have to integrate.
				   */
			          for (i = 0; i < BSIM4NSRCS; i++)
				  {    if (i != BSIM4TOTNOIZ)
				       {   tempOnoise = Nintegrate(noizDens[i],
						lnNdens[i],
				                here->BSIM4nVar[LNLSTDENS][i],
						data);
				           tempInoise = Nintegrate(noizDens[i]
						* data->GainSqInv, lnNdens[i]
						+ data->lnGainInv,
				                here->BSIM4nVar[LNLSTDENS][i]
						+ data->lnGainInv, data);
				           here->BSIM4nVar[LNLSTDENS][i] =
						lnNdens[i];
				           data->outNoiz += tempOnoise;
				           data->inNoise += tempInoise;
				           if (((NOISEAN*)
					       ckt->CKTcurJob)->NStpsSm != 0)
					   {   here->BSIM4nVar[OUTNOIZ][i]
						     += tempOnoise;
				               here->BSIM4nVar[OUTNOIZ][BSIM4TOTNOIZ]
						     += tempOnoise;
				               here->BSIM4nVar[INNOIZ][i]
						     += tempInoise;
				               here->BSIM4nVar[INNOIZ][BSIM4TOTNOIZ]
						     += tempInoise;
                                           }
			               }
			          }
		              }
		              if (data->prtSummary)
			      {   for (i = 0; i < BSIM4NSRCS; i++)
				  {    /* print a summary report */
			               data->outpVector[data->outNumber++]
					     = noizDens[i];
			          }
		              }
		              break;
		         case INT_NOIZ:
			      /* already calculated, just output */
		              if (((NOISEAN*)ckt->CKTcurJob)->NStpsSm != 0)
			      {   for (i = 0; i < BSIM4NSRCS; i++)
				  {    data->outpVector[data->outNumber++]
					     = here->BSIM4nVar[OUTNOIZ][i];
			               data->outpVector[data->outNumber++]
					     = here->BSIM4nVar[INNOIZ][i];
			          }
		              }
		              break;
		      }
		      break;
	         case N_CLOSE:
		      /* do nothing, the main calling routine will close */
		      return (OK);
		      break;   /* the plots */
	      }       /* switch (operation) */
	 }    /* for here */
    }    /* for model */

    return(OK);
}