src/material/GaAs/GaAs_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: GaAs
  23
  24
  25 #include "PMI.h"
  26
  27
  28 class GSS_GaAs_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     = 1.424000e+00*eV;
  52     EGALPH    = 5.405000e-04*eV/K;
  53     EGBETA    = 2.040000e+02*K;
  54     ELECMASS  = 6.700000E-02*me;
  55     HOLEMASS  = 6.415000E-01*me;
  56     NC300     = 4.700000e+17*pow(cm,-3);
  57     NV300     = 7.000000e+18*pow(cm,-3);
  58     NC_F      = 1.500000e+00;
  59     NV_F      = 1.500000e+00;
  60     N0_BGN    = 1.000000e+17*pow(cm,-3);
  61     V0_BGN    = 0.000000e+00*V;
  62     CON_BGN   = 0.000000e+00*eV;
  63   }
  64 public:
  65   //---------------------------------------------------------------------------
  66   // procedure of Bandgap
  67   PetscScalar Eg (const PetscScalar &Tl)
  68   {
  69     return EG300+EGALPH*(T300*T300/(T300+EGBETA) - Tl*Tl/(Tl+EGBETA));
  70   }
  71   AutoDScalar Eg (const AutoDScalar &Tl)
  72   {
  73     return EG300+EGALPH*(T300*T300/(T300+EGBETA) - Tl*Tl/(Tl+EGBETA));
  74   }
  75
  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   //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   //---------------------------------------------------------------------------
 115   // Nc and Nv
 116   PetscScalar Nc (const PetscScalar &Tl)
 117   {
 118     return NC300*pow(Tl/T300,NC_F);
 119   }
 120   AutoDScalar Nc (const AutoDScalar &Tl)
 121   {
 122     return NC300*pow(Tl/T300,NC_F);
 123   }
 124
 125   PetscScalar Nv (const PetscScalar &Tl)
 126   {
 127     return NV300*pow(Tl/T300,NV_F);
 128   }
 129   AutoDScalar Nv (const AutoDScalar &Tl)
 130   {
 131     return NV300*pow(Tl/T300,NV_F);
 132   }
 133
 134   //---------------------------------------------------------------------------
 135   // nie
 136   PetscScalar nie (const PetscScalar &Tl)
 137   {
 138     PetscScalar bandgap = Eg(Tl);
 139     PetscScalar Nc = NC300*pow(Tl/T300,NC_F);
 140     PetscScalar Nv = NV300*pow(Tl/T300,NV_F);
 141     return sqrt(Nc*Nv)*exp(-bandgap/(2*kb*Tl))*exp(EgNarrow(Tl));
 142   }
 143   AutoDScalar nie (const AutoDScalar &Tl)
 144   {
 145     AutoDScalar bandgap = Eg(Tl);
 146     AutoDScalar Nc = NC300*pow(Tl/T300,NC_F);
 147     AutoDScalar Nv = NV300*pow(Tl/T300,NV_F);
 148     return sqrt(Nc*Nv)*exp(-bandgap/(2*kb*Tl))*exp(EgNarrow(Tl));
 149   }
 150
 151   //end of Bandgap
 152
 153 private:
 154   //[Lifetime]
 155   //Lifetimes
 156   PetscScalar TAUN0;         // The Shockley-Read-Hall electron lifetime.
 157   PetscScalar TAUP0;         // The Shockley-Read-Hall hole lifetime.
 158   PetscScalar SurfTauN;      // The electron surface recombination velocity.
 159   PetscScalar SurfTauP;      // The hole surface recombination velocity.
 160   //Concentration-Dependent Lifetimes
 161   PetscScalar NSRHN;         // The Shockley-Read-Hall concentration parameter for electrons.
 162   PetscScalar AN;            // The constant term in the concentration-dependent expression for electron lifetime.
 163   PetscScalar BN;            // The linear term coefficient in the concentration-dependent expression for electron lifetime.
 164   PetscScalar CN;            // The exponential term coefficient in the concentration-dependent expression for electron lifetime.
 165   PetscScalar EN;            // The exponent in the concentration-dependent expression for electron lifetime.
 166   PetscScalar NSRHP;            // The Shockley-Read-Hall concentration parameter for holes.
 167   PetscScalar AP;            // The constant term in the concentration-dependent expression for hole lifetime.
 168   PetscScalar BP;            // The linear term coefficient in the concentration-dependent expression for hole lifetime.
 169   PetscScalar CP;            // The exponential term coefficient in the concentration-dependent expression for hole lifetime.
 170   PetscScalar EP;            // The exponent in the concentration-dependent expression for hole lifetime.
 171   // Lattice Temperature-Dependent Lifetimes
 172   PetscScalar EXN_TAU;       // The exponent of lattice temperature dependent electron lifetime.
 173   PetscScalar EXP_TAU;       // The exponent of lattice temperature dependent hole lifetime.
 174
 175   //Init value
 176   void Lifetime_Init()
 177   {
 178     TAUN0     = 1.000000e-09*s;
 179     TAUP0     = 1.000000e-09*s;
 180     SurfTauN  = 0.000000e+00*cm/s;
 181     SurfTauP  = 0.000000e+00*cm/s;
 182     NSRHN     = 5.000000e+16*pow(cm,-3);
 183     AN        = 1.000000e+00;
 184     BN        = 0.000000e+00;
 185     CN        = 0.000000e+00;
 186     EN        = 2.000000e+00;
 187     NSRHP     = 5.000000e+16*pow(cm,-3);
 188     AP        = 1.000000e+00;
 189     BP        = 0.000000e+00;
 190     CP        = 0.000000e+00;
 191     EP        = 2.000000e+00;
 192     EXN_TAU   = 0.000000e+00;
 193     EXP_TAU   = 0.000000e+00;
 194   }
 195
 196 public:
 197   //---------------------------------------------------------------------------
 198   // electron lift time for SHR Recombination
 199   PetscScalar TAUN (const PetscScalar &Tl)
 200   {
 201     PetscScalar Na = ReadDopingNa();
 202     PetscScalar Nd = ReadDopingNd();
 203     return TAUN0/(1+(Na+Nd)/NSRHN)*pow(Tl/T300,EXN_TAU);
 204   }
 205   AutoDScalar TAUN (const AutoDScalar &Tl)
 206   {
 207     PetscScalar Na = ReadDopingNa();
 208     PetscScalar Nd = ReadDopingNd();
 209     return TAUN0/(1+(Na+Nd)/NSRHN)*pow(Tl/T300,EXN_TAU);
 210   }
 211
 212   //---------------------------------------------------------------------------
 213   // hole lift time for SHR Recombination
 214   PetscScalar TAUP (const PetscScalar &Tl)
 215   {
 216     PetscScalar Na = ReadDopingNa();
 217     PetscScalar Nd = ReadDopingNd();
 218     return TAUP0/(1+(Na+Nd)/NSRHP)*pow(Tl/T300,EXP_TAU);
 219   }
 220   AutoDScalar TAUP (const AutoDScalar &Tl)
 221   {
 222     PetscScalar Na = ReadDopingNa();
 223     PetscScalar Nd = ReadDopingNd();
 224     return TAUP0/(1+(Na+Nd)/NSRHP)*pow(Tl/T300,EXP_TAU);
 225   }
 226   // End of Lifetime
 227
 228 private:
 229   //[Recombination]
 230   // SRH, Auger, and Direct Recombination
 231   PetscScalar ETRAP;         // The trap level (Et - Ei) used in determining the Shockley-Read-Hall recombination rate.
 232   PetscScalar AUGN;          // The Auger coefficient for electrons.
 233   PetscScalar AUGP;          // The Auger coefficient for holes.
 234   PetscScalar C_DIRECT;      // The band-to-band recombination coefficient.
 235   // Recombination Including Tunneling
 236   PetscScalar M_RTUN;        // The trap-assisted tunneling effective mass. *free electron rest mass m0
 237   PetscScalar S_RTUN;        // Band-to-band field power ratio.
 238   PetscScalar B_RTUN;        // Band-to-band tunneling rate proportionality factor.
 239   PetscScalar E_RTUN;        // Band-to-band reference electric field.
 240
 241   // Init value
 242   void Recomb_Init()
 243   {
 244     ETRAP   =  0.000000e+00*eV;
 245     AUGN    =  0.000000e+00*pow(cm,6)/s;
 246     AUGP    =  0.000000e+00*pow(cm,6)/s;
 247     C_DIRECT = 2.000000e-10*pow(cm,3)/s;
 248     M_RTUN   = 2.500000e-01;
 249     S_RTUN   = 2.000000e+00;
 250     B_RTUN   = 0.000000e+00*pow(cm,S_RTUN -3)*pow(V,S_RTUN*-1)/s;
 251     E_RTUN   = 0.000000e+00*V/cm;
 252   }
 253
 254 public:
 255   //---------------------------------------------------------------------------
 256   // Direct Recombination
 257   PetscScalar R_Direct     (const PetscScalar &p, const PetscScalar &n, const PetscScalar &Tl)
 258   {
 259     PetscScalar ni =   nie(Tl);
 260     return C_DIRECT*(n*p-ni*ni);
 261   }
 262   AutoDScalar R_Direct     (const AutoDScalar &p, const AutoDScalar &n, const AutoDScalar &Tl)
 263   {
 264     AutoDScalar ni =   nie(Tl);
 265     return C_DIRECT*(n*p-ni*ni);
 266   }
 267
 268   //---------------------------------------------------------------------------
 269   // Auger Recombination
 270   PetscScalar R_Auger     (const PetscScalar &p, const PetscScalar &n, const PetscScalar &Tl)
 271   {
 272     PetscScalar ni =   nie(Tl);
 273     return AUGN*(p*n*n-n*ni*ni)+AUGP*(n*p*p-p*ni*ni);
 274   }
 275   AutoDScalar R_Auger     (const AutoDScalar &p, const AutoDScalar &n, const AutoDScalar &Tl)
 276   {
 277     AutoDScalar ni =   nie(Tl);
 278     return AUGN*(p*n*n-n*ni*ni)+AUGP*(n*p*p-p*ni*ni);
 279   }
 280
 281   //---------------------------------------------------------------------------
 282   // SHR Recombination
 283   PetscScalar R_SHR     (const PetscScalar &p, const PetscScalar &n, const PetscScalar &Tl)
 284   {
 285     PetscScalar ni =   nie(Tl);
 286     PetscScalar taun = TAUN(Tl);
 287     PetscScalar taup = TAUP(Tl);
 288     return (p*n-ni*ni)/(taup*(n+ni)+taun*(p+ni));
 289   }
 290   AutoDScalar R_SHR     (const AutoDScalar &p, const AutoDScalar &n, const AutoDScalar &Tl)
 291   {
 292     AutoDScalar ni =   nie(Tl);
 293     AutoDScalar taun = TAUN(Tl);
 294     AutoDScalar taup = TAUP(Tl);
 295     return (p*n-ni*ni)/(taup*(n+ni)+taun*(p+ni));
 296   }
 297
 298   //---------------------------------------------------------------------------
 299   // Surface SHR Recombination
 300   PetscScalar R_Surf     (const PetscScalar &p, const PetscScalar &n, const PetscScalar &Tl, const PetscScalar &reciprocal_len)
 301   {
 302     PetscScalar ni =   nie(Tl);
 303     PetscScalar taun = TAUN(Tl);
 304     PetscScalar taup = TAUP(Tl);
 305     taun = 1.0/(SurfTauN*reciprocal_len + 1.0/taun);
 306     taup = 1.0/(SurfTauP*reciprocal_len + 1.0/taup);
 307     return (p*n-ni*ni)/(taup*(n+ni)+taun*(p+ni));
 308   }
 309   AutoDScalar R_Surf     (const AutoDScalar &p, const AutoDScalar &n, const AutoDScalar &Tl, const PetscScalar &reciprocal_len)
 310   {
 311     AutoDScalar ni =   nie(Tl);
 312     AutoDScalar taun = TAUN(Tl);
 313     AutoDScalar taup = TAUP(Tl);
 314     taun = 1.0/(SurfTauN*reciprocal_len + 1.0/taun);
 315     taup = 1.0/(SurfTauP*reciprocal_len + 1.0/taup);
 316     return (p*n-ni*ni)/(taup*(n+ni)+taun*(p+ni));
 317   }
 318
 319   //---------------------------------------------------------------------------
 320   // total Recombination
 321   PetscScalar Recomb (const PetscScalar &p, const PetscScalar &n, const PetscScalar &Tl)
 322   {
 323     PetscScalar ni =   nie(Tl);
 324     PetscScalar taun = TAUN(Tl);
 325     PetscScalar taup = TAUP(Tl);
 326     PetscScalar dn   = p*n-ni*ni;
 327     PetscScalar Rshr = dn/(taup*(n+ni)+taun*(p+ni));
 328     PetscScalar Rdir = C_DIRECT*dn;
 329     PetscScalar Raug = (AUGN*n+AUGP*p)*dn;
 330     return Rshr+Rdir+Raug;
 331   }
 332   AutoDScalar Recomb (const AutoDScalar &p, const AutoDScalar &n, const AutoDScalar &Tl)
 333   {
 334     AutoDScalar ni =   nie(Tl);
 335     AutoDScalar taun = TAUN(Tl);
 336     AutoDScalar taup = TAUP(Tl);
 337     AutoDScalar dn   = p*n-ni*ni;
 338     AutoDScalar Rshr = dn/(taup*(n+ni)+taun*(p+ni));
 339     AutoDScalar Rdir = C_DIRECT*dn;
 340     AutoDScalar Raug = (AUGN*n+AUGP*p)*dn;
 341     return Rshr+Rdir+Raug;
 342   }
 343   // End of Recombination
 344 private:
 345   //[energy relax time]
 346   PetscScalar  WTN0;
 347   PetscScalar  WTN1;
 348   PetscScalar  WTN2;
 349   PetscScalar  WTN3;
 350   PetscScalar  WTN4;
 351   PetscScalar  WTN5;
 352   PetscScalar  WTNL;
 353   PetscScalar  TNL;
 354   PetscScalar  WTP0;
 355   PetscScalar  WTP1;
 356   PetscScalar  WTP2;
 357   PetscScalar  WTP3;
 358   PetscScalar  WTP4;
 359   PetscScalar  WTP5;
 360   PetscScalar  WTPL;
 361   PetscScalar  TPL;
 362   // Init value
 363   void RelaxTime_Init()
 364   {
 365    WTN0 =  2.400000E-12*s;
 366    WTN1 =  4.000000E-13*s;
 367    WTN2 =  0.000000E+00*s;
 368    WTN3 =  0.000000E+00*s;
 369    WTN4 =  0.000000E+00*s;
 370    WTN5 =  0.000000E+00*s;
 371    WTNL =  6.800000E-13*s;
 372    TNL  =  1.866270E+03*K;
 373    WTP0 =  0.000000E+00*s;
 374    WTP1 =  0.000000E+00*s;
 375    WTP2 =  0.000000E+00*s;
 376    WTP3 =  0.000000E+00*s;
 377    WTP4 =  0.000000E+00*s;
 378    WTP5 =  0.000000E+00*s;
 379    WTPL =  1.000000E-12*s;
 380    TPL  =  0.000000E+00*K;
 381   }
 382 public:
 383   //---------------------------------------------------------------------------
 384   // Electron relaxation time for EBM
 385   PetscScalar ElecEnergyRelaxTime(const PetscScalar &Tn,const PetscScalar &Tl)
 386   {
 387     PetscScalar r = (Tn-Tl)/TNL;
 388     return WTN1+(WTN0-WTN1)*r*r*exp(2-2*r);
 389   }
 390   AutoDScalar ElecEnergyRelaxTime(const AutoDScalar &Tn,const AutoDScalar &Tl)
 391   {
 392     AutoDScalar r = (Tn-Tl)/TNL;
 393     return WTN1+(WTN0-WTN1)*r*r*exp(2-2*r);
 394   }
 395
 396   //---------------------------------------------------------------------------
 397   // Hole relaxation time for EBM
 398   PetscScalar HoleEnergyRelaxTime(const PetscScalar &Tp,const PetscScalar &Tl)
 399   {
 400     return WTPL;
 401   }
 402   AutoDScalar HoleEnergyRelaxTime(const AutoDScalar &Tp,const AutoDScalar &Tl)
 403   {
 404     return WTPL;
 405   }
 406   // end of energy relax time
 407
 408 private:
 409   // [Schottky]
 410   PetscScalar ARICHN;
 411   PetscScalar ARICHP;
 412   PetscScalar VSURFN;   // Thermionic emission velocity of electron
 413   PetscScalar VSURFP;
 414   void   Schottky_Init()
 415   {
 416     ARICHN = 6.285700e+00*A/(K*cm)/(K*cm);
 417     ARICHP = 1.050000e+02*A/(K*cm)/(K*cm);
 418   }
 419 public:
 420   PetscScalar SchottyJsn (PetscScalar n,PetscScalar Tl,PetscScalar Vb)
 421   {
 422     PetscScalar VSURFN = ARICHN*Tl*Tl/(e*Nc(Tl));
 423     PetscScalar nb = Nc(Tl)*exp(-e*Vb/(kb*Tl));
 424     return -e*VSURFN*(n-nb);
 425   }
 426   PetscScalar SchottyJsp (PetscScalar p,PetscScalar Tl,PetscScalar Vb)
 427   {
 428     PetscScalar VSURFP = ARICHP*Tl*Tl/(e*Nv(Tl));
 429     PetscScalar pb = Nv(Tl)*exp((-Eg(Tl)+e*Vb)/(kb*Tl));
 430     return e*VSURFP*(p-pb);
 431   }
 432   PetscScalar SchottyBarrierLowerring (PetscScalar eps, PetscScalar E)
 433   {
 434     return sqrt(e/(4*3.1415926535*eps)*E);
 435   }
 436   PetscScalar pdSchottyJsn_pdn(PetscScalar n,PetscScalar Tl,PetscScalar Vb)
 437   {
 438     PetscScalar VSURFN = ARICHN*Tl*Tl/(e*Nc(Tl));
 439     return -e*VSURFN;
 440   }
 441   PetscScalar pdSchottyJsp_pdp(PetscScalar p,PetscScalar Tl,PetscScalar Vb)
 442   {
 443     PetscScalar VSURFP = ARICHP*Tl*Tl/(e*Nv(Tl));
 444     return e*VSURFP;
 445   }
 446   PetscScalar pdSchottyJsn_pdTl(PetscScalar n,PetscScalar Tl,PetscScalar Vb)
 447   {
 448     //use finite difference approximate
 449     PetscScalar dJ = SchottyJsn(n,Tl,Vb)-SchottyJsn(n,(1-1e-10)*Tl,Vb);
 450     return dJ/(1e-10*Tl);
 451   }
 452   PetscScalar pdSchottyJsp_pdTl(PetscScalar p,PetscScalar Tl,PetscScalar Vb)
 453   {
 454     //use finite difference approximate
 455     PetscScalar dJ = SchottyJsp(p,Tl,Vb)-SchottyJsp(p,(1-1e-10)*Tl,Vb);
 456     return dJ/(1e-10*Tl);
 457   }
 458
 459   PetscScalar ThermalVn (PetscScalar Tl)
 460   {
 461         return sqrt(kb*Tl/(2*3.14159265359*EffecElecMass(Tl)));
 462   }
 463   PetscScalar ThermalVp (PetscScalar Tl)
 464   {
 465         return sqrt(kb*Tl/(2*3.14159265359*EffecHoleMass(Tl)));
 466   }
 467   PetscScalar pdThermalVn_pdTl (PetscScalar Tl)
 468   {
 469         return 0;
 470   }
 471   PetscScalar pdThermalVp_pdTl (PetscScalar Tl)
 472   {
 473         return 0;
 474   }
 475
 476 private:
 477   // [band to band Tunneling]
 478   PetscScalar  A_BTBT;
 479   PetscScalar  B_BTBT;
 480   void   BBTunneling_Init()
 481   {
 482     A_BTBT = 0*e*sqrt(V)/cm/s/V/V;
 483     B_BTBT = 0*V/cm/pow(e*V,PetscScalar(1.5));
 484   }
 485 public:
 486   //----------------------------------------------------------------
 487   // band to band Tunneling
 488   PetscScalar BB_Tunneling(const PetscScalar &Tl, const PetscScalar &E)
 489   {
 490      return A_BTBT*E*E/sqrt(Eg(Tl))*exp(-B_BTBT*pow(Eg(Tl),PetscScalar(1.5))/(E+1*V/cm));
 491   }
 492   AutoDScalar BB_Tunneling(const AutoDScalar &Tl, const AutoDScalar &E)
 493   {
 494      return A_BTBT*E*E/sqrt(Eg(Tl))*exp(-B_BTBT*pow(Eg(Tl),PetscScalar(1.5))/(E+1*V/cm));
 495   }
 496
 497
 498
 499 // constructor and destructor
 500 public:
 501   GSS_GaAs_BandStructure(const PMIS_Environment &env):PMIS_BandStructure(env)
 502   {
 503     T300 = 300.0*K;
 504     Eg_Init();
 505     Lifetime_Init();
 506     Recomb_Init();
 507     RelaxTime_Init();
 508     Schottky_Init();
 509     BBTunneling_Init();
 510   }
 511
 512   ~GSS_GaAs_BandStructure()
 513   {}
 514 }
 515 ;
 516
 517
 518 extern "C"
 519 {
 520   PMIS_BandStructure*  PMIS_GaAs_BandStructure_Default (const PMIS_Environment& env)
 521   {
 522     return new GSS_GaAs_BandStructure(env);
 523   }
 524 }