b3soipdtemp.c

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

                      namarray[0] = model->B3SOIPDmodName;
                      namarray[1] = here->B3SOIPDname;
                      (*(SPfrontEnd->IFerror)) (ERR_FATAL, "Fatal error(s) detected during B3SOIPDV3 parameter checking for %s in model %s", namarray);
                      return(E_BADPARM);   
		  }


                  pParam->B3SOIPDcgdo = (model->B3SOIPDcgdo + pParam->B3SOIPDcf)
				    * pParam->B3SOIPDwdiodCV;
                  pParam->B3SOIPDcgso = (model->B3SOIPDcgso + pParam->B3SOIPDcf)
				    * pParam->B3SOIPDwdiosCV;

                  pParam->B3SOIPDcgeo = model->B3SOIPDcgeo
                                    * pParam->B3SOIPDleffCV;


                  if (!model->B3SOIPDnpeakGiven && model->B3SOIPDgamma1Given)
                  {   T0 = pParam->B3SOIPDgamma1 * model->B3SOIPDcox;
                      pParam->B3SOIPDnpeak = 3.021E22 * T0 * T0;
                  }


                  T4 = Eg300 / model->B3SOIPDvtm * (TempRatio - 1.0);
                  T7 = model->B3SOIPDxbjt * T4 / pParam->B3SOIPDndiode;
                  DEXP(T7, T0);
                  T7 = model->B3SOIPDxdif * T4 / pParam->B3SOIPDndiode;
                  DEXP(T7, T1);
                  T7 = model->B3SOIPDxrec * T4 / pParam->B3SOIPDnrecf0;
                  DEXP(T7, T2);

                  /* v2.2.2 bug fix */
                  pParam->B3SOIPDahli0 = pParam->B3SOIPDahli * T0;
 
                  pParam->B3SOIPDjbjt = pParam->B3SOIPDisbjt * T0;
                  pParam->B3SOIPDjdif = pParam->B3SOIPDisdif * T1;
                  pParam->B3SOIPDjrec = pParam->B3SOIPDisrec * T2;

                  T7 = model->B3SOIPDxtun * (TempRatio - 1);
                  DEXP(T7, T0);
                  pParam->B3SOIPDjtun = pParam->B3SOIPDistun * T0;
 

                  if (pParam->B3SOIPDnsub > 0)
                     pParam->B3SOIPDvfbb = -model->B3SOIPDtype * model->B3SOIPDvtm *
                                log(pParam->B3SOIPDnpeak/ pParam->B3SOIPDnsub);
                  else
                     pParam->B3SOIPDvfbb = -model->B3SOIPDtype * model->B3SOIPDvtm *
                                log(-pParam->B3SOIPDnpeak* pParam->B3SOIPDnsub/ni/ni);

                  if (!model->B3SOIPDvsdfbGiven)
                  {
                     if (pParam->B3SOIPDnsub > 0)
                        pParam->B3SOIPDvsdfb = -model->B3SOIPDtype * (model->B3SOIPDvtm*log(1e20 *
                                            pParam->B3SOIPDnsub / ni /ni) - 0.3);
                     else if (pParam->B3SOIPDnsub < 0)
                        pParam->B3SOIPDvsdfb = -model->B3SOIPDtype * (model->B3SOIPDvtm*log(-1e20 /
                                            pParam->B3SOIPDnsub) + 0.3);
                  }
                 
                  /* Phi  & Gamma */
                  SDphi = 2.0*model->B3SOIPDvtm*log(fabs(pParam->B3SOIPDnsub) / ni);
                  SDgamma = 5.753e-12 * sqrt(fabs(pParam->B3SOIPDnsub)) / model->B3SOIPDcbox;

                  if (!model->B3SOIPDvsdthGiven)
                  {
                     if ( ((pParam->B3SOIPDnsub > 0) && (model->B3SOIPDtype > 0)) ||
                          ((pParam->B3SOIPDnsub < 0) && (model->B3SOIPDtype < 0)) )
                        pParam->B3SOIPDvsdth = pParam->B3SOIPDvsdfb + SDphi +
                                            SDgamma * sqrt(SDphi);
                     else
                        pParam->B3SOIPDvsdth = pParam->B3SOIPDvsdfb - SDphi -
                                            SDgamma * sqrt(SDphi);
                  }

                  if (!model->B3SOIPDcsdminGiven) {
                     /* Cdmin */
                     tmp = sqrt(2.0 * EPSSI * SDphi / (Charge_q * 
                                fabs(pParam->B3SOIPDnsub) * 1.0e6));
                     tmp1 = EPSSI / tmp;
                     model->B3SOIPDcsdmin = tmp1 * model->B3SOIPDcbox /
                                          (tmp1 + model->B3SOIPDcbox);
                  } 


		  pParam->B3SOIPDphi = 2.0 * model->B3SOIPDvtm 
			           * log(pParam->B3SOIPDnpeak / ni);

	          pParam->B3SOIPDsqrtPhi = sqrt(pParam->B3SOIPDphi);
	          pParam->B3SOIPDphis3 = pParam->B3SOIPDsqrtPhi * pParam->B3SOIPDphi;

                  pParam->B3SOIPDXdep0 = sqrt(2.0 * EPSSI / (Charge_q
				     * pParam->B3SOIPDnpeak * 1.0e6))
                                     * pParam->B3SOIPDsqrtPhi; 
                  pParam->B3SOIPDsqrtXdep0 = sqrt(pParam->B3SOIPDXdep0);
                  pParam->B3SOIPDlitl = sqrt(3.0 * model->B3SOIPDxj
				    * model->B3SOIPDtox);
                  pParam->B3SOIPDvbi = model->B3SOIPDvtm * log(1.0e20
			           * pParam->B3SOIPDnpeak / (ni * ni));
                  pParam->B3SOIPDcdep0 = sqrt(Charge_q * EPSSI
				     * pParam->B3SOIPDnpeak * 1.0e6 / 2.0
				     / pParam->B3SOIPDphi);
        
                  if (model->B3SOIPDk1Given || model->B3SOIPDk2Given)
	          {   if (!model->B3SOIPDk1Given)
	              {   fprintf(stdout, "Warning: k1 should be specified with k2.\n");
                          pParam->B3SOIPDk1 = 0.53;
                      }
                      if (!model->B3SOIPDk2Given)
	              {   fprintf(stdout, "Warning: k2 should be specified with k1.\n");
                          pParam->B3SOIPDk2 = -0.0186;
                      }
                      if (model->B3SOIPDxtGiven)
                          fprintf(stdout, "Warning: xt is ignored because k1 or k2 is given.\n");
                      if (model->B3SOIPDvbxGiven)
                          fprintf(stdout, "Warning: vbx is ignored because k1 or k2 is given.\n");
                      if (model->B3SOIPDvbmGiven)
                          fprintf(stdout, "Warning: vbm is ignored because k1 or k2 is given.\n");
                      if (model->B3SOIPDgamma1Given)
                          fprintf(stdout, "Warning: gamma1 is ignored because k1 or k2 is given.\n");
                      if (model->B3SOIPDgamma2Given)
                          fprintf(stdout, "Warning: gamma2 is ignored because k1 or k2 is given.\n");
                  }
                  else
	          {   if (!model->B3SOIPDvbxGiven)
                          pParam->B3SOIPDvbx = pParam->B3SOIPDphi - 7.7348e-4 
                                           * pParam->B3SOIPDnpeak
					   * pParam->B3SOIPDxt * pParam->B3SOIPDxt;
	              if (pParam->B3SOIPDvbx > 0.0)
		          pParam->B3SOIPDvbx = -pParam->B3SOIPDvbx;
	              if (pParam->B3SOIPDvbm > 0.0)
                          pParam->B3SOIPDvbm = -pParam->B3SOIPDvbm;
           
                      if (!model->B3SOIPDgamma1Given)
                          pParam->B3SOIPDgamma1 = 5.753e-12
					      * sqrt(pParam->B3SOIPDnpeak)
                                              / model->B3SOIPDcox;
                      if (!model->B3SOIPDgamma2Given)
                          pParam->B3SOIPDgamma2 = 5.753e-12
					      * sqrt(pParam->B3SOIPDnsub)
                                              / model->B3SOIPDcox;

                      T0 = pParam->B3SOIPDgamma1 - pParam->B3SOIPDgamma2;
                      T1 = sqrt(pParam->B3SOIPDphi - pParam->B3SOIPDvbx)
			 - pParam->B3SOIPDsqrtPhi;
                      T2 = sqrt(pParam->B3SOIPDphi * (pParam->B3SOIPDphi
			 - pParam->B3SOIPDvbm)) - pParam->B3SOIPDphi;
                      pParam->B3SOIPDk2 = T0 * T1 / (2.0 * T2 + pParam->B3SOIPDvbm);
                      pParam->B3SOIPDk1 = pParam->B3SOIPDgamma2 - 2.0
				      * pParam->B3SOIPDk2 * sqrt(pParam->B3SOIPDphi
				      - pParam->B3SOIPDvbm);
                  }
 
		  if (pParam->B3SOIPDk2 < 0.0)
		  {   T0 = 0.5 * pParam->B3SOIPDk1 / pParam->B3SOIPDk2;
                      pParam->B3SOIPDvbsc = 0.9 * (pParam->B3SOIPDphi - T0 * T0);
		      if (pParam->B3SOIPDvbsc > -3.0)
		          pParam->B3SOIPDvbsc = -3.0;
		      else if (pParam->B3SOIPDvbsc < -30.0)
		          pParam->B3SOIPDvbsc = -30.0;
		  }
		  else
		  {   pParam->B3SOIPDvbsc = -30.0;
		  }
		  if (pParam->B3SOIPDvbsc > pParam->B3SOIPDvbm)
		      pParam->B3SOIPDvbsc = pParam->B3SOIPDvbm;

                  if ((T0 = pParam->B3SOIPDweff + pParam->B3SOIPDk1w2) < 1e-8)
                     T0 = 1e-8;
                  pParam->B3SOIPDk1eff = pParam->B3SOIPDk1 * (1 + pParam->B3SOIPDk1w1/T0);

	          if (model->B3SOIPDvth0Given)
		  {   pParam->B3SOIPDvfb = model->B3SOIPDtype * pParam->B3SOIPDvth0 
                                       - pParam->B3SOIPDphi - pParam->B3SOIPDk1eff 
                                       * pParam->B3SOIPDsqrtPhi;
		  }
		  else
		  {   pParam->B3SOIPDvfb = -1.0;
		      pParam->B3SOIPDvth0 = model->B3SOIPDtype * (pParam->B3SOIPDvfb
                                        + pParam->B3SOIPDphi + pParam->B3SOIPDk1eff 
                                        * pParam->B3SOIPDsqrtPhi);
		  }
                  T1 = sqrt(EPSSI / EPSOX * model->B3SOIPDtox
		     * pParam->B3SOIPDXdep0);
                  T0 = exp(-0.5 * pParam->B3SOIPDdsub * pParam->B3SOIPDleff / T1);
                  pParam->B3SOIPDtheta0vb0 = (T0 + 2.0 * T0 * T0);

                  T0 = exp(-0.5 * pParam->B3SOIPDdrout * pParam->B3SOIPDleff / T1);
                  T2 = (T0 + 2.0 * T0 * T0);
                  pParam->B3SOIPDthetaRout = pParam->B3SOIPDpdibl1 * T2
				         + pParam->B3SOIPDpdibl2;
	      }

              here->B3SOIPDcsbox = model->B3SOIPDcbox*here->B3SOIPDsourceArea;
              here->B3SOIPDcsmin = model->B3SOIPDcsdmin*here->B3SOIPDsourceArea;
              here->B3SOIPDcdbox = model->B3SOIPDcbox*here->B3SOIPDdrainArea;
              here->B3SOIPDcdmin = model->B3SOIPDcsdmin*here->B3SOIPDdrainArea;

	      if ( ((pParam->B3SOIPDnsub > 0) && (model->B3SOIPDtype > 0)) ||
	           ((pParam->B3SOIPDnsub < 0) && (model->B3SOIPDtype < 0)) )
	      {
                 T0 = pParam->B3SOIPDvsdth - pParam->B3SOIPDvsdfb;
                 pParam->B3SOIPDsdt1 = pParam->B3SOIPDvsdfb + model->B3SOIPDasd * T0;
                 T1 = here->B3SOIPDcsbox - here->B3SOIPDcsmin;
                 T2 = T1 / T0 / T0;
                 pParam->B3SOIPDst2 = T2 / model->B3SOIPDasd;
                 pParam->B3SOIPDst3 = T2 /( 1 - model->B3SOIPDasd);
                 here->B3SOIPDst4 =  T0 * T1 * (1 + model->B3SOIPDasd) / 3
                                  - here->B3SOIPDcsmin * pParam->B3SOIPDvsdfb;

                 T1 = here->B3SOIPDcdbox - here->B3SOIPDcdmin;
                 T2 = T1 / T0 / T0;
                 pParam->B3SOIPDdt2 = T2 / model->B3SOIPDasd;
                 pParam->B3SOIPDdt3 = T2 /( 1 - model->B3SOIPDasd);
                 here->B3SOIPDdt4 =  T0 * T1 * (1 + model->B3SOIPDasd) / 3
                                  - here->B3SOIPDcdmin * pParam->B3SOIPDvsdfb;
	      } else
	      {
                 T0 = pParam->B3SOIPDvsdfb - pParam->B3SOIPDvsdth;
                 pParam->B3SOIPDsdt1 = pParam->B3SOIPDvsdth + model->B3SOIPDasd * T0;
                 T1 = here->B3SOIPDcsmin - here->B3SOIPDcsbox;
                 T2 = T1 / T0 / T0;
                 pParam->B3SOIPDst2 = T2 / model->B3SOIPDasd;
                 pParam->B3SOIPDst3 = T2 /( 1 - model->B3SOIPDasd);
                 here->B3SOIPDst4 =  T0 * T1 * (1 + model->B3SOIPDasd) / 3
                                  - here->B3SOIPDcsbox * pParam->B3SOIPDvsdth;
 
                 T1 = here->B3SOIPDcdmin - here->B3SOIPDcdbox;
                 T2 = T1 / T0 / T0;
                 pParam->B3SOIPDdt2 = T2 / model->B3SOIPDasd;
                 pParam->B3SOIPDdt3 = T2 /( 1 - model->B3SOIPDasd);
                 here->B3SOIPDdt4 =  T0 * T1 * (1 + model->B3SOIPDasd) / 3
                                      - here->B3SOIPDcdbox * pParam->B3SOIPDvsdth;
	      } 

              /* v2.2.2 bug fix */
              T0 = model->B3SOIPDcsdesw * log(1 + model->B3SOIPDtsi /
                 model->B3SOIPDtbox);
              T1 = here->B3SOIPDsourcePerimeter - here->B3SOIPDw;
              if (T1 > 0.0)
                 here->B3SOIPDcsesw = T0 * T1; 
              else
                 here->B3SOIPDcsesw = 0.0;
              T1 = here->B3SOIPDdrainPerimeter - here->B3SOIPDw;
              if (T1 > 0.0)
                 here->B3SOIPDcdesw = T0 * T1;
              else
                 here->B3SOIPDcdesw = 0.0;


	      here->B3SOIPDphi = pParam->B3SOIPDphi;
              /* process source/drain series resistance */
              here->B3SOIPDdrainConductance = model->B3SOIPDsheetResistance 
		                              * here->B3SOIPDdrainSquares;
              if (here->B3SOIPDdrainConductance > 0.0)
                  here->B3SOIPDdrainConductance = 1.0
					      / here->B3SOIPDdrainConductance;
	      else
                  here->B3SOIPDdrainConductance = 0.0;
                  
              here->B3SOIPDsourceConductance = model->B3SOIPDsheetResistance 
		                           * here->B3SOIPDsourceSquares;
              if (here->B3SOIPDsourceConductance > 0.0) 
                  here->B3SOIPDsourceConductance = 1.0
					       / here->B3SOIPDsourceConductance;
	      else
                  here->B3SOIPDsourceConductance = 0.0;
	      here->B3SOIPDcgso = pParam->B3SOIPDcgso;
	      here->B3SOIPDcgdo = pParam->B3SOIPDcgdo;


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

              T0 = pParam->B3SOIPDlbjt0 * (1.0 / pParam->B3SOIPDleff + 1.0 / model->B3SOIPDln);
              pParam->B3SOIPDlratio = pow(T0,pParam->B3SOIPDnbjt);
              pParam->B3SOIPDlratiodif = 1.0 + model->B3SOIPDldif0 * pow(T0,model->B3SOIPDndif);

              if ((pParam->B3SOIPDvearly = pParam->B3SOIPDvabjt + pParam->B3SOIPDaely * pParam->B3SOIPDleff) < 1) 
                 pParam->B3SOIPDvearly = 1; 

              /* vfbzb calculation for capMod 3 */
              tmp = sqrt(pParam->B3SOIPDXdep0);
              tmp1 = pParam->B3SOIPDvbi - pParam->B3SOIPDphi;
              tmp2 = model->B3SOIPDfactor1 * tmp;

              T0 = -0.5 * pParam->B3SOIPDdvt1w * pParam->B3SOIPDweff
                 * pParam->B3SOIPDleff / 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->B3SOIPDdvt0w * T2;
              T2 = T0 * tmp1;

              T0 = -0.5 * pParam->B3SOIPDdvt1 * pParam->B3SOIPDleff / 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->B3SOIPDdvt0 * T3 * tmp1;

/* v2.2.3 */
              T4 = (model->B3SOIPDtox - model->B3SOIPDdtoxcv) * pParam->B3SOIPDphi
                 / (pParam->B3SOIPDweff + pParam->B3SOIPDw0);

              T0 = sqrt(1.0 + pParam->B3SOIPDnlx / pParam->B3SOIPDleff);
              T5 = pParam->B3SOIPDk1eff * (T0 - 1.0) * pParam->B3SOIPDsqrtPhi
                 + (pParam->B3SOIPDkt1 + pParam->B3SOIPDkt1l / pParam->B3SOIPDleff)
                 * (TempRatio - 1.0);

              tmp3 = model->B3SOIPDtype * pParam->B3SOIPDvth0
                   - T2 - T3 + pParam->B3SOIPDk3 * T4 + T5;
              pParam->B3SOIPDvfbzb = tmp3 - pParam->B3SOIPDphi - pParam->B3SOIPDk1eff
                                 * pParam->B3SOIPDsqrtPhi;
              /* End of vfbzb */

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