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