src/material/S-SiO2/SiO2S_band.cc

   1 /*****************************************************************************/
   2 /*                                                                           */
   3 /*              8888888         88888888         88888888                    */
   4 /*            8                8                8                            */
   5 /*           8                 8                8                            */
   6 /*           8                  88888888         88888888                    */
   7 /*           8      8888                8                8                   */
   8 /*            8       8                 8                8                   */
   9 /*              888888         888888888        888888888                    */
  10 /*                                                                           */
  11 /*       A Two-Dimensional General Purpose Semiconductor Simulator.          */
  12 /*                                                                           */
  13 /*  GSS material database Version 0.4                                        */
  14 /*  Last update: Feb 17, 2006                                                */
  15 /*                                                                           */
  16 /*  Gong Ding                                                                */
  17 /*  gdiso@ustc.edu                                                           */
  18 /*  NINT, No.69 P.O.Box, Xi'an City, China                                   */
  19 /*                                                                           */
  20 /*****************************************************************************/
  21 //
  22 // Material Type: SiO2 as semiconductor
  23
  24
  25 #include "PMI.h"
  26
  27
  28 class GSS_SiO2S_BandStructure : public PMIS_BandStructure
  29 {
  30 private:
  31   PetscScalar T300;
  32   //[Bandgap]
  33   // Bandgap and Effective Density of States
  34   PetscScalar EG300;     // The energy bandgap of the material at 300 K.
  35   PetscScalar EGALPH;    // The value of alpha used in calculating the temperature depended energy bandgap.
  36   PetscScalar EGBETA;    // The value of beta  used in calculating the temperature depended energy bandgap.
  37   PetscScalar ELECMASS;  // The relative effective mass of electron
  38   PetscScalar HOLEMASS;  // The relative effective mass of hole
  39   PetscScalar NC300;     // The effective density of states in the conduction band at 300K.
  40   PetscScalar NV300;     // The effective density of states in the valence band at 300K.
  41   PetscScalar NC_F;      // The parameter for temperature depended effective density of states in the conduction band.
  42   PetscScalar NV_F;      // The parameter for temperature depended effective density of states in the valence band.
  43   // Model of Bandgap Narrowing due to Heavy Doping
  44   PetscScalar N0_BGN;    // The concentration parameter used in Slotboom's band-gap narrowing model.
  45   PetscScalar V0_BGN;    // The voltage parameter used in Slotboom's band-gap narrowing model.
  46   PetscScalar CON_BGN;   // The const parameter used in Slotboom's band-gap narrowing model.
  47
  48   // Init value
  49   void Eg_Init()
  50   {
  51     EG300     = 9.000000e+00*eV;
  52     EGALPH    = 0.000000e+00*eV/K;
  53     EGBETA    = 0.000000e+00*K;
  54
  55     ELECMASS  = 4.200000E-01*me;
  56     HOLEMASS  = 1.000000E+00*me;
  57     NC300     = 2.800000e+19*pow(cm,-3);
  58     NV300     = 1.040000e+19*pow(cm,-3);
  59     NC_F      = 1.500000e+00;
  60     NV_F      = 1.500000e+00;
  61     N0_BGN    = 1.000000e+17*pow(cm,-3);
  62     V0_BGN    = 0.000000e+00*V;
  63     CON_BGN   = 0.000000e+00*eV;
  64   }
  65 public:
  66   //---------------------------------------------------------------------------
  67   // procedure of Bandgap
  68   PetscScalar Eg (const PetscScalar &Tl)
  69   {
  70     return EG300+EGALPH*(T300*T300/(T300+EGBETA) - Tl*Tl/(Tl+EGBETA));
  71   }
  72   AutoDScalar Eg (const AutoDScalar &Tl)
  73   {
  74     return EG300+EGALPH*(T300*T300/(T300+EGBETA) - Tl*Tl/(Tl+EGBETA));
  75   }
  76
  77   //---------------------------------------------------------------------------
  78   // procedure of Bandgap Narrowing due to Heavy Doping
  79   PetscScalar EgNarrow(const PetscScalar &Tl)
  80   {
  81     PetscScalar Na = ReadDopingNa();
  82     PetscScalar Nd = ReadDopingNd();
  83     PetscScalar N = Na+Nd+1.0*pow(cm,-3);
  84     PetscScalar x = log(N/N0_BGN);
  85     return V0_BGN*(x+sqrt(x*x+CON_BGN));
  86   }
  87   PetscScalar EgNarrowToEc   (const PetscScalar &Tl){return 0.5*EgNarrow(Tl);}
  88   PetscScalar EgNarrowToEv   (const PetscScalar &Tl){return 0.5*EgNarrow(Tl);}
  89
  90   AutoDScalar EgNarrow(const AutoDScalar &Tl)
  91   {
  92     PetscScalar Na = ReadDopingNa();
  93     PetscScalar Nd = ReadDopingNd();
  94     PetscScalar N = Na+Nd+1.0*pow(cm,-3);
  95     PetscScalar x = log(N/N0_BGN);
  96     return V0_BGN*(x+sqrt(x*x+CON_BGN));
  97   }
  98   AutoDScalar EgNarrowToEc   (const AutoDScalar &Tl){return 0.5*EgNarrow(Tl);}
  99   AutoDScalar EgNarrowToEv   (const AutoDScalar &Tl){return 0.5*EgNarrow(Tl);}
 100
 101
 102   //---------------------------------------------------------------------------
 103   //electron and hole effect mass
 104   PetscScalar EffecElecMass (const PetscScalar &Tl)
 105   {
 106         return ELECMASS;
 107   }
 108   PetscScalar EffecHoleMass (const PetscScalar &Tl)
 109   {
 110         return HOLEMASS;
 111   }
 112
 113   //---------------------------------------------------------------------------
 114   // Nc and Nv
 115   PetscScalar Nc (const PetscScalar &Tl)
 116   {
 117     return 2.540e19*ELECMASS/me*pow(Tl/T300,NC_F);
 118   }
 119   AutoDScalar Nc (const AutoDScalar &Tl)
 120   {
 121     return 2.540e19*ELECMASS/me*pow(Tl/T300,NC_F);
 122   }
 123   PetscScalar Nv (const PetscScalar &Tl)
 124   {
 125     return 2.540e19*HOLEMASS/me*pow(Tl/T300,NC_F);
 126   }
 127   AutoDScalar Nv (const AutoDScalar &Tl)
 128   {
 129     return 2.540e19*HOLEMASS/me*pow(Tl/T300,NC_F);
 130   }
 131
 132   //---------------------------------------------------------------------------
 133   // nie, Eg narrow should be considered
 134   PetscScalar nie (const PetscScalar &Tl)
 135   {
 136     PetscScalar bandgap = Eg(Tl);
 137     PetscScalar Nc = NC300*pow(Tl/T300,NC_F);
 138     PetscScalar Nv = NV300*pow(Tl/T300,NV_F);
 139     return sqrt(Nc*Nv)*exp(-bandgap/(2*kb*Tl))*exp(EgNarrow(Tl));
 140   }
 141   AutoDScalar nie (const AutoDScalar &Tl)
 142   {
 143     AutoDScalar bandgap = Eg(Tl);
 144     AutoDScalar Nc = NC300*pow(Tl/T300,NC_F);
 145     AutoDScalar Nv = NV300*pow(Tl/T300,NV_F);
 146     return sqrt(Nc*Nv)*exp(-bandgap/(2*kb*Tl))*exp(EgNarrow(Tl));
 147   }
 148
 149   //end of Bandgap
 150
 151 private:
 152   //[Lifetime]
 153   //Lifetimes
 154   PetscScalar TAUN0;         // The Shockley-Read-Hall electron lifetime.
 155   PetscScalar TAUP0;         // The Shockley-Read-Hall hole lifetime.
 156   PetscScalar SurfTauN;      // The electron surface recombination velocity.
 157   PetscScalar SurfTauP;      // The hole surface recombination velocity.
 158   //Concentration-Dependent Lifetimes
 159   PetscScalar NSRHN;         // The Shockley-Read-Hall concentration parameter for electrons.
 160   PetscScalar AN;            // The constant term in the concentration-dependent expression for electron lifetime.
 161   PetscScalar BN;            // The linear term coefficient in the concentration-dependent expression for electron lifetime.
 162   PetscScalar CN;            // The exponential term coefficient in the concentration-dependent expression for electron lifetime.
 163   PetscScalar EN;            // The exponent in the concentration-dependent expression for electron lifetime.
 164   PetscScalar NSRHP;            // The Shockley-Read-Hall concentration parameter for holes.
 165   PetscScalar AP;            // The constant term in the concentration-dependent expression for hole lifetime.
 166   PetscScalar BP;            // The linear term coefficient in the concentration-dependent expression for hole lifetime.
 167   PetscScalar CP;            // The exponential term coefficient in the concentration-dependent expression for hole lifetime.
 168   PetscScalar EP;            // The exponent in the concentration-dependent expression for hole lifetime.
 169   // Lattice Temperature-Dependent Lifetimes
 170   PetscScalar EXN_TAU;       // The exponent of lattice temperature dependent electron lifetime.
 171   PetscScalar EXP_TAU;       // The exponent of lattice temperature dependent hole lifetime.
 172
 173   //Init value, the dummy value is not exact!
 174   void Lifetime_Init()
 175   {
 176     TAUN0     = 1.000000e+00*s;
 177     TAUP0     = 1.000000e+00*s;
 178     SurfTauN  = 0.000000e+00*cm/s;
 179     SurfTauP  = 0.000000e+00*cm/s;
 180     NSRHN     = 5.000000e+16*pow(cm,-3);
 181     AN        = 1.000000e+00;
 182     BN        = 1.000000e+00;
 183     CN        = 0.000000e+00;
 184     EN        = 2.000000e+00;
 185     NSRHP     = 5.000000e+16*pow(cm,-3);
 186     AP        = 1.000000e+00;
 187     BP        = 1.000000e+00;
 188     CP        = 0.000000e+00;
 189     EP        = 2.000000e+00;
 190     EXN_TAU   = 0.000000e+00;
 191     EXP_TAU   = 0.000000e+00;
 192   }
 193
 194 public:
 195   //---------------------------------------------------------------------------
 196   // electron lift time for SHR Recombination
 197   PetscScalar TAUN (const PetscScalar &Tl)
 198   {
 199     PetscScalar Na = ReadDopingNa();
 200     PetscScalar Nd = ReadDopingNd();
 201     return TAUN0/(1+(Na+Nd)/NSRHN)*pow(Tl/T300,EXN_TAU);
 202   }
 203   AutoDScalar TAUN (const AutoDScalar &Tl)
 204   {
 205     PetscScalar Na = ReadDopingNa();
 206     PetscScalar Nd = ReadDopingNd();
 207     return TAUN0/(1+(Na+Nd)/NSRHN)*pow(Tl/T300,EXN_TAU);
 208   }
 209
 210   //---------------------------------------------------------------------------
 211   // hole lift time for SHR Recombination
 212   PetscScalar TAUP (const PetscScalar &Tl)
 213   {
 214     PetscScalar Na = ReadDopingNa();
 215     PetscScalar Nd = ReadDopingNd();
 216     return TAUP0/(1+(Na+Nd)/NSRHP)*pow(Tl/T300,EXP_TAU);
 217   }
 218   AutoDScalar TAUP (const AutoDScalar &Tl)
 219   {
 220     PetscScalar Na = ReadDopingNa();
 221     PetscScalar Nd = ReadDopingNd();
 222     return TAUP0/(1+(Na+Nd)/NSRHP)*pow(Tl/T300,EXP_TAU);
 223   }
 224   // End of Lifetime
 225
 226   //[the fit parameter for density-gradient solver]
 227   PetscScalar Gamman         () {return 1.0;}
 228   PetscScalar Gammap         () {return 1.0;}
 229
 230 private:
 231   //[Recombination]
 232   // SRH, Auger, and Direct Recombination
 233   PetscScalar ETRAP;         // The trap level (Et - Ei) used in determining the Shockley-Read-Hall recombination rate.
 234   PetscScalar AUGN;          // The Auger coefficient for electrons.
 235   PetscScalar AUGP;          // The Auger coefficient for holes.
 236   PetscScalar C_DIRECT;      // The band-to-band recombination coefficient.
 237   // Init value
 238   void Recomb_Init()
 239   {
 240     ETRAP   = 0.000000e+00*eV;
 241     AUGN    =  0.000000e+00*pow(cm,6)/s;
 242     AUGP    =  0.000000e+00*pow(cm,6)/s;
 243     C_DIRECT = 0.000000e+00*pow(cm,3)/s;
 244   }
 245
 246 public:
 247   //---------------------------------------------------------------------------
 248   // Direct Recombination
 249   PetscScalar R_Direct     (const PetscScalar &p, const PetscScalar &n, const PetscScalar &Tl)
 250   {
 251     PetscScalar ni =   nie(Tl);
 252     return C_DIRECT*(n*p-ni*ni);
 253   }
 254   AutoDScalar R_Direct     (const AutoDScalar &p, const AutoDScalar &n, const AutoDScalar &Tl)
 255   {
 256     AutoDScalar ni =   nie(Tl);
 257     return C_DIRECT*(n*p-ni*ni);
 258   }
 259
 260   //---------------------------------------------------------------------------
 261   // Auger Recombination
 262   PetscScalar R_Auger     (const PetscScalar &p, const PetscScalar &n, const PetscScalar &Tl)
 263   {
 264     PetscScalar ni =   nie(Tl);
 265     return AUGN*(p*n*n-n*ni*ni)+AUGP*(n*p*p-p*ni*ni);
 266   }
 267   AutoDScalar R_Auger     (const AutoDScalar &p, const AutoDScalar &n, const AutoDScalar &Tl)
 268   {
 269     AutoDScalar ni =   nie(Tl);
 270     return AUGN*(p*n*n-n*ni*ni)+AUGP*(n*p*p-p*ni*ni);
 271   }
 272
 273   //---------------------------------------------------------------------------
 274   // SHR Recombination
 275   PetscScalar R_SHR     (const PetscScalar &p, const PetscScalar &n, const PetscScalar &Tl)
 276   {
 277     PetscScalar ni =   nie(Tl);
 278     PetscScalar taun = TAUN(Tl);
 279     PetscScalar taup = TAUP(Tl);
 280     return (p*n-ni*ni)/(taup*(n+ni)+taun*(p+ni));
 281   }
 282   AutoDScalar R_SHR     (const AutoDScalar &p, const AutoDScalar &n, const AutoDScalar &Tl)
 283   {
 284     AutoDScalar ni =   nie(Tl);
 285     AutoDScalar taun = TAUN(Tl);
 286     AutoDScalar taup = TAUP(Tl);
 287     return (p*n-ni*ni)/(taup*(n+ni)+taun*(p+ni));
 288   }
 289
 290   //---------------------------------------------------------------------------
 291   // Surface SHR Recombination
 292   PetscScalar R_Surf     (const PetscScalar &p, const PetscScalar &n, const PetscScalar &Tl, const PetscScalar &reciprocal_len)
 293   {
 294     PetscScalar ni =   nie(Tl);
 295     PetscScalar taun = TAUN(Tl);
 296     PetscScalar taup = TAUP(Tl);
 297     taun = 1.0/(SurfTauN*reciprocal_len + 1.0/taun);
 298     taup = 1.0/(SurfTauP*reciprocal_len + 1.0/taup);
 299     return (p*n-ni*ni)/(taup*(n+ni)+taun*(p+ni));
 300   }
 301   AutoDScalar R_Surf     (const AutoDScalar &p, const AutoDScalar &n, const AutoDScalar &Tl, const PetscScalar &reciprocal_len)
 302   {
 303     AutoDScalar ni =   nie(Tl);
 304     AutoDScalar taun = TAUN(Tl);
 305     AutoDScalar taup = TAUP(Tl);
 306     taun = 1.0/(SurfTauN*reciprocal_len + 1.0/taun);
 307     taup = 1.0/(SurfTauP*reciprocal_len + 1.0/taup);
 308     return (p*n-ni*ni)/(taup*(n+ni)+taun*(p+ni));
 309   }
 310
 311   //---------------------------------------------------------------------------
 312   // total Recombination
 313   PetscScalar Recomb (const PetscScalar &p, const PetscScalar &n, const PetscScalar &Tl)
 314   {
 315     PetscScalar ni =   nie(Tl);
 316     PetscScalar taun = TAUN(Tl);
 317     PetscScalar taup = TAUP(Tl);
 318     PetscScalar dn   = p*n-ni*ni;
 319     PetscScalar Rshr = dn/(taup*(n+ni)+taun*(p+ni));
 320     PetscScalar Rdir = C_DIRECT*dn;
 321     PetscScalar Raug = (AUGN*n+AUGP*p)*dn;
 322     return Rshr+Rdir+Raug;
 323   }
 324   AutoDScalar Recomb (const AutoDScalar &p, const AutoDScalar &n, const AutoDScalar &Tl)
 325   {
 326     AutoDScalar ni =   nie(Tl);
 327     AutoDScalar taun = TAUN(Tl);
 328     AutoDScalar taup = TAUP(Tl);
 329     AutoDScalar dn   = p*n-ni*ni;
 330     AutoDScalar Rshr = dn/(taup*(n+ni)+taun*(p+ni));
 331     AutoDScalar Rdir = C_DIRECT*dn;
 332     AutoDScalar Raug = (AUGN*n+AUGP*p)*dn;
 333     return Rshr+Rdir+Raug;
 334   }
 335
 336   // End of Recombination
 337
 338 private:
 339   //[energy relax time]
 340   void RelaxTime_Init()
 341   {
 342   }
 343 public:
 344   //---------------------------------------------------------------------------
 345   // Electron relaxation time for EBM
 346   PetscScalar ElecEnergyRelaxTime(const PetscScalar &Tn,const PetscScalar &Tl)
 347   {
 348     return 1e-12*s; //this dummy value is not exact
 349   }
 350   AutoDScalar ElecEnergyRelaxTime(const AutoDScalar &Tn,const AutoDScalar &Tl)
 351   {
 352     return 1e-12*s; //this dummy value is not exact
 353   }
 354
 355   //---------------------------------------------------------------------------
 356   // Hole relaxation time for EBM
 357   PetscScalar HoleEnergyRelaxTime(const PetscScalar &Tp,const PetscScalar &Tl)
 358   {
 359     return 1e-12*s; //this dummy value is not exact
 360   }
 361   AutoDScalar HoleEnergyRelaxTime(const AutoDScalar &Tp,const AutoDScalar &Tl)
 362   {
 363     return 1e-12*s; //this dummy value is not exact
 364   }
 365   // end of energy relax time
 366
 367 private:
 368   // [Schottky and Heterojunction]
 369   PetscScalar ARICHN;
 370   PetscScalar ARICHP;
 371   PetscScalar VSURFN;   // Thermionic emission velocity of electron
 372   PetscScalar VSURFP;
 373
 374   void   Schottky_Init()
 375   {
 376     ARICHN = 1.100000e+02*A/(K*cm)/(K*cm);
 377     ARICHP = 3.000000e+01*A/(K*cm)/(K*cm);
 378   }
 379
 380 public:
 381   PetscScalar SchottyJsn (PetscScalar n,PetscScalar Tl,PetscScalar Vb)
 382   {
 383     PetscScalar VSURFN = ARICHN*Tl*Tl/(e*Nc(Tl));
 384     PetscScalar nb = Nc(Tl)*exp(-e*Vb/(kb*Tl));
 385     return -e*VSURFN*(n-nb);
 386   }
 387   PetscScalar SchottyJsp (PetscScalar p,PetscScalar Tl,PetscScalar Vb)
 388   {
 389     PetscScalar VSURFP = ARICHP*Tl*Tl/(e*Nv(Tl));
 390     PetscScalar pb = Nv(Tl)*exp((-Eg(Tl)+e*Vb)/(kb*Tl));
 391     return e*VSURFP*(p-pb);
 392   }
 393   PetscScalar SchottyBarrierLowerring (PetscScalar eps, PetscScalar E)
 394   {
 395     return sqrt(e/(4*3.1415926535*eps)*E);
 396   }
 397   PetscScalar pdSchottyJsn_pdn(PetscScalar n,PetscScalar Tl,PetscScalar Vb)
 398   {
 399     PetscScalar VSURFN = ARICHN*Tl*Tl/(e*Nc(Tl));
 400     return -e*VSURFN;
 401   }
 402   PetscScalar pdSchottyJsp_pdp(PetscScalar p,PetscScalar Tl,PetscScalar Vb)
 403   {
 404     PetscScalar VSURFP = ARICHP*Tl*Tl/(e*Nv(Tl));
 405     return e*VSURFP;
 406   }
 407   PetscScalar pdSchottyJsn_pdTl(PetscScalar n,PetscScalar Tl,PetscScalar Vb)
 408   {
 409     //use finite difference approximate
 410     PetscScalar dJ = SchottyJsn(n,Tl,Vb)-SchottyJsn(n,(1-1e-10)*Tl,Vb);
 411     return dJ/(1e-10*Tl);
 412   }
 413   PetscScalar pdSchottyJsp_pdTl(PetscScalar p,PetscScalar Tl,PetscScalar Vb)
 414   {
 415     //use finite difference approximate
 416     PetscScalar dJ = SchottyJsp(p,Tl,Vb)-SchottyJsp(p,(1-1e-10)*Tl,Vb);
 417     return dJ/(1e-10*Tl);
 418   }
 419   PetscScalar ThermalVn (PetscScalar Tl)
 420   {
 421         return sqrt(kb*Tl/(2*3.14159265359*EffecElecMass(Tl)));
 422   }
 423   PetscScalar ThermalVp (PetscScalar Tl)
 424   {
 425         return sqrt(kb*Tl/(2*3.14159265359*EffecHoleMass(Tl)));
 426   }
 427   PetscScalar pdThermalVn_pdTl (PetscScalar Tl)
 428   {
 429         return 0;
 430   }
 431   PetscScalar pdThermalVp_pdTl (PetscScalar Tl)
 432   {
 433         return 0;
 434   }
 435
 436 private:
 437   // [band to band Tunneling]
 438   PetscScalar  A_BTBT;
 439   PetscScalar  B_BTBT;
 440   void   BBTunneling_Init()
 441   {
 442     A_BTBT = 0.000000E+00*sqrt(e*V)/cm/s/V/V;
 443     B_BTBT = 0.000000E+00*V/cm/pow(e*V,PetscScalar(1.5));
 444   }
 445 public:
 446   //----------------------------------------------------------------
 447   // band to band Tunneling
 448   PetscScalar BB_Tunneling(const PetscScalar &Tl, const PetscScalar &E)
 449   {
 450      return A_BTBT*E*E/sqrt(Eg(Tl))*exp(-B_BTBT*pow(Eg(Tl),PetscScalar(1.5))/(E+1*V/cm));
 451   }
 452   AutoDScalar BB_Tunneling(const AutoDScalar &Tl, const AutoDScalar &E)
 453   {
 454      return A_BTBT*E*E/sqrt(Eg(Tl))*exp(-B_BTBT*pow(Eg(Tl),PetscScalar(1.5))/(E+1*V/cm));
 455   }
 456
 457
 458 // constructor and destructor
 459 public:
 460   GSS_SiO2S_BandStructure(const PMIS_Environment &env):PMIS_BandStructure(env)
 461   {
 462     T300 = 300.0*K;
 463     Eg_Init();
 464     Lifetime_Init();
 465     Recomb_Init();
 466     RelaxTime_Init();
 467     Schottky_Init();
 468     BBTunneling_Init();
 469   }
 470
 471   ~GSS_SiO2S_BandStructure()
 472   {}
 473 }
 474 ;
 475
 476
 477 extern "C"
 478 {
 479   PMIS_BandStructure*  PMIS_SiO2S_BandStructure_Default (const PMIS_Environment& env)
 480   {
 481     return new GSS_SiO2S_BandStructure(env);
 482   }
 483 }