b3soitemp.c

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

		  }


                  pParam->B3SOIcgdo = (model->B3SOIcgdo + pParam->B3SOIcf)
				    * pParam->B3SOIwdiodCV;
                  pParam->B3SOIcgso = (model->B3SOIcgso + pParam->B3SOIcf)
				    * pParam->B3SOIwdiosCV;

                  pParam->B3SOIcgeo = model->B3SOIcgeo
                                    * pParam->B3SOIleffCV;


                  if (!model->B3SOInpeakGiven && model->B3SOIgamma1Given)
                  {   T0 = pParam->B3SOIgamma1 * model->B3SOIcox;
                      pParam->B3SOInpeak = 3.021E22 * T0 * T0;
                  }


                  T4 = Eg300 / model->B3SOIvtm * (TempRatio - 1.0);
                  T7 = model->B3SOIxbjt * T4 / pParam->B3SOIndiode;
                  DEXP(T7, T0);
                  T7 = model->B3SOIxdif * T4 / pParam->B3SOIndiode;
                  DEXP(T7, T1);
                  T7 = model->B3SOIxrec * T4 / pParam->B3SOInrecf0;
                  DEXP(T7, T2);

                  /* v2.2.2 bug fix */
                  pParam->B3SOIahli0 = pParam->B3SOIahli * T0;
 
                  pParam->B3SOIjbjt = pParam->B3SOIisbjt * T0;
                  pParam->B3SOIjdif = pParam->B3SOIisdif * T1;
                  pParam->B3SOIjrec = pParam->B3SOIisrec * T2;

                  T7 = model->B3SOIxtun * (TempRatio - 1);
                  DEXP(T7, T0);
                  pParam->B3SOIjtun = pParam->B3SOIistun * T0;
 

                  if (pParam->B3SOInsub > 0)
                     pParam->B3SOIvfbb = -model->B3SOItype * model->B3SOIvtm *
                                log(pParam->B3SOInpeak/ pParam->B3SOInsub);
                  else
                     pParam->B3SOIvfbb = -model->B3SOItype * model->B3SOIvtm *
                                log(-pParam->B3SOInpeak* pParam->B3SOInsub/ni/ni);

                  if (!model->B3SOIvsdfbGiven)
                  {
                     if (pParam->B3SOInsub > 0)
                        pParam->B3SOIvsdfb = -model->B3SOItype * (model->B3SOIvtm*log(1e20 *
                                            pParam->B3SOInsub / ni /ni) - 0.3);
                     else if (pParam->B3SOInsub < 0)
                        pParam->B3SOIvsdfb = -model->B3SOItype * (model->B3SOIvtm*log(-1e20 /
                                            pParam->B3SOInsub) + 0.3);
                  }
                 
                  /* Phi  & Gamma */
                  SDphi = 2.0*model->B3SOIvtm*log(fabs(pParam->B3SOInsub) / ni);
                  SDgamma = 5.753e-12 * sqrt(fabs(pParam->B3SOInsub)) / model->B3SOIcbox;

                  if (!model->B3SOIvsdthGiven)
                  {
                     if ( ((pParam->B3SOInsub > 0) && (model->B3SOItype > 0)) ||
                          ((pParam->B3SOInsub < 0) && (model->B3SOItype < 0)) )
                        pParam->B3SOIvsdth = pParam->B3SOIvsdfb + SDphi +
                                            SDgamma * sqrt(SDphi);
                     else
                        pParam->B3SOIvsdth = pParam->B3SOIvsdfb - SDphi -
                                            SDgamma * sqrt(SDphi);
                  }

                  if (!model->B3SOIcsdminGiven) {
                     /* Cdmin */
                     tmp = sqrt(2.0 * EPSSI * SDphi / (Charge_q * 
                                fabs(pParam->B3SOInsub) * 1.0e6));
                     tmp1 = EPSSI / tmp;
                     model->B3SOIcsdmin = tmp1 * model->B3SOIcbox /
                                          (tmp1 + model->B3SOIcbox);
                  } 


		  pParam->B3SOIphi = 2.0 * model->B3SOIvtm 
			           * log(pParam->B3SOInpeak / ni);

	          pParam->B3SOIsqrtPhi = sqrt(pParam->B3SOIphi);
	          pParam->B3SOIphis3 = pParam->B3SOIsqrtPhi * pParam->B3SOIphi;

                  pParam->B3SOIXdep0 = sqrt(2.0 * EPSSI / (Charge_q
				     * pParam->B3SOInpeak * 1.0e6))
                                     * pParam->B3SOIsqrtPhi; 
                  pParam->B3SOIsqrtXdep0 = sqrt(pParam->B3SOIXdep0);
                  pParam->B3SOIlitl = sqrt(3.0 * model->B3SOIxj
				    * model->B3SOItox);
                  pParam->B3SOIvbi = model->B3SOIvtm * log(1.0e20
			           * pParam->B3SOInpeak / (ni * ni));
                  pParam->B3SOIcdep0 = sqrt(Charge_q * EPSSI
				     * pParam->B3SOInpeak * 1.0e6 / 2.0
				     / pParam->B3SOIphi);

