b3soipdld.c

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

          }
	  else if ((ckt->CKTmode & MODEINITJCT) && !here->B3SOIPDoff)
	  {   vds = model->B3SOIPDtype * here->B3SOIPDicVDS;
              vgs = model->B3SOIPDtype * here->B3SOIPDicVGS;
              ves = model->B3SOIPDtype * here->B3SOIPDicVES;
              vbs = model->B3SOIPDtype * here->B3SOIPDicVBS;
              vps = model->B3SOIPDtype * here->B3SOIPDicVPS;

	      vg = vd = vs = vp = ve = 0.0;


              delTemp = 0.0;
	      here->B3SOIPDphi = pParam->B3SOIPDphi;



	      if ((vds == 0.0) && (vgs == 0.0) && (vbs == 0.0) && 
	         ((ckt->CKTmode & (MODETRAN | MODEAC|MODEDCOP |
		   MODEDCTRANCURVE)) || (!(ckt->CKTmode & MODEUIC))))
	      {   vbs = 0.0;
		  vgs = model->B3SOIPDtype*0.1 + pParam->B3SOIPDvth0;
		  vds = 0.0;
		  ves = 0.0;
		  vps = 0.0;
	      }
	  }
	  else if ((ckt->CKTmode & (MODEINITJCT | MODEINITFIX)) && 
		  (here->B3SOIPDoff)) 
	  {    delTemp = vps = vbs = vgs = vds = ves = 0.0;
               vg = vd = vs = vp = ve = 0.0;
	  }
	  else
	  {
#ifndef PREDICTOR
	       if ((ckt->CKTmode & MODEINITPRED))
	       {   xfact = ckt->CKTdelta / ckt->CKTdeltaOld[1];
		   *(ckt->CKTstate0 + here->B3SOIPDvbs) = 
			 *(ckt->CKTstate1 + here->B3SOIPDvbs);
		   vbs = (1.0 + xfact)* (*(ckt->CKTstate1 + here->B3SOIPDvbs))
			 - (xfact * (*(ckt->CKTstate2 + here->B3SOIPDvbs)));
		   *(ckt->CKTstate0 + here->B3SOIPDvgs) = 
			 *(ckt->CKTstate1 + here->B3SOIPDvgs);
		   vgs = (1.0 + xfact)* (*(ckt->CKTstate1 + here->B3SOIPDvgs))
			 - (xfact * (*(ckt->CKTstate2 + here->B3SOIPDvgs)));
		   *(ckt->CKTstate0 + here->B3SOIPDves) = 
			 *(ckt->CKTstate1 + here->B3SOIPDves);
		   ves = (1.0 + xfact)* (*(ckt->CKTstate1 + here->B3SOIPDves))
			 - (xfact * (*(ckt->CKTstate2 + here->B3SOIPDves)));
		   *(ckt->CKTstate0 + here->B3SOIPDvps) = 
			 *(ckt->CKTstate1 + here->B3SOIPDvps);
		   vps = (1.0 + xfact)* (*(ckt->CKTstate1 + here->B3SOIPDvps))
			 - (xfact * (*(ckt->CKTstate2 + here->B3SOIPDvps)));
		   *(ckt->CKTstate0 + here->B3SOIPDvds) = 
			 *(ckt->CKTstate1 + here->B3SOIPDvds);
		   vds = (1.0 + xfact)* (*(ckt->CKTstate1 + here->B3SOIPDvds))
			 - (xfact * (*(ckt->CKTstate2 + here->B3SOIPDvds)));
		   *(ckt->CKTstate0 + here->B3SOIPDvbd) = 
			 *(ckt->CKTstate0 + here->B3SOIPDvbs)
			 - *(ckt->CKTstate0 + here->B3SOIPDvds);

                   *(ckt->CKTstate0 + here->B3SOIPDvg) = *(ckt->CKTstate1 + here->B3SOIPDvg);
                   *(ckt->CKTstate0 + here->B3SOIPDvd) = *(ckt->CKTstate1 + here->B3SOIPDvd);
                   *(ckt->CKTstate0 + here->B3SOIPDvs) = *(ckt->CKTstate1 + here->B3SOIPDvs);
                   *(ckt->CKTstate0 + here->B3SOIPDvp) = *(ckt->CKTstate1 + here->B3SOIPDvp);
                   *(ckt->CKTstate0 + here->B3SOIPDve) = *(ckt->CKTstate1 + here->B3SOIPDve);

                   /* Only predict ve */
                   ve = (1.0 + xfact)* (*(ckt->CKTstate1 + here->B3SOIPDve))

                        - (xfact * (*(ckt->CKTstate2 + here->B3SOIPDve)));
                   /* Then update vg, vs, vb, vd, vp base on ve */
                   vs = ve - model->B3SOIPDtype * ves;
                   vg = model->B3SOIPDtype * vgs + vs;
                   vd = model->B3SOIPDtype * vds + vs;
                   vb = model->B3SOIPDtype * vbs + vs;
                   vp = model->B3SOIPDtype * vps + vs;

		   delTemp = (1.0 + xfact)* (*(ckt->CKTstate1 +
			 here->B3SOIPDdeltemp))-(xfact * (*(ckt->CKTstate2 +
			 here->B3SOIPDdeltemp)));

/* v2.2.3 bug fix */
                   *(ckt->CKTstate0 + here->B3SOIPDdeltemp) = 
                         *(ckt->CKTstate1 + here->B3SOIPDdeltemp);

		   if (selfheat)
		   {
		       here->B3SOIPDphi = 2.0 * here->B3SOIPDvtm
					* log(pParam->B3SOIPDnpeak /
					       here->B3SOIPDni); 
		   }

	       }
	       else
	       {
#endif /* PREDICTOR */

                   vg = B3SOIPDlimit(*(ckt->CKTrhsOld + here->B3SOIPDgNode),
                                 *(ckt->CKTstate0 + here->B3SOIPDvg), 3.0, &Check);
                   vd = B3SOIPDlimit(*(ckt->CKTrhsOld + here->B3SOIPDdNodePrime),
                                 *(ckt->CKTstate0 + here->B3SOIPDvd), 3.0, &Check);
                   vs = B3SOIPDlimit(*(ckt->CKTrhsOld + here->B3SOIPDsNodePrime),
                                 *(ckt->CKTstate0 + here->B3SOIPDvs), 3.0, &Check);
                   vp = B3SOIPDlimit(*(ckt->CKTrhsOld + here->B3SOIPDpNode),
                                 *(ckt->CKTstate0 + here->B3SOIPDvp), 3.0, &Check);
                   ve = B3SOIPDlimit(*(ckt->CKTrhsOld + here->B3SOIPDeNode),
                                 *(ckt->CKTstate0 + here->B3SOIPDve), 3.0, &Check);
                   delTemp = *(ckt->CKTrhsOld + here->B3SOIPDtempNode);

		   vbs = model->B3SOIPDtype * (*(ckt->CKTrhsOld+here->B3SOIPDbNode)
                                - *(ckt->CKTrhsOld+here->B3SOIPDsNodePrime));

		   vps = model->B3SOIPDtype * (vp - vs);
		   vgs = model->B3SOIPDtype * (vg - vs);
		   ves = model->B3SOIPDtype * (ve - vs);
		   vds = model->B3SOIPDtype * (vd - vs);


#ifndef PREDICTOR
	       }
#endif /* PREDICTOR */

	       vbd = vbs - vds;
	       vgd = vgs - vds;
               ved = ves - vds;
	       vgdo = *(ckt->CKTstate0 + here->B3SOIPDvgs)
		    - *(ckt->CKTstate0 + here->B3SOIPDvds);
	       vedo = *(ckt->CKTstate0 + here->B3SOIPDves)
		    - *(ckt->CKTstate0 + here->B3SOIPDvds);
	       delvbs = vbs - *(ckt->CKTstate0 + here->B3SOIPDvbs);
	       delvbd = vbd - *(ckt->CKTstate0 + here->B3SOIPDvbd);
	       delvgs = vgs - *(ckt->CKTstate0 + here->B3SOIPDvgs);
	       delves = ves - *(ckt->CKTstate0 + here->B3SOIPDves);
	       delvps = vps - *(ckt->CKTstate0 + here->B3SOIPDvps);
	       deldelTemp = delTemp - *(ckt->CKTstate0 + here->B3SOIPDdeltemp);
	       delvds = vds - *(ckt->CKTstate0 + here->B3SOIPDvds);
	       delvgd = vgd - vgdo;
               delved = ved - vedo;

	       if (here->B3SOIPDmode >= 0) 
	       {   
                   cdhat = here->B3SOIPDcd + (here->B3SOIPDgm-here->B3SOIPDgjdg) * delvgs
                         + (here->B3SOIPDgds - here->B3SOIPDgjdd) * delvds
                         + (here->B3SOIPDgmbs - here->B3SOIPDgjdb) * delvbs
			 + (here->B3SOIPDgmT - here->B3SOIPDgjdT) * deldelTemp;
	       }
	       else
	       {   
                   cdhat = here->B3SOIPDcd + (here->B3SOIPDgm-here->B3SOIPDgjdg) * delvgd
                         - (here->B3SOIPDgds - here->B3SOIPDgjdd) * delvds
                         + (here->B3SOIPDgmbs - here->B3SOIPDgjdb) * delvbd
                         + (here->B3SOIPDgmT - here->B3SOIPDgjdT) * deldelTemp;

	       }
	       cbhat = here->B3SOIPDcb + here->B3SOIPDgbgs * delvgs
		     + here->B3SOIPDgbbs * delvbs 
                     + here->B3SOIPDgbds * delvds
                     + here->B3SOIPDgbps * delvps 
                     + here->B3SOIPDgbT * deldelTemp;

#ifndef NOBYPASS
	   /* following should be one big if connected by && all over
	    * the place, but some C compilers can't handle that, so
	    * we split it up here to let them digest it in stages
	    */

	       if ((!(ckt->CKTmode & MODEINITPRED)) && (ckt->CKTbypass) && Check == 0)
	       if ((fabs(delvbs) < (ckt->CKTreltol * MAX(fabs(vbs),
		   fabs(*(ckt->CKTstate0+here->B3SOIPDvbs))) + ckt->CKTvoltTol))  )
	       if ((fabs(delvbd) < (ckt->CKTreltol * MAX(fabs(vbd),
		   fabs(*(ckt->CKTstate0+here->B3SOIPDvbd))) + ckt->CKTvoltTol))  )
	       if ((fabs(delvgs) < (ckt->CKTreltol * MAX(fabs(vgs),
		   fabs(*(ckt->CKTstate0+here->B3SOIPDvgs))) + ckt->CKTvoltTol)))
	       if ((fabs(delves) < (ckt->CKTreltol * MAX(fabs(ves),
		   fabs(*(ckt->CKTstate0+here->B3SOIPDves))) + ckt->CKTvoltTol)))
	       if ( (here->B3SOIPDbodyMod == 0) || (here->B3SOIPDbodyMod == 2) ||
                  (fabs(delvps) < (ckt->CKTreltol * MAX(fabs(vps),
		   fabs(*(ckt->CKTstate0+here->B3SOIPDvps))) + ckt->CKTvoltTol)) )
	       if ( (here->B3SOIPDtempNode == 0)  ||
                  (fabs(deldelTemp) < (ckt->CKTreltol * MAX(fabs(delTemp),
		   fabs(*(ckt->CKTstate0+here->B3SOIPDdeltemp)))
		   + ckt->CKTvoltTol*1e4)))
	       if ((fabs(delvds) < (ckt->CKTreltol * MAX(fabs(vds),
		   fabs(*(ckt->CKTstate0+here->B3SOIPDvds))) + ckt->CKTvoltTol)))
	       if ((fabs(cdhat - here->B3SOIPDcd) < ckt->CKTreltol 
		   * MAX(fabs(cdhat),fabs(here->B3SOIPDcd)) + ckt->CKTabstol)) 
	       if ((fabs(cbhat - here->B3SOIPDcb) < ckt->CKTreltol 
		   * MAX(fabs(cbhat),fabs(here->B3SOIPDcb)) + ckt->CKTabstol) )
	       {   /* bypass code */
	           vbs = *(ckt->CKTstate0 + here->B3SOIPDvbs);
	           vbd = *(ckt->CKTstate0 + here->B3SOIPDvbd);
	           vgs = *(ckt->CKTstate0 + here->B3SOIPDvgs);
	           ves = *(ckt->CKTstate0 + here->B3SOIPDves);
	           vps = *(ckt->CKTstate0 + here->B3SOIPDvps);
	           vds = *(ckt->CKTstate0 + here->B3SOIPDvds);
	           delTemp = *(ckt->CKTstate0 + here->B3SOIPDdeltemp);

		   /*  calculate Vds for temperature conductance calculation
		       in bypass (used later when filling Temp node matrix)  */
		   Vds = here->B3SOIPDmode > 0 ? vds : -vds;

	           vgd = vgs - vds;
	           vgb = vgs - vbs;
                   veb = ves - vbs;

		   if ((ckt->CKTmode & (MODETRAN | MODEAC)) || 
		      ((ckt->CKTmode & MODETRANOP) && (ckt->CKTmode & MODEUIC)))
		   {   ByPass = 1;
		       goto line755;
		   }
		   else
		   {   goto line850;
		   }
	       }


#endif /*NOBYPASS*/
		       von = here->B3SOIPDvon;


                       if (*(ckt->CKTstate0 + here->B3SOIPDvds) >= 0.0)
                          T0 = *(ckt->CKTstate0 + here->B3SOIPDvbs);
                       else
                          T0 = *(ckt->CKTstate0 + here->B3SOIPDvbd);


		       if (vds >= 0.0) 
		       {   
		           vbs = B3SOIPDlimit(vbs, T0, 0.2, &Check);
			   vbd = vbs - vds;
                           vb = model->B3SOIPDtype * vbs + vs;
		       } else 
		       {   
		           vbd = B3SOIPDlimit(vbd, T0, 0.2, &Check);
			   vbs = vbd + vds;
                           vb = model->B3SOIPDtype * vbs + vd;
		       }

		       delTemp =B3SOIPDlimit(delTemp, *(ckt->CKTstate0 + here->B3SOIPDdeltemp),5.0,&Check);

                  }

