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