/* v3.0 */
                  if (pParam->B3SOIngate > 0.0)
                  {   pParam->B3SOIvfbsd = Vtm0 * log(pParam->B3SOIngate
                                         / 1.0e20);
                  }
                  else
                      pParam->B3SOIvfbsd = 0.0;

                  pParam->B3SOIToxRatio = exp(model->B3SOIntox
                                        * log(model->B3SOItoxref /model->B3SOItoxqm))
                                        /model->B3SOItoxqm /model->B3SOItoxqm;
                  pParam->B3SOIToxRatioEdge = exp(model->B3SOIntox
                                            * log(model->B3SOItoxref
                                            / (model->B3SOItoxqm * pParam->B3SOIpoxedge)))
                                            / model->B3SOItoxqm / model->B3SOItoxqm
                                            / pParam->B3SOIpoxedge / pParam->B3SOIpoxedge;
                  pParam->B3SOIAechvb = (model->B3SOItype == NMOS) ? 4.97232e-7 : 3.42537e-7;
                  pParam->B3SOIBechvb = (model->B3SOItype == NMOS) ? 7.45669e11 : 1.16645e12;
                  pParam->B3SOIAechvbEdge = pParam->B3SOIAechvb * pParam->B3SOIweff
                                          * pParam->B3SOIdlcig * pParam->B3SOIToxRatioEdge;
                  pParam->B3SOIBechvbEdge = -pParam->B3SOIBechvb
                                          * model->B3SOItoxqm * pParam->B3SOIpoxedge;
                  pParam->B3SOIAechvb *= pParam->B3SOIweff * pParam->B3SOIleff
                                       * pParam->B3SOIToxRatio;
                  pParam->B3SOIBechvb *= -model->B3SOItoxqm;