/*  Calculate temperature dependent values for self-heating effect  */
		  Temp = delTemp + ckt->CKTtemp;
                  dTempRatio_dT = 1 / model->B3SOIPDtnom; 
                  TempRatio = Temp * dTempRatio_dT;

		  if (selfheat) {
		      Vtm = KboQ * Temp;

                      T0 = 1108.0 + Temp;
		      T5 = Temp * Temp;
		      Eg = 1.16 - 7.02e-4 * T5 / T0;
		      T1 = ((7.02e-4 * T5) - T0 * (14.04e-4 * Temp)) / T0 / T0;
                      /*  T1 = dEg / dT  */

                      T2 = 1.9230584e-4;  /*  T2 = 1 / 300.15^(3/2)  */
		      T5 = sqrt(Temp);
                      T3 = 1.45e10 * Temp * T5 * T2;
                      T4 = exp(21.5565981 - Eg / (2.0 * Vtm));
		      ni = T3 * T4;
                      dni_dT = 2.175e10 * T2 * T5 * T4 + T3 * T4 *
                               (-Vtm * T1 + Eg * KboQ) / (2.0 * Vtm * Vtm);

                      T0 = log(1.0e20 * pParam->B3SOIPDnpeak / (ni * ni));
		      vbi = Vtm * T0;
                      dvbi_dT = KboQ * T0 + Vtm * (-2.0 * dni_dT / ni);

		      if (pParam->B3SOIPDnsub > 0) {
                         T0 = log(pParam->B3SOIPDnpeak / pParam->B3SOIPDnsub);
		         vfbb = -model->B3SOIPDtype * Vtm * T0;
                         dvfbb_dT = -model->B3SOIPDtype * KboQ * T0;
                      } 
		      else {
                         T0 = log(-pParam->B3SOIPDnpeak * pParam->B3SOIPDnsub / ni / ni);
		         vfbb = -model->B3SOIPDtype * Vtm * T0;
                         dvfbb_dT = -model->B3SOIPDtype *
                                   (KboQ * T0 - Vtm * 2.0 * dni_dT / ni);
                      }

/*		      phi = 2.0 * Vtm * log(pParam->B3SOIPDnpeak / ni);  */
		      phi = here->B3SOIPDphi;
		      sqrtPhi = sqrt(phi);
		      Xdep0 = sqrt(2.0 * EPSSI / (Charge_q
				         * pParam->B3SOIPDnpeak * 1.0e6))
				         * sqrtPhi;
		      /*  Save the values below for phi calculation in B3SOIPDaccept()  */
		      here->B3SOIPDvtm = Vtm;
		      here->B3SOIPDni = ni;

                      T3 = TempRatio - 1.0;
                      T8 = 1/ model->B3SOIPDtnom;
                      T4 = Eg300 / Vtm * T3;
                      dT4_dT = Eg300 / Vtm / Vtm * (Vtm * T8 - T3 * KboQ);

                      T7 = model->B3SOIPDxbjt * T4 / pParam->B3SOIPDndiode;
                      dT7_dT = model->B3SOIPDxbjt * dT4_dT / pParam->B3SOIPDndiode;
                      DEXP(T7, T0, dT0_dT7);
                      dT0_dT = dT0_dT7 * dT7_dT;
 
                      if (model->B3SOIPDxbjt == model->B3SOIPDxdif) {
                         T1 = T0;
                         dT1_dT = dT0_dT;
                      } 
                      else {
                         T7 = model->B3SOIPDxdif * T4 / pParam->B3SOIPDndiode;
                         dT7_dT = model->B3SOIPDxdif * dT4_dT / pParam->B3SOIPDndiode;
                         DEXP(T7, T1, dT1_dT7);
                         dT1_dT = dT1_dT7 * dT7_dT;
                      }

                      T7 = model->B3SOIPDxrec * T4 / pParam->B3SOIPDnrecf0;
                      dT7_dT = model->B3SOIPDxrec * dT4_dT / pParam->B3SOIPDnrecf0;
                      DEXP(T7, T2, dT2_dT7);
                      dT2_dT = dT2_dT7 * dT7_dT;
 
                      /* high level injection */
                      Ahli = pParam->B3SOIPDahli * T0;
                      dAhli_dT = pParam->B3SOIPDahli * dT0_dT;
 
                      jbjt = pParam->B3SOIPDisbjt * T0;
                      jdif = pParam->B3SOIPDisdif * T1;
                      jrec = pParam->B3SOIPDisrec * T2;
                      djbjt_dT = pParam->B3SOIPDisbjt * dT0_dT;
                      djdif_dT = pParam->B3SOIPDisdif * dT1_dT;
                      djrec_dT = pParam->B3SOIPDisrec * dT2_dT;
 
                      T7 = model->B3SOIPDxtun * T3;
                      dT7_dT = model->B3SOIPDxtun * T8;
                      DEXP(T7, T0, dT0_dT7);
                      dT0_dT = dT0_dT7 * dT7_dT;
                      jtun = pParam->B3SOIPDistun * T0;
                      djtun_dT = pParam->B3SOIPDistun * dT0_dT;

		      u0temp = pParam->B3SOIPDu0 * pow(TempRatio, pParam->B3SOIPDute);
                      du0temp_dT = pParam->B3SOIPDu0 * pParam->B3SOIPDute *
                                   pow(TempRatio, pParam->B3SOIPDute - 1.0) * T8;

		      vsattemp = pParam->B3SOIPDvsat - pParam->B3SOIPDat * T3;
                      dvsattemp_dT = -pParam->B3SOIPDat * T8;

		      rds0 = (pParam->B3SOIPDrdsw + pParam->B3SOIPDprt
		          * T3) / pParam->B3SOIPDrds0denom;
                      drds0_dT = pParam->B3SOIPDprt / pParam->B3SOIPDrds0denom * T8;

		      ua = pParam->B3SOIPDuatemp + pParam->B3SOIPDua1 * T3;
		      ub = pParam->B3SOIPDubtemp + pParam->B3SOIPDub1 * T3;