src/material/SiGe/SiGe_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: Si(1-x)Ge(x).
  23
  24
  25 #include "PMI.h"
  26
  27
  28 class GSS_SiGe_BandStructure : public PMIS_BandStructure
  29 {
  30 private:
  31   PetscScalar T300;
  32   PetscScalar T90;
  33   //[Bandgap]
  34   // Bandgap and Effective Density of States
  35   PetscScalar EGSi300;   // The energy bandgap of the material at 300 K.
  36   PetscScalar EgSi90;
  37   PetscScalar EGALPH;    // The value of alpha used in calculating the temperature depended energy bandgap.
  38   PetscScalar EGBETA;    // The value of beta  used in calculating the temperature depended energy bandgap.
  39   PetscScalar ELECMASS;  // The relative effective mass of electron
  40   PetscScalar HOLEMASS;  // The relative effective mass of hole
  41   PetscScalar NC300;     // The effective density of states in the conduction band at 300K.
  42   PetscScalar NV300;     // The effective density of states in the valence band at 300K.
  43   PetscScalar NC_F;      // The parameter for temperature depended effective density of states in the conduction band.
  44   PetscScalar NV_F;      // The parameter for temperature depended effective density of states in the valence band.
  45   PetscScalar NC_0;         // Parameters for effective density of states of compound semiconductor material
  46   PetscScalar NV_0;
  47   PetscScalar NC_E;
  48   PetscScalar NV_E;
  49   // Model of Bandgap Narrowing due to Heavy Doping
  50   PetscScalar N0_BGN;    // The concentration parameter used in Slotboom's band-gap narrowing model.
  51   PetscScalar V0_BGN;    // The voltage parameter used in Slotboom's band-gap narrowing model.
  52   PetscScalar CON_BGN;   // The const parameter used in Slotboom's band-gap narrowing model.
  53
  54   // Init value
  55   void Eg_Init()
  56   {
  57     EGSi300   = 1.080000e+00*eV;
  58     EGALPH    = 4.730000e-04*eV/K;
  59     EGBETA    = 6.360000e+02*K;
  60     T90       = 90*K;
  61     EgSi90    = EGSi300+EGALPH*(T300*T300/(T300+EGBETA) - T90*T90/(T90+EGBETA));
  62     ELECMASS  = 3.100000E-01*me;
  63     HOLEMASS  = 5.000000E-01*me;
  64     NC300     = 2.800000e+19*pow(cm,-3);
  65     NV300     = 1.040000e+19*pow(cm,-3);
  66     NC_F      = 1.500000e+00;
  67     NV_F      = 1.500000e+00;
  68     NC_0      = 0.000000e+00;
  69     NV_0      = 0.000000e+00;
  70     NC_E      = 0.000000e+00;
  71     NV_E      = 0.000000e+00;
  72     N0_BGN    = 1.000000e+17*pow(cm,-3);
  73     V0_BGN    = 9.000000e-03*V;
  74     CON_BGN   = 5.000000e-01*eV;
  75   }
  76 public:
  77   //---------------------------------------------------------------------------
  78   // procedure of Bandgap
  79   PetscScalar Eg (const PetscScalar &Tl)
  80   {
  81     PetscScalar mole_x = ReadxMoleFraction();
  82     PetscScalar EG90;
  83     if(mole_x<=0.25)
  84         EG90 = EgSi90 - 4.0*(EgSi90-0.950)*mole_x;
  85     else if(mole_x<=0.40)
  86         EG90 = 0.950 -  0.66666*(mole_x-0.25);
  87     else if(mole_x<=0.60)
  88         EG90 = 0.850 - 0.57500*(mole_x-0.40);
  89     else if(mole_x<=0.75)
  90         EG90 = 0.735-0.43333*(mole_x-0.60);
  91     else
  92         EG90 = 0.670;
  93     return EG90+EGALPH*(T90*T90/(T90+EGBETA) - Tl*Tl/(Tl+EGBETA));
  94   }
  95   AutoDScalar Eg (const AutoDScalar &Tl)
  96   {
  97     PetscScalar mole_x = ReadxMoleFraction();
  98     PetscScalar EG90;
  99     if(mole_x<=0.25)
 100         EG90 = EgSi90 - 4.0*(EgSi90-0.950)*mole_x;
 101     else if(mole_x<=0.40)
 102         EG90 = 0.950 -  0.66666*(mole_x-0.25);
 103     else if(mole_x<=0.60)
 104         EG90 = 0.850 - 0.57500*(mole_x-0.40);
 105     else if(mole_x<=0.75)
 106         EG90 = 0.735-0.43333*(mole_x-0.60);
 107     else
 108         EG90 = 0.670;
 109     return EG90+EGALPH*(T90*T90/(T90+EGBETA) - Tl*Tl/(Tl+EGBETA));
 110   }
 111
 112
 113   //---------------------------------------------------------------------------
 114   // procedure of Bandgap Narrowing due to Heavy Doping
 115   PetscScalar EgNarrow(const PetscScalar &Tl)
 116   {
 117     PetscScalar Na = ReadDopingNa();
 118     PetscScalar Nd = ReadDopingNd();
 119     PetscScalar N = Na+Nd+1.0*pow(cm,-3);
 120     PetscScalar x = log(N/N0_BGN);
 121     return V0_BGN*(x+sqrt(x*x+CON_BGN));
 122   }
 123   PetscScalar EgNarrowToEc   (const PetscScalar &Tl){return 0.5*EgNarrow(Tl);}
 124   PetscScalar EgNarrowToEv   (const PetscScalar &Tl){return 0.5*EgNarrow(Tl);}
 125
 126   AutoDScalar EgNarrow(const AutoDScalar &Tl)
 127   {
 128     PetscScalar Na = ReadDopingNa();
 129     PetscScalar Nd = ReadDopingNd();
 130     PetscScalar N = Na+Nd+1.0*pow(cm,-3);
 131     PetscScalar x = log(N/N0_BGN);
 132     return V0_BGN*(x+sqrt(x*x+CON_BGN));
 133   }
 134   AutoDScalar EgNarrowToEc   (const AutoDScalar &Tl){return 0.5*EgNarrow(Tl);}
 135   AutoDScalar EgNarrowToEv   (const AutoDScalar &Tl){return 0.5*EgNarrow(Tl);}
 136
 137
 138   //---------------------------------------------------------------------------
 139   //electron and hole effect mass
 140   PetscScalar EffecElecMass (const PetscScalar &Tl)
 141   {
 142         return ELECMASS;
 143   }
 144   PetscScalar EffecHoleMass (const PetscScalar &Tl)
 145   {
 146         return HOLEMASS;
 147   }
 148
 149
 150   //---------------------------------------------------------------------------
 151   // Nc and Nv
 152   PetscScalar Nc (const PetscScalar &Tl)
 153   {
 154     PetscScalar mole_x = ReadxMoleFraction();
 155     return NC300*pow(Tl/T300,NC_F)*(1+NC_0*(exp(-NC_E*mole_x/(kb*Tl))-1));
 156   }
 157   AutoDScalar Nc (const AutoDScalar &Tl)
 158   {
 159     PetscScalar mole_x = ReadxMoleFraction();
 160     return NC300*pow(Tl/T300,NC_F)*(1+NC_0*(exp(-NC_E*mole_x/(kb*Tl))-1));
 161   }
 162
 163   PetscScalar Nv (const PetscScalar &Tl)
 164   {
 165     PetscScalar mole_x = ReadxMoleFraction();
 166     return NV300*pow(Tl/T300,NV_F)*(1+NV_0*(exp(-NV_E*mole_x/(kb*Tl))-1));
 167   }
 168   AutoDScalar Nv (const AutoDScalar &Tl)
 169   {
 170     PetscScalar mole_x = ReadxMoleFraction();
 171     return NV300*pow(Tl/T300,NV_F)*(1+NV_0*(exp(-NV_E*mole_x/(kb*Tl))-1));
 172   }
 173
 174   //---------------------------------------------------------------------------
 175   // nie, Eg narrow should be considered
 176   PetscScalar nie (const PetscScalar &Tl)
 177   {
 178     PetscScalar bandgap = Eg(Tl);
 179     PetscScalar Nc = NC300*pow(Tl/T300,NC_F);
 180     PetscScalar Nv = NV300*pow(Tl/T300,NV_F);
 181     return sqrt(Nc*Nv)*exp(-bandgap/(2*kb*Tl))*exp(EgNarrow(Tl));
 182   }
 183   AutoDScalar nie (const AutoDScalar &Tl)
 184   {
 185     AutoDScalar bandgap = Eg(Tl);
 186     AutoDScalar Nc = NC300*pow(Tl/T300,NC_F);
 187     AutoDScalar Nv = NV300*pow(Tl/T300,NV_F);
 188     return sqrt(Nc*Nv)*exp(-bandgap/(2*kb*Tl))*exp(EgNarrow(Tl));
 189   }
 190   //end of Bandgap
 191
 192 private:
 193   //[Lifetime]
 194   //Lifetimes
 195   PetscScalar TAUN0;         // The Shockley-Read-Hall electron lifetime.
 196   PetscScalar TAUP0;         // The Shockley-Read-Hall hole lifetime.
 197   PetscScalar SurfTauN;      // The electron surface recombination velocity.
 198   PetscScalar SurfTauP;      // The hole surface recombination velocity.
 199   //Concentration-Dependent Lifetimes
 200   PetscScalar NSRHN;         // The Shockley-Read-Hall concentration parameter for electrons.
 201   PetscScalar AN;            // The constant term in the concentration-dependent expression for electron lifetime.
 202   PetscScalar BN;            // The linear term coefficient in the concentration-dependent expression for electron lifetime.
 203   PetscScalar CN;            // The exponential term coefficient in the concentration-dependent expression for electron lifetime.
 204   PetscScalar EN;            // The exponent in the concentration-dependent expression for electron lifetime.
 205   PetscScalar NSRHP;            // The Shockley-Read-Hall concentration parameter for holes.
 206   PetscScalar AP;            // The constant term in the concentration-dependent expression for hole lifetime.
 207   PetscScalar BP;            // The linear term coefficient in the concentration-dependent expression for hole lifetime.
 208   PetscScalar CP;            // The exponential term coefficient in the concentration-dependent expression for hole lifetime.
 209   PetscScalar EP;            // The exponent in the concentration-dependent expression for hole lifetime.
 210   // Lattice Temperature-Dependent Lifetimes
 211   PetscScalar EXN_TAU;       // The exponent of lattice temperature dependent electron lifetime.
 212   PetscScalar EXP_TAU;       // The exponent of lattice temperature dependent hole lifetime.
 213
 214   //Init value
 215   void Lifetime_Init()
 216   {
 217     TAUN0     = 1.000000e-07*s;
 218     TAUP0     = 1.000000e-07*s;
 219     SurfTauN  = 0.000000e+00*cm/s;
 220     SurfTauP  = 0.000000e+00*cm/s;
 221     NSRHN     = 5.000000e+16*pow(cm,-3);
 222     AN        = 1.000000e+00;
 223     BN        = 1.000000e+00;
 224     CN        = 0.000000e+00;
 225     EN        = 2.000000e+00;
 226     NSRHP     = 5.000000e+16*pow(cm,-3);
 227     AP        = 1.000000e+00;
 228     BP        = 1.000000e+00;
 229     CP        = 0.000000e+00;
 230     EP        = 2.000000e+00;
 231     EXN_TAU   = 0.000000e+00;
 232     EXP_TAU   = 0.000000e+00;
 233   }
 234
 235 public:
 236   //---------------------------------------------------------------------------
 237   // electron lift time for SHR Recombination
 238   PetscScalar TAUN (const PetscScalar &Tl)
 239   {
 240     PetscScalar Na = ReadDopingNa();
 241     PetscScalar Nd = ReadDopingNd();
 242     return TAUN0/(1+(Na+Nd)/NSRHN)*pow(Tl/T300,EXN_TAU);
 243   }
 244   AutoDScalar TAUN (const AutoDScalar &Tl)
 245   {
 246     PetscScalar Na = ReadDopingNa();
 247     PetscScalar Nd = ReadDopingNd();
 248     return TAUN0/(1+(Na+Nd)/NSRHN)*pow(Tl/T300,EXN_TAU);
 249   }
 250
 251   //---------------------------------------------------------------------------
 252   // hole lift time for SHR Recombination
 253   PetscScalar TAUP (const PetscScalar &Tl)
 254   {
 255     PetscScalar Na = ReadDopingNa();
 256     PetscScalar Nd = ReadDopingNd();
 257     return TAUP0/(1+(Na+Nd)/NSRHP)*pow(Tl/T300,EXP_TAU);
 258   }
 259   AutoDScalar TAUP (const AutoDScalar &Tl)
 260   {
 261     PetscScalar Na = ReadDopingNa();
 262     PetscScalar Nd = ReadDopingNd();
 263     return TAUP0/(1+(Na+Nd)/NSRHP)*pow(Tl/T300,EXP_TAU);
 264   }
 265   // End of Lifetime
 266
 267   //[the fit parameter for density-gradient solver]
 268   PetscScalar Gamman         () {return 3.6;}
 269   PetscScalar Gammap         () {return 5.6;}
 270
 271 private:
 272   //[Recombination]
 273   // SRH, Auger, and Direct Recombination
 274   PetscScalar ETRAP;         // The trap level (Et - Ei) used in determining the Shockley-Read-Hall recombination rate.
 275   PetscScalar AUGN;          // The Auger coefficient for electrons.
 276   PetscScalar AUGP;          // The Auger coefficient for holes.
 277   PetscScalar C_DIRECT;      // The band-to-band recombination coefficient.
 278   // Recombination Including Tunneling
 279   PetscScalar M_RTUN;        // The trap-assisted tunneling effective mass. *free electron rest mass m0
 280   PetscScalar S_RTUN;        // Band-to-band field power ratio.
 281   PetscScalar B_RTUN;        // Band-to-band tunneling rate proportionality factor.
 282   PetscScalar E_RTUN;        // Band-to-band reference electric field.
 283
 284   // Init value
 285   void Recomb_Init()
 286   {
 287     ETRAP   = 0.000000e+00*eV;
 288     AUGN    =  2.800000e-31*pow(cm,6)/s;
 289     AUGP    =  9.900000e-32*pow(cm,6)/s;
 290     C_DIRECT = 0.000000e+00*pow(cm,3)/s;
 291     M_RTUN   = 2.500000e-01;
 292     S_RTUN   = 2.500000e+00;
 293     B_RTUN   = 4.000000e+14*pow(cm,S_RTUN -3)*pow(V,S_RTUN*-1)/s;
 294     E_RTUN   = 1.900000e+07*V/cm;
 295   }
 296
 297 public:
 298   //---------------------------------------------------------------------------
 299   // Direct Recombination
 300   PetscScalar R_Direct     (const PetscScalar &p, const PetscScalar &n, const PetscScalar &Tl)
 301   {
 302     PetscScalar ni =   nie(Tl);
 303     return C_DIRECT*(n*p-ni*ni);
 304   }
 305   AutoDScalar R_Direct     (const AutoDScalar &p, const AutoDScalar &n, const AutoDScalar &Tl)
 306   {
 307     AutoDScalar ni =   nie(Tl);
 308     return C_DIRECT*(n*p-ni*ni);
 309   }
 310
 311   //---------------------------------------------------------------------------
 312   // Auger Recombination
 313   PetscScalar R_Auger     (const PetscScalar &p, const PetscScalar &n, const PetscScalar &Tl)
 314   {
 315     PetscScalar ni =   nie(Tl);
 316     return AUGN*(p*n*n-n*ni*ni)+AUGP*(n*p*p-p*ni*ni);
 317   }
 318   AutoDScalar R_Auger     (const AutoDScalar &p, const AutoDScalar &n, const AutoDScalar &Tl)
 319   {
 320     AutoDScalar ni =   nie(Tl);
 321     return AUGN*(p*n*n-n*ni*ni)+AUGP*(n*p*p-p*ni*ni);
 322   }
 323
 324   //---------------------------------------------------------------------------
 325   // SHR Recombination
 326   PetscScalar R_SHR     (const PetscScalar &p, const PetscScalar &n, const PetscScalar &Tl)
 327   {
 328     PetscScalar ni =   nie(Tl);
 329     PetscScalar taun = TAUN(Tl);
 330     PetscScalar taup = TAUP(Tl);
 331     return (p*n-ni*ni)/(taup*(n+ni)+taun*(p+ni));
 332   }
 333   AutoDScalar R_SHR     (const AutoDScalar &p, const AutoDScalar &n, const AutoDScalar &Tl)
 334   {
 335     AutoDScalar ni =   nie(Tl);
 336     AutoDScalar taun = TAUN(Tl);
 337     AutoDScalar taup = TAUP(Tl);
 338     return (p*n-ni*ni)/(taup*(n+ni)+taun*(p+ni));
 339   }
 340
 341   //---------------------------------------------------------------------------
 342   // Surface SHR Recombination
 343   PetscScalar R_Surf     (const PetscScalar &p, const PetscScalar &n, const PetscScalar &Tl, const PetscScalar &reciprocal_len)
 344   {
 345     PetscScalar ni =   nie(Tl);
 346     PetscScalar taun = TAUN(Tl);
 347     PetscScalar taup = TAUP(Tl);
 348     taun = 1.0/(SurfTauN*reciprocal_len + 1.0/taun);
 349     taup = 1.0/(SurfTauP*reciprocal_len + 1.0/taup);
 350     return (p*n-ni*ni)/(taup*(n+ni)+taun*(p+ni));
 351   }
 352   AutoDScalar R_Surf     (const AutoDScalar &p, const AutoDScalar &n, const AutoDScalar &Tl, const PetscScalar &reciprocal_len)
 353   {
 354     AutoDScalar ni =   nie(Tl);
 355     AutoDScalar taun = TAUN(Tl);
 356     AutoDScalar taup = TAUP(Tl);
 357     taun = 1.0/(SurfTauN*reciprocal_len + 1.0/taun);
 358     taup = 1.0/(SurfTauP*reciprocal_len + 1.0/taup);
 359     return (p*n-ni*ni)/(taup*(n+ni)+taun*(p+ni));
 360   }
 361
 362   //---------------------------------------------------------------------------
 363   // total Recombination
 364   PetscScalar Recomb (const PetscScalar &p, const PetscScalar &n, const PetscScalar &Tl)
 365   {
 366     PetscScalar ni =   nie(Tl);
 367     PetscScalar taun = TAUN(Tl);
 368     PetscScalar taup = TAUP(Tl);
 369     PetscScalar dn   = p*n-ni*ni;
 370     PetscScalar Rshr = dn/(taup*(n+ni)+taun*(p+ni));
 371     PetscScalar Rdir = C_DIRECT*dn;
 372     PetscScalar Raug = (AUGN*n+AUGP*p)*dn;
 373     return Rshr+Rdir+Raug;
 374   }
 375   AutoDScalar Recomb (const AutoDScalar &p, const AutoDScalar &n, const AutoDScalar &Tl)
 376   {
 377     AutoDScalar ni =   nie(Tl);
 378     AutoDScalar taun = TAUN(Tl);
 379     AutoDScalar taup = TAUP(Tl);
 380     AutoDScalar dn   = p*n-ni*ni;
 381     AutoDScalar Rshr = dn/(taup*(n+ni)+taun*(p+ni));
 382     AutoDScalar Rdir = C_DIRECT*dn;
 383     AutoDScalar Raug = (AUGN*n+AUGP*p)*dn;
 384     return Rshr+Rdir+Raug;
 385   }
 386
 387   // End of Recombination
 388
 389 private:
 390   //[energy relax time]
 391   PetscScalar  WTN0;
 392   PetscScalar  WTN1;
 393   PetscScalar  WTN2;
 394   PetscScalar  WTN3;
 395   PetscScalar  WTN4;
 396   PetscScalar  WTN5;
 397   PetscScalar  WTNL;
 398   PetscScalar  TNL;
 399   PetscScalar  WTP0;
 400   PetscScalar  WTP1;
 401   PetscScalar  WTP2;
 402   PetscScalar  WTP3;
 403   PetscScalar  WTP4;
 404   PetscScalar  WTP5;
 405   PetscScalar  WTPL;
 406   PetscScalar  TPL;
 407   // Init value
 408   void RelaxTime_Init()
 409   {
 410    WTN0 =  1.685200E-13*s;
 411    WTN1 =  1.029900E-13*s;
 412    WTN2 = -5.184500E-15*s;
 413    WTN3 =  0.000000E+00*s;
 414    WTN4 =  0.000000E+00*s;
 415    WTN5 =  0.000000E+00*s;
 416    WTNL =  6.800000E-13*s;
 417    TNL  =  2.979800E+03*K;
 418    WTP0 = -1.560000E-14*s;
 419    WTP1 =  1.380000E-13*s;
 420    WTP2 = -2.500000E-14*s;
 421    WTP3 =  2.310000E-15*s;
 422    WTP4 = -1.050000E-16*s;
 423    WTP5 =  1.820000E-18*s;
 424    WTPL =  2.000000E-13*s;
 425    TPL  =  1.000000E+05*K;
 426   }
 427 public:
 428   //---------------------------------------------------------------------------
 429   // Electron relaxation time for EBM
 430   PetscScalar ElecEnergyRelaxTime(const PetscScalar &Tn,const PetscScalar &Tl)
 431   {
 432     if(Tn>TNL)     return WTNL;
 433     PetscScalar x = 1+(Tn-Tl)/T300;
 434     return WTN0+ WTN1*x + WTN2*x*x;
 435   }
 436   AutoDScalar ElecEnergyRelaxTime(const AutoDScalar &Tn,const AutoDScalar &Tl)
 437   {
 438     if(Tn>TNL)     return WTNL;
 439     AutoDScalar x = 1+(Tn-Tl)/T300;
 440     return WTN0+ WTN1*x + WTN2*x*x;
 441   }
 442
 443   //---------------------------------------------------------------------------
 444   // Hole relaxation time for EBM
 445   PetscScalar HoleEnergyRelaxTime(const PetscScalar &Tp,const PetscScalar &Tl)
 446   {
 447     if(Tp>TPL)     return WTPL;
 448     PetscScalar x = 1+(Tp-Tl)/T300;
 449     return WTP0+ WTP1*x + WTP2*x*x + WTP3*x*x*x + WTP4*pow(x,4) + WTP5*pow(x,5);
 450   }
 451   AutoDScalar HoleEnergyRelaxTime(const AutoDScalar &Tp,const AutoDScalar &Tl)
 452   {
 453     if(Tp>TPL)     return WTPL;
 454     AutoDScalar x = 1+(Tp-Tl)/T300;
 455     return WTP0+ WTP1*x + WTP2*x*x + WTP3*x*x*x + WTP4*pow(x,4) + WTP5*pow(x,5);
 456   }
 457
 458   // end of energy relax time
 459
 460 private:
 461   // [Schottky]
 462   PetscScalar ARICHN;
 463   PetscScalar ARICHP;
 464   PetscScalar VSURFN;   // Thermionic emission velocity of electron
 465   PetscScalar VSURFP;
 466
 467   void   Schottky_Init()
 468   {
 469     ARICHN = 1.100000e+02*A/(K*cm)/(K*cm);
 470     ARICHP = 3.000000e+01*A/(K*cm)/(K*cm);
 471   }
 472 public:
 473   PetscScalar SchottyJsn (PetscScalar n,PetscScalar Tl,PetscScalar Vb)
 474   {
 475     PetscScalar VSURFN = ARICHN*Tl*Tl/(e*Nc(Tl));
 476     PetscScalar nb = Nc(Tl)*exp(-e*Vb/(kb*Tl));
 477     return -e*VSURFN*(n-nb);
 478   }
 479   PetscScalar SchottyJsp (PetscScalar p,PetscScalar Tl,PetscScalar Vb)
 480   {
 481     PetscScalar VSURFP = ARICHP*Tl*Tl/(e*Nv(Tl));
 482     PetscScalar pb = Nv(Tl)*exp((-Eg(Tl)+e*Vb)/(kb*Tl));
 483     return e*VSURFP*(p-pb);
 484   }
 485   PetscScalar SchottyBarrierLowerring (PetscScalar eps, PetscScalar E)
 486   {
 487     return sqrt(e/(4*3.1415926535*eps)*E);
 488   }
 489   PetscScalar pdSchottyJsn_pdn(PetscScalar n,PetscScalar Tl,PetscScalar Vb)
 490   {
 491     PetscScalar VSURFN = ARICHN*Tl*Tl/(e*Nc(Tl));
 492     return -e*VSURFN;
 493   }
 494   PetscScalar pdSchottyJsp_pdp(PetscScalar p,PetscScalar Tl,PetscScalar Vb)
 495   {
 496     PetscScalar VSURFP = ARICHP*Tl*Tl/(e*Nv(Tl));
 497     return e*VSURFP;
 498   }
 499   PetscScalar pdSchottyJsn_pdTl(PetscScalar n,PetscScalar Tl,PetscScalar Vb)
 500   {
 501     //use finite difference approximate
 502     PetscScalar dJ = SchottyJsn(n,Tl,Vb)-SchottyJsn(n,(1-1e-10)*Tl,Vb);
 503     return dJ/(1e-10*Tl);
 504   }
 505   PetscScalar pdSchottyJsp_pdTl(PetscScalar p,PetscScalar Tl,PetscScalar Vb)
 506   {
 507     //use finite difference approximate
 508     PetscScalar dJ = SchottyJsp(p,Tl,Vb)-SchottyJsp(p,(1-1e-10)*Tl,Vb);
 509     return dJ/(1e-10*Tl);
 510   }
 511
 512   PetscScalar ThermalVn (PetscScalar Tl)
 513   {
 514         return sqrt(kb*Tl/(2*3.14159265359*EffecElecMass(Tl)));
 515   }
 516   PetscScalar ThermalVp (PetscScalar Tl)
 517   {
 518         return sqrt(kb*Tl/(2*3.14159265359*EffecHoleMass(Tl)));
 519   }
 520   PetscScalar pdThermalVn_pdTl (PetscScalar Tl)
 521   {
 522         return 0;
 523   }
 524   PetscScalar pdThermalVp_pdTl (PetscScalar Tl)
 525   {
 526         return 0;
 527   }
 528
 529 private:
 530   // [band to band Tunneling]
 531   PetscScalar  A_BTBT;
 532   PetscScalar  B_BTBT;
 533   void   BBTunneling_Init()
 534   {
 535     A_BTBT = 3.500000E+21*e*sqrt(V)/cm/s/V/V;
 536     B_BTBT = 2.250000E+07*V/cm/pow(e*V,PetscScalar(1.5));
 537   }
 538 public:
 539   //----------------------------------------------------------------
 540   // band to band Tunneling
 541   PetscScalar BB_Tunneling(const PetscScalar &Tl, const PetscScalar &E)
 542   {
 543      return A_BTBT*E*E/sqrt(Eg(Tl))*exp(-B_BTBT*pow(Eg(Tl),PetscScalar(1.5))/(E+1*V/cm));
 544   }
 545   AutoDScalar BB_Tunneling(const AutoDScalar &Tl, const AutoDScalar &E)
 546   {
 547      return A_BTBT*E*E/sqrt(Eg(Tl))*exp(-B_BTBT*pow(Eg(Tl),PetscScalar(1.5))/(E+1*V/cm));
 548   }
 549
 550 // constructor and destructor
 551 public:
 552   GSS_SiGe_BandStructure(const PMIS_Environment &env):PMIS_BandStructure(env)
 553   {
 554     T300 = 300.0*K;
 555     Eg_Init();
 556     Lifetime_Init();
 557     Recomb_Init();
 558     RelaxTime_Init();
 559     Schottky_Init();
 560     BBTunneling_Init();
 561   }
 562
 563   ~GSS_SiGe_BandStructure()
 564   {}
 565 }
 566 ;
 567
 568
 569 extern "C"
 570 {
 571   PMIS_BandStructure*  PMIS_SiGe_BandStructure_Default (const PMIS_Environment& env)
 572   {
 573     return new GSS_SiGe_BandStructure(env);
 574   }
 575 }