/* v3.0 */

        
                  if (model->B3SOIk1Given || model->B3SOIk2Given)
	          {   if (!model->B3SOIk1Given)
	              {   fprintf(stdout, "Warning: k1 should be specified with k2.\n");
                          pParam->B3SOIk1 = 0.53;
                      }
                      if (!model->B3SOIk2Given)
	              {   fprintf(stdout, "Warning: k2 should be specified with k1.\n");
                          pParam->B3SOIk2 = -0.0186;
                      }
                      if (model->B3SOIxtGiven)
                          fprintf(stdout, "Warning: xt is ignored because k1 or k2 is given.\n");
                      if (model->B3SOIvbxGiven)
                          fprintf(stdout, "Warning: vbx is ignored because k1 or k2 is given.\n");
                      if (model->B3SOIvbmGiven)
                          fprintf(stdout, "Warning: vbm is ignored because k1 or k2 is given.\n");
                      if (model->B3SOIgamma1Given)
                          fprintf(stdout, "Warning: gamma1 is ignored because k1 or k2 is given.\n");
                      if (model->B3SOIgamma2Given)
                          fprintf(stdout, "Warning: gamma2 is ignored because k1 or k2 is given.\n");
                  }
                  else
	          {   if (!model->B3SOIvbxGiven)
                          pParam->B3SOIvbx = pParam->B3SOIphi - 7.7348e-4 
                                           * pParam->B3SOInpeak
					   * pParam->B3SOIxt * pParam->B3SOIxt;
	              if (pParam->B3SOIvbx > 0.0)
		          pParam->B3SOIvbx = -pParam->B3SOIvbx;
	              if (pParam->B3SOIvbm > 0.0)
                          pParam->B3SOIvbm = -pParam->B3SOIvbm;
           
                      if (!model->B3SOIgamma1Given)
                          pParam->B3SOIgamma1 = 5.753e-12
					      * sqrt(pParam->B3SOInpeak)
                                              / model->B3SOIcox;
                      if (!model->B3SOIgamma2Given)
                          pParam->B3SOIgamma2 = 5.753e-12
					      * sqrt(pParam->B3SOInsub)
                                              / model->B3SOIcox;

                      T0 = pParam->B3SOIgamma1 - pParam->B3SOIgamma2;
                      T1 = sqrt(pParam->B3SOIphi - pParam->B3SOIvbx)
			 - pParam->B3SOIsqrtPhi;
                      T2 = sqrt(pParam->B3SOIphi * (pParam->B3SOIphi
			 - pParam->B3SOIvbm)) - pParam->B3SOIphi;
                      pParam->B3SOIk2 = T0 * T1 / (2.0 * T2 + pParam->B3SOIvbm);
                      pParam->B3SOIk1 = pParam->B3SOIgamma2 - 2.0
				      * pParam->B3SOIk2 * sqrt(pParam->B3SOIphi
				      - pParam->B3SOIvbm);
                  }
 
		  if (pParam->B3SOIk2 < 0.0)
		  {   T0 = 0.5 * pParam->B3SOIk1 / pParam->B3SOIk2;
                      pParam->B3SOIvbsc = 0.9 * (pParam->B3SOIphi - T0 * T0);
		      if (pParam->B3SOIvbsc > -3.0)
		          pParam->B3SOIvbsc = -3.0;
		      else if (pParam->B3SOIvbsc < -30.0)
		          pParam->B3SOIvbsc = -30.0;
		  }
		  else
		  {   pParam->B3SOIvbsc = -30.0;
		  }
		  if (pParam->B3SOIvbsc > pParam->B3SOIvbm)
		      pParam->B3SOIvbsc = pParam->B3SOIvbm;

                  if ((T0 = pParam->B3SOIweff + pParam->B3SOIk1w2) < 1e-8)
                     T0 = 1e-8;
                  pParam->B3SOIk1eff = pParam->B3SOIk1 * (1 + pParam->B3SOIk1w1/T0);

	          if (model->B3SOIvth0Given)
		  {   pParam->B3SOIvfb = model->B3SOItype * pParam->B3SOIvth0 
                                       - pParam->B3SOIphi - pParam->B3SOIk1eff 
                                       * pParam->B3SOIsqrtPhi;
		  }
		  else
		  {   pParam->B3SOIvfb = -1.0;
		      pParam->B3SOIvth0 = model->B3SOItype * (pParam->B3SOIvfb
                                        + pParam->B3SOIphi + pParam->B3SOIk1eff 
                                        * pParam->B3SOIsqrtPhi);
		  }
                  T1 = sqrt(EPSSI / EPSOX * model->B3SOItox
		     * pParam->B3SOIXdep0);
                  T0 = exp(-0.5 * pParam->B3SOIdsub * pParam->B3SOIleff / T1);
                  pParam->B3SOItheta0vb0 = (T0 + 2.0 * T0 * T0);

                  T0 = exp(-0.5 * pParam->B3SOIdrout * pParam->B3SOIleff / T1);
                  T2 = (T0 + 2.0 * T0 * T0);
                  pParam->B3SOIthetaRout = pParam->B3SOIpdibl1 * T2
				         + pParam->B3SOIpdibl2;
	      }

              here->B3SOIcsbox = model->B3SOIcbox*here->B3SOIsourceArea;
              here->B3SOIcsmin = model->B3SOIcsdmin*here->B3SOIsourceArea;
              here->B3SOIcdbox = model->B3SOIcbox*here->B3SOIdrainArea;
              here->B3SOIcdmin = model->B3SOIcsdmin*here->B3SOIdrainArea;

	      if ( ((pParam->B3SOInsub > 0) && (model->B3SOItype > 0)) ||
	           ((pParam->B3SOInsub < 0) && (model->B3SOItype < 0)) )
	      {
                 T0 = pParam->B3SOIvsdth - pParam->B3SOIvsdfb;
                 pParam->B3SOIsdt1 = pParam->B3SOIvsdfb + model->B3SOIasd * T0;
                 T1 = here->B3SOIcsbox - here->B3SOIcsmin;
                 T2 = T1 / T0 / T0;
                 pParam->B3SOIst2 = T2 / model->B3SOIasd;
                 pParam->B3SOIst3 = T2 /( 1 - model->B3SOIasd);
                 here->B3SOIst4 =  T0 * T1 * (1 + model->B3SOIasd) / 3
                                  - here->B3SOIcsmin * pParam->B3SOIvsdfb;

                 T1 = here->B3SOIcdbox - here->B3SOIcdmin;
                 T2 = T1 / T0 / T0;
                 pParam->B3SOIdt2 = T2 / model->B3SOIasd;
                 pParam->B3SOIdt3 = T2 /( 1 - model->B3SOIasd);
                 here->B3SOIdt4 =  T0 * T1 * (1 + model->B3SOIasd) / 3
                                  - here->B3SOIcdmin * pParam->B3SOIvsdfb;
	      } else
	      {
                 T0 = pParam->B3SOIvsdfb - pParam->B3SOIvsdth;
                 pParam->B3SOIsdt1 = pParam->B3SOIvsdth + model->B3SOIasd * T0;
                 T1 = here->B3SOIcsmin - here->B3SOIcsbox;
                 T2 = T1 / T0 / T0;
                 pParam->B3SOIst2 = T2 / model->B3SOIasd;
                 pParam->B3SOIst3 = T2 /( 1 - model->B3SOIasd);
                 here->B3SOIst4 =  T0 * T1 * (1 + model->B3SOIasd) / 3
                                  - here->B3SOIcsbox * pParam->B3SOIvsdth;
 
                 T1 = here->B3SOIcdmin - here->B3SOIcdbox;
                 T2 = T1 / T0 / T0;
                 pParam->B3SOIdt2 = T2 / model->B3SOIasd;
                 pParam->B3SOIdt3 = T2 /( 1 - model->B3SOIasd);
                 here->B3SOIdt4 =  T0 * T1 * (1 + model->B3SOIasd) / 3
                                      - here->B3SOIcdbox * pParam->B3SOIvsdth;
	      } 

              /* v2.2.2 bug fix */
              T0 = model->B3SOIcsdesw * log(1 + model->B3SOItsi /
                 model->B3SOItbox);
              T1 = here->B3SOIsourcePerimeter - here->B3SOIw;
              if (T1 > 0.0)
                 here->B3SOIcsesw = T0 * T1; 
              else
                 here->B3SOIcsesw = 0.0;
              T1 = here->B3SOIdrainPerimeter - here->B3SOIw;
              if (T1 > 0.0)
                 here->B3SOIcdesw = T0 * T1;
              else
                 here->B3SOIcdesw = 0.0;


	      here->B3SOIphi = pParam->B3SOIphi;
              /* process source/drain series resistance */
              here->B3SOIdrainConductance = model->B3SOIsheetResistance 
		                              * here->B3SOIdrainSquares;
              if (here->B3SOIdrainConductance > 0.0)
                  here->B3SOIdrainConductance = 1.0
					      / here->B3SOIdrainConductance;
	      else
                  here->B3SOIdrainConductance = 0.0;
                  
              here->B3SOIsourceConductance = model->B3SOIsheetResistance 
		                           * here->B3SOIsourceSquares;
              if (here->B3SOIsourceConductance > 0.0) 
                  here->B3SOIsourceConductance = 1.0
					       / here->B3SOIsourceConductance;
	      else
                  here->B3SOIsourceConductance = 0.0;
	      here->B3SOIcgso = pParam->B3SOIcgso;
	      here->B3SOIcgdo = pParam->B3SOIcgdo;


