b3soiddtemp.c

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

                      pParam->B3SOIDDu0 = pParam->B3SOIDDu0 / 1.0e4;

                  pParam->B3SOIDDu0temp = pParam->B3SOIDDu0
				      * pow(TRatio, pParam->B3SOIDDute); 
                  pParam->B3SOIDDvsattemp = pParam->B3SOIDDvsat - pParam->B3SOIDDat 
			                * T0;
	          pParam->B3SOIDDrds0 = (pParam->B3SOIDDrdsw + pParam->B3SOIDDprt * T0)
                                    / pow(pParam->B3SOIDDweff * 1E6, pParam->B3SOIDDwr);

		  if (B3SOIDDcheckModel(model, here, ckt))
		  {   IFuid namarray[2];
                      namarray[0] = model->B3SOIDDmodName;
                      namarray[1] = here->B3SOIDDname;
                      (*(SPfrontEnd->IFerror)) (ERR_FATAL, "Fatal error(s) detected during B3SOIDDV3 parameter checking for %s in model %s", namarray);
                      return(E_BADPARM);   
		  }


                  pParam->B3SOIDDcgdo = (model->B3SOIDDcgdo + pParam->B3SOIDDcf)
				    * pParam->B3SOIDDweffCV;
                  pParam->B3SOIDDcgso = (model->B3SOIDDcgso + pParam->B3SOIDDcf)
				    * pParam->B3SOIDDweffCV;
                  pParam->B3SOIDDcgeo = model->B3SOIDDcgeo
                                    * pParam->B3SOIDDleffCV;


                  if (!model->B3SOIDDnpeakGiven && model->B3SOIDDgamma1Given)
                  {   T0 = pParam->B3SOIDDgamma1 * model->B3SOIDDcox;
                      pParam->B3SOIDDnpeak = 3.021E22 * T0 * T0;
                  }

                  T0 = pow(TRatio, model->B3SOIDDxbjt / pParam->B3SOIDDndiode);
                  T1 = pow(TRatio, model->B3SOIDDxdif / pParam->B3SOIDDndiode);
                  T2 = pow(TRatio, model->B3SOIDDxrec / pParam->B3SOIDDndiode / 2);
                  T4 = -Eg0 / pParam->B3SOIDDndiode / model->B3SOIDDvtm * (1 - TRatio);
                  T5 = exp(T4);
                  T6 = sqrt(T5);
                  pParam->B3SOIDDjbjt = pParam->B3SOIDDisbjt * T0 * T5;
                  pParam->B3SOIDDjdif = pParam->B3SOIDDisdif * T1 * T5;
                  pParam->B3SOIDDjrec = pParam->B3SOIDDisrec * T2 * T6;
                  T0 = pow(TRatio, model->B3SOIDDxtun / pParam->B3SOIDDntun);
                  pParam->B3SOIDDjtun = pParam->B3SOIDDistun * T0 ;

                  if (pParam->B3SOIDDnsub > 0)
                     pParam->B3SOIDDvfbb = -model->B3SOIDDtype * model->B3SOIDDvtm *
                                log(pParam->B3SOIDDnpeak/ pParam->B3SOIDDnsub);
                  else
                     pParam->B3SOIDDvfbb = -model->B3SOIDDtype * model->B3SOIDDvtm *
                                log(-pParam->B3SOIDDnpeak* pParam->B3SOIDDnsub/ni/ni);

                  if (!model->B3SOIDDvsdfbGiven)
                  {
                     if (pParam->B3SOIDDnsub > 0)
                        pParam->B3SOIDDvsdfb = -model->B3SOIDDtype * (model->B3SOIDDvtm*log(1e20 *
                                            pParam->B3SOIDDnsub / ni /ni) - 0.3);
                     else if (pParam->B3SOIDDnsub < 0)
                        pParam->B3SOIDDvsdfb = -model->B3SOIDDtype * (model->B3SOIDDvtm*log(-1e20 /
                                            pParam->B3SOIDDnsub) + 0.3);
                  }
                 
                  /* Phi  & Gamma */
                  SDphi = 2.0*model->B3SOIDDvtm*log(fabs(pParam->B3SOIDDnsub) / ni);
                  SDgamma = 5.753e-12 * sqrt(fabs(pParam->B3SOIDDnsub)) / model->B3SOIDDcbox;

                  if (!model->B3SOIDDvsdthGiven)
                  {
                     if ( ((pParam->B3SOIDDnsub > 0) && (model->B3SOIDDtype > 0)) ||
                          ((pParam->B3SOIDDnsub < 0) && (model->B3SOIDDtype < 0)) )
                        pParam->B3SOIDDvsdth = pParam->B3SOIDDvsdfb + SDphi +
                                            SDgamma * sqrt(SDphi);
                     else 
                        pParam->B3SOIDDvsdth = pParam->B3SOIDDvsdfb - SDphi -
                                            SDgamma * sqrt(SDphi);
                  }
                  if (!model->B3SOIDDcsdminGiven)
                  {
                     /* Cdmin */
                     tmp = sqrt(2.0 * EPSSI * SDphi / (Charge_q * 
                                fabs(pParam->B3SOIDDnsub) * 1.0e6));
                     tmp1 = EPSSI / tmp;
                     model->B3SOIDDcsdmin = tmp1 * model->B3SOIDDcbox /
                                          (tmp1 + model->B3SOIDDcbox);
                  }


                  T0 = model->B3SOIDDcsdesw * log(1 + model->B3SOIDDtsi /
                       model->B3SOIDDtbox);
                  T1 = here->B3SOIDDsourcePerimeter - pParam->B3SOIDDweff;
                  if (T1 > 0.0)
                     pParam->B3SOIDDcsesw = T0 * T1; 
                  else
                     pParam->B3SOIDDcsesw = 0.0;
                  T1 = here->B3SOIDDdrainPerimeter - pParam->B3SOIDDweff;
                  if (T1 > 0.0)
                     pParam->B3SOIDDcdesw = T0 * T1;
                  else
                     pParam->B3SOIDDcdesw = 0.0;

		  pParam->B3SOIDDphi = 2.0 * model->B3SOIDDvtm 
			           * log(pParam->B3SOIDDnpeak / ni);

	          pParam->B3SOIDDsqrtPhi = sqrt(pParam->B3SOIDDphi);
	          pParam->B3SOIDDphis3 = pParam->B3SOIDDsqrtPhi * pParam->B3SOIDDphi;

                  pParam->B3SOIDDXdep0 = sqrt(2.0 * EPSSI / (Charge_q
				     * pParam->B3SOIDDnpeak * 1.0e6))
                                     * pParam->B3SOIDDsqrtPhi; 
                  pParam->B3SOIDDsqrtXdep0 = sqrt(pParam->B3SOIDDXdep0);
                  pParam->B3SOIDDlitl = sqrt(3.0 * model->B3SOIDDxj
				    * model->B3SOIDDtox);
                  pParam->B3SOIDDvbi = model->B3SOIDDvtm * log(1.0e20
			           * pParam->B3SOIDDnpeak / (ni * ni));
                  pParam->B3SOIDDcdep0 = sqrt(Charge_q * EPSSI
				     * pParam->B3SOIDDnpeak * 1.0e6 / 2.0
				     / pParam->B3SOIDDphi);
        
                  if (model->B3SOIDDk1Given || model->B3SOIDDk2Given)
	          {   if (!model->B3SOIDDk1Given)
	              {   fprintf(stdout, "Warning: k1 should be specified with k2.\n");
                          pParam->B3SOIDDk1 = 0.53;
                      }
                      if (!model->B3SOIDDk2Given)
	              {   fprintf(stdout, "Warning: k2 should be specified with k1.\n");
                          pParam->B3SOIDDk2 = -0.0186;
                      }
                      if (model->B3SOIDDxtGiven)
                          fprintf(stdout, "Warning: xt is ignored because k1 or k2 is given.\n");
                      if (model->B3SOIDDvbxGiven)
                          fprintf(stdout, "Warning: vbx is ignored because k1 or k2 is given.\n");
                      if (model->B3SOIDDvbmGiven)
                          fprintf(stdout, "Warning: vbm is ignored because k1 or k2 is given.\n");
                      if (model->B3SOIDDgamma1Given)
                          fprintf(stdout, "Warning: gamma1 is ignored because k1 or k2 is given.\n");
                      if (model->B3SOIDDgamma2Given)
                          fprintf(stdout, "Warning: gamma2 is ignored because k1 or k2 is given.\n");
                  }
                  else
	          {   if (!model->B3SOIDDvbxGiven)
                          pParam->B3SOIDDvbx = pParam->B3SOIDDphi - 7.7348e-4 
                                           * pParam->B3SOIDDnpeak
					   * pParam->B3SOIDDxt * pParam->B3SOIDDxt;
	              if (pParam->B3SOIDDvbx > 0.0)
		          pParam->B3SOIDDvbx = -pParam->B3SOIDDvbx;
	              if (pParam->B3SOIDDvbm > 0.0)
                          pParam->B3SOIDDvbm = -pParam->B3SOIDDvbm;
           
                      if (!model->B3SOIDDgamma1Given)
                          pParam->B3SOIDDgamma1 = 5.753e-12
					      * sqrt(pParam->B3SOIDDnpeak)
                                              / model->B3SOIDDcox;
                      if (!model->B3SOIDDgamma2Given)
                          pParam->B3SOIDDgamma2 = 5.753e-12
					      * sqrt(pParam->B3SOIDDnsub)
                                              / model->B3SOIDDcox;

                      T0 = pParam->B3SOIDDgamma1 - pParam->B3SOIDDgamma2;
                      T1 = sqrt(pParam->B3SOIDDphi - pParam->B3SOIDDvbx)
			 - pParam->B3SOIDDsqrtPhi;
                      T2 = sqrt(pParam->B3SOIDDphi * (pParam->B3SOIDDphi
			 - pParam->B3SOIDDvbm)) - pParam->B3SOIDDphi;
                      pParam->B3SOIDDk2 = T0 * T1 / (2.0 * T2 + pParam->B3SOIDDvbm);
                      pParam->B3SOIDDk1 = pParam->B3SOIDDgamma2 - 2.0
				      * pParam->B3SOIDDk2 * sqrt(pParam->B3SOIDDphi
				      - pParam->B3SOIDDvbm);
                  }
 
		  if (pParam->B3SOIDDk2 < 0.0)
		  {   T0 = 0.5 * pParam->B3SOIDDk1 / pParam->B3SOIDDk2;
                      pParam->B3SOIDDvbsc = 0.9 * (pParam->B3SOIDDphi - T0 * T0);
		      if (pParam->B3SOIDDvbsc > -3.0)
		          pParam->B3SOIDDvbsc = -3.0;
		      else if (pParam->B3SOIDDvbsc < -30.0)
		          pParam->B3SOIDDvbsc = -30.0;
		  }
		  else
		  {   pParam->B3SOIDDvbsc = -30.0;
		  }
		  if (pParam->B3SOIDDvbsc > pParam->B3SOIDDvbm)
		      pParam->B3SOIDDvbsc = pParam->B3SOIDDvbm;

	          if (model->B3SOIDDvth0Given)
		  {   pParam->B3SOIDDvfb = model->B3SOIDDtype * pParam->B3SOIDDvth0 
                                       - pParam->B3SOIDDphi - pParam->B3SOIDDk1 
                                       * pParam->B3SOIDDsqrtPhi;
		  }
		  else
		  {   pParam->B3SOIDDvfb = -1.0;
		      pParam->B3SOIDDvth0 = model->B3SOIDDtype * (pParam->B3SOIDDvfb
                                        + pParam->B3SOIDDphi + pParam->B3SOIDDk1 
                                        * pParam->B3SOIDDsqrtPhi);
		  }
                  T1 = sqrt(EPSSI / EPSOX * model->B3SOIDDtox
		     * pParam->B3SOIDDXdep0);
                  T0 = exp(-0.5 * pParam->B3SOIDDdsub * pParam->B3SOIDDleff / T1);
                  pParam->B3SOIDDtheta0vb0 = (T0 + 2.0 * T0 * T0);

                  T0 = exp(-0.5 * pParam->B3SOIDDdrout * pParam->B3SOIDDleff / T1);
                  T2 = (T0 + 2.0 * T0 * T0);
                  pParam->B3SOIDDthetaRout = pParam->B3SOIDDpdibl1 * T2
				         + pParam->B3SOIDDpdibl2;

                  here->B3SOIDDminIsub = 5.0e-2 * pParam->B3SOIDDweff * model->B3SOIDDtsi
                                     * MAX(pParam->B3SOIDDisdif, pParam->B3SOIDDisrec);
	      }

              here->B3SOIDDcsbox = model->B3SOIDDcbox*here->B3SOIDDsourceArea;
              here->B3SOIDDcsmin = model->B3SOIDDcsdmin*here->B3SOIDDsourceArea;
              here->B3SOIDDcdbox = model->B3SOIDDcbox*here->B3SOIDDdrainArea;
              here->B3SOIDDcdmin = model->B3SOIDDcsdmin*here->B3SOIDDdrainArea;

              if ( ((pParam->B3SOIDDnsub > 0) && (model->B3SOIDDtype > 0)) ||
	           ((pParam->B3SOIDDnsub < 0) && (model->B3SOIDDtype < 0)) )
              {
                 T0 = pParam->B3SOIDDvsdth - pParam->B3SOIDDvsdfb;
                 pParam->B3SOIDDsdt1 = pParam->B3SOIDDvsdfb + model->B3SOIDDasd * T0;
                 T1 = here->B3SOIDDcsbox - here->B3SOIDDcsmin;
                 T2 = T1 / T0 / T0;
                 pParam->B3SOIDDst2 = T2 / model->B3SOIDDasd;
                 pParam->B3SOIDDst3 = T2 /( 1 - model->B3SOIDDasd);
                 here->B3SOIDDst4 =  T0 * T1 * (1 + model->B3SOIDDasd) / 3
                                  - here->B3SOIDDcsmin * pParam->B3SOIDDvsdfb;
 
                 T1 = here->B3SOIDDcdbox - here->B3SOIDDcdmin;
                 T2 = T1 / T0 / T0;
                 pParam->B3SOIDDdt2 = T2 / model->B3SOIDDasd;
                 pParam->B3SOIDDdt3 = T2 /( 1 - model->B3SOIDDasd);
                 here->B3SOIDDdt4 =  T0 * T1 * (1 + model->B3SOIDDasd) / 3
                                  - here->B3SOIDDcdmin * pParam->B3SOIDDvsdfb;
	      } else
              {
                 T0 = pParam->B3SOIDDvsdfb - pParam->B3SOIDDvsdth;
                 pParam->B3SOIDDsdt1 = pParam->B3SOIDDvsdth + model->B3SOIDDasd * T0;
                 T1 = here->B3SOIDDcsmin - here->B3SOIDDcsbox;
                 T2 = T1 / T0 / T0;
                 pParam->B3SOIDDst2 = T2 / model->B3SOIDDasd;
                 pParam->B3SOIDDst3 = T2 /( 1 - model->B3SOIDDasd);
                 here->B3SOIDDst4 =  T0 * T1 * (1 + model->B3SOIDDasd) / 3
                                  - here->B3SOIDDcsbox * pParam->B3SOIDDvsdth;
  
                 T1 = here->B3SOIDDcdmin - here->B3SOIDDcdbox;
                 T2 = T1 / T0 / T0;
                 pParam->B3SOIDDdt2 = T2 / model->B3SOIDDasd;
                 pParam->B3SOIDDdt3 = T2 /( 1 - model->B3SOIDDasd);
                 here->B3SOIDDdt4 =  T0 * T1 * (1 + model->B3SOIDDasd) / 3
                                  - here->B3SOIDDcdbox * pParam->B3SOIDDvsdth;
              } 

	      here->B3SOIDDphi = pParam->B3SOIDDphi;
              /* process source/drain series resistance */
              here->B3SOIDDdrainConductance = model->B3SOIDDsheetResistance 
		                              * here->B3SOIDDdrainSquares;
              if (here->B3SOIDDdrainConductance > 0.0)
                  here->B3SOIDDdrainConductance = 1.0
					      / here->B3SOIDDdrainConductance;
	      else
                  here->B3SOIDDdrainConductance = 0.0;
                  
              here->B3SOIDDsourceConductance = model->B3SOIDDsheetResistance 
		                           * here->B3SOIDDsourceSquares;
              if (here->B3SOIDDsourceConductance > 0.0) 
                  here->B3SOIDDsourceConductance = 1.0
					       / here->B3SOIDDsourceConductance;
	      else
                  here->B3SOIDDsourceConductance = 0.0;
	      here->B3SOIDDcgso = pParam->B3SOIDDcgso;
	      here->B3SOIDDcgdo = pParam->B3SOIDDcgdo;

         }
    }
    return(OK);
}