/* v2.0 release */
              if (model->B3SOIln < 1e-15) model->B3SOIln = 1e-15;
              T0 = -0.5 * pParam->B3SOIleff * pParam->B3SOIleff / model->B3SOIln / model->B3SOIln;
              DEXP(T0,T1);
              pParam->B3SOIarfabjt = T1;

              T0 = pParam->B3SOIlbjt0 * (1.0 / pParam->B3SOIleff + 1.0 / model->B3SOIln);
              pParam->B3SOIlratio = pow(T0,pParam->B3SOInbjt);
              pParam->B3SOIlratiodif = 1.0 + model->B3SOIldif0 * pow(T0,model->B3SOIndif);

              if ((pParam->B3SOIvearly = pParam->B3SOIvabjt + pParam->B3SOIaely * pParam->B3SOIleff) < 1) 
                 pParam->B3SOIvearly = 1; 

              /* vfbzb calculation for capMod 3 */
              tmp = sqrt(pParam->B3SOIXdep0);
              tmp1 = pParam->B3SOIvbi - pParam->B3SOIphi;
              tmp2 = model->B3SOIfactor1 * tmp;

              T0 = -0.5 * pParam->B3SOIdvt1w * pParam->B3SOIweff
                 * pParam->B3SOIleff / tmp2;
              if (T0 > -EXPL_THRESHOLD)
              {   T1 = exp(T0);
                  T2 = T1 * (1.0 + 2.0 * T1);
              }
              else
              {   T1 = MIN_EXPL;
                  T2 = T1 * (1.0 + 2.0 * T1);
              }
              T0 = pParam->B3SOIdvt0w * T2;
              T2 = T0 * tmp1;

              T0 = -0.5 * pParam->B3SOIdvt1 * pParam->B3SOIleff / tmp2;
              if (T0 > -EXPL_THRESHOLD)
              {   T1 = exp(T0);
                  T3 = T1 * (1.0 + 2.0 * T1);
              }
              else
              {   T1 = MIN_EXPL;
                  T3 = T1 * (1.0 + 2.0 * T1);
              }
              T3 = pParam->B3SOIdvt0 * T3 * tmp1;

/* v2.2.3 */
              T4 = (model->B3SOItox - model->B3SOIdtoxcv) * pParam->B3SOIphi
                 / (pParam->B3SOIweff + pParam->B3SOIw0);

              T0 = sqrt(1.0 + pParam->B3SOInlx / pParam->B3SOIleff);
              T5 = pParam->B3SOIk1eff * (T0 - 1.0) * pParam->B3SOIsqrtPhi
                 + (pParam->B3SOIkt1 + pParam->B3SOIkt1l / pParam->B3SOIleff)
                 * (TempRatio - 1.0);

              tmp3 = model->B3SOItype * pParam->B3SOIvth0
                   - T2 - T3 + pParam->B3SOIk3 * T4 + T5;
              pParam->B3SOIvfbzb = tmp3 - pParam->B3SOIphi - pParam->B3SOIk1eff
                                 * pParam->B3SOIsqrtPhi;
              /* End of vfbzb */

              pParam->B3SOIldeb = sqrt(EPSSI * Vtm0 / (Charge_q * pParam->B3SOInpeak * 1.0e6)) / 3.0;
              pParam->B3SOIacde = pParam->B3SOIacde * pow((pParam->B3SOInpeak / 2.0e16), -0.25);
         }
    }
    return(OK);
}