Xyce  6.1
N_DEV_MaterialSupport.C
Go to the documentation of this file.
1 //-----------------------------------------------------------------------------
2 // Copyright Notice
3 //
4 // Copyright 2002 Sandia Corporation. Under the terms
5 // of Contract DE-AC04-94AL85000 with Sandia Corporation, the U.S.
6 // Government retains certain rights in this software.
7 //
8 // Xyce(TM) Parallel Electrical Simulator
9 // Copyright (C) 2002-2015 Sandia Corporation
10 //
11 // This program is free software: you can redistribute it and/or modify
12 // it under the terms of the GNU General Public License as published by
13 // the Free Software Foundation, either version 3 of the License, or
14 // (at your option) any later version.
15 //
16 // This program is distributed in the hope that it will be useful,
17 // but WITHOUT ANY WARRANTY; without even the implied warranty of
18 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 // GNU General Public License for more details.
20 //
21 // You should have received a copy of the GNU General Public License
22 // along with this program. If not, see <http://www.gnu.org/licenses/>.
23 //-----------------------------------------------------------------------------
24 
25 //-------------------------------------------------------------------------
26 // Filename : $RCSfile: N_DEV_MaterialSupport.C,v $
27 //
28 // Purpose :
29 //
30 // Special Notes :
31 //
32 // Creator : Eric R. Keiter, SNL, Parallel Computational Sciences
33 //
34 // Creation Date : 07/19/03
35 //
36 // Revision Information:
37 // ---------------------
38 //
39 // Revision Number: $Revision: 1.43 $
40 //
41 // Revision Date : $Date: 2015/09/01 22:15:04 $
42 //
43 // Current Owner : $Author: erkeite $
44 //-------------------------------------------------------------------------
45 
46 #include <Xyce_config.h>
47 
48 // ---------- Standard Includes ----------
49 #include <iostream>
50 
51 // ---------- Xyce Includes ----------
52 #include <N_DEV_MaterialSupport.h>
53 #include <N_UTL_Math.h>
54 
55 namespace Xyce {
56 namespace Device {
57 
58 // ----------------------------------------------------------------------------
59 // Function : MaterialSupport::getEffectiveMassN
60 // Purpose : returns effective mass for electrons.
61 // Special Notes : Relative to free space mass.
62 //
63 // These are from Appendix 3 of Streetman.
64 //
65 // Scope : public
66 // Creator : Eric R. Keiter, SNL, Parallel Computational Sciences
67 // Creation Date : 7/19/03
68 // ----------------------------------------------------------------------------
69 double MaterialSupport::getEffectiveMassN (const std::string & material)
70 {
71  ExtendedString mater = material;
72  mater.toLower();
73 
74  double mass=0.0;
75 
76  if (mater == "si")
77  {
78  double ml = 0.98; // longitudinal mass
79  double mt = 0.19; // transverse mass
80  mass = pow((ml*mt*mt),1.0/3.0);
81  }
82  else if (mater == "ge" )
83  {
84  double ml = 1.64; // longitudinal mass
85  double mt = 0.082; // transverse mass
86  mass = pow((1.64*0.082*0.082),1.0/3.0);
87  }
88  else if (mater == "gaas")
89  {
90  //mass = 0.067;
91  mass = 6.69935094e-2;
92  }
93  else if (mater=="inalas" || mater=="alinas")
94  {
95  mass = 0.074;
96  //dnco= 0.020;
97  }
98  else if (mater=="ingaas" || mater=="gainas")
99  {
100  mass = 0.041;
101  // dnco= 0.0083;
102  }
103  else if (mater == "ingap")
104  {
105  mass = 0.0179;
106  // dnco = 0.02391;
107  }
108  else if (mater == "inp")
109  {
110  mass = 0.079;
111  // dnco= 0.01734;
112  }
113  else
114  {
115  Report::UserFatal0() << material << " material not recognized.";
116  }
117 
118  return mass;
119 }
120 
121 // ----------------------------------------------------------------------------
122 // Function : MaterialSupport::getEffectiveMassP
123 // Purpose : returns effective mass for holes.
124 // Special Notes : Relative to free space mass.
125 //
126 // These are from Appendix 3 of Streetman.
127 //
128 // Scope : public
129 // Creator : Eric R. Keiter, SNL, Parallel Computational Sciences
130 // Creation Date : 7/19/03
131 // ----------------------------------------------------------------------------
132 double MaterialSupport::getEffectiveMassP (const std::string & material)
133 {
134  ExtendedString mater = material;
135  mater.toLower();
136  double mass=0.0;
137 
138  if (mater == "si")
139  {
140  double mlh = 0.16; // light hole mass
141  double mhh = 0.49; // heavy hole mass
142  mass = pow((pow(mlh,1.5) + pow(mhh,1.5)),2.0/3.0);
143  }
144  else if (mater == "ge" )
145  {
146  double mlh = 0.04; // light hole mass
147  double mhh = 0.28; // heavy hole mass
148  mass = pow((pow(mlh, 1.5) + pow(mhh, 1.5)),2.0/3.0);
149  }
150  else if (mater == "gaas")
151  {
152 #if 1
153  // Note: Wampler's value of dnva = 0.4318
154  // Their SAND report uses a DOS effective mass as: mh*=0.571
155  // Note that the electron effective mass for GaAs seems to be uncontroversial m=0.067
156  // In order to match XPD, and pass historical regression tests, etc, using this number.
157  //mass=0.571;
158  mass=5.71287987e-1;
159 #endif
160 #if 0
161  // These are the original values in this file:
162  // Streetman, Appendix III:
163  // This gives dnva = 0.373684
164  double mlh = 0.074; // light hole mass
165  double mhh = 0.5; // heavy hole mass
166  mass = pow((pow(mlh,1.5) + pow(mhh, 1.5)), 2.0/3.0);
167 #endif
168 #if 0
169  // Websites: http://ecee.colorado.edu/~bart/book/book/chapter2/pdf/ch2_3_7.pdf
170  // http://ecee.colorado.edu/~bart/book/effmass.htm#dosmass
171  // http://www.semiconductors.co.uk/propiiiv5653.htm
172  //
173  // These have been referenced as coming from "Singh, 1993":
174  // Singh J, 1993, "Physics of Semiconductors and Their Heterostructures" (McGraw-Hill)
175  //
176  // This gives dnva = 0.32535
177  double mlh = 0.082; // light hole mass
178  double mhh = 0.45; // heavy hole mass
179  mass = pow((pow(mlh,1.5) + pow(mhh, 1.5)), 2.0/3.0);
180 #endif
181 #if 0
182  // William Liu HBT book:
183  // this gives dnva = 0.51385
184  double mlh = 0.087; // light hole mass
185  double mhh = 0.62; // heavy hole mass
186  mass = pow((pow(mlh,1.5) + pow(mhh, 1.5)), 2.0/3.0);
187 #endif
188  }
189  else if (mater=="inalas" || mater=="alinas")
190  {
191  double mlh = 0.08; // light hole mass
192  double mhh = 0.6; // heavy hole mass
193  mass = pow((pow(mlh,1.5) + pow(mhh, 1.5)), 2.0/3.0);
194  }
195  else if (mater=="ingaas" || mater=="gainas")
196  {
197  double mlh = 0.05; // light hole mass
198  double mhh = 0.54; // heavy hole mass
199  mass = pow((pow(mlh,1.5) + pow(mhh, 1.5)), 2.0/3.0);
200  }
201  else if (mater=="ingap")
202  {
203  // dnva = 0.5423;
204  //mass = 0.665;
205  mass = 6.65007285e-1;
206  }
207  else if (mater == "inp")
208  {
209  double mlh = 0.074; // light hole mass
210  double mhh = 0.5; // heavy hole mass
211  mass = pow((pow(mlh,1.5) + pow(mhh, 1.5)), 2.0/3.0);
212  }
213  else
214  {
215  Report::UserFatal0() << material << " material not recognized.";
216  }
217 
218  return mass;
219 }
220 
221 // ----------------------------------------------------------------------------
222 // Function : MaterialSupport::get_DOS_EffectiveMassN
223 // Purpose : returns effective mass for electrons for density of states
224 // Special Notes : See http://ecee.colorado.edu/~bart/book/effmass.htm#dosmass.
225 //
226 // m_e_dos = Mc^(2/3) * (m_l*m_t*m_t)^(1/3)
227 //
228 // Scope : public
229 // Creator : Eric R. Keiter, SNL
230 // Creation Date :
231 // ----------------------------------------------------------------------------
232 double MaterialSupport::get_DOS_EffectiveMassN (const std::string & material)
233 {
234  ExtendedString mater = material;
235  mater.toLower();
236  double mass;
237 
238  if (mater == "si")
239  {
240  double ml = 0.98; // longitudinal mass
241  double mt = 0.19; // transverse mass
242  double Mc = 6.0; // degeneracy factor (number of equivalent band minimums)
243  mass = pow(Mc,2.0/3.0)*pow((ml*mt*mt),1.0/3.0);
244  // Note, this should evaluate to 1.08.
245  }
246  else if (mater == "ge")
247  {
248  double ml = 1.64; // longitudinal mass
249  double mt = 0.082; // transverse mass
250  double Mc = 4.0; // degeneracy factor
251  mass = pow(Mc,2.0/3.0)*pow((ml*mt*mt),1.0/3.0);
252  // this mass should be around 0.56
253  }
254  else if (mater == "gaas")
255  {
256  mass = 0.067; // GaAs is isotropic
257  }
258  else if (mater=="inalas" || mater=="alinas")
259  {
260  //dnco= 0.020; = mass^(1.5)
261  mass = 0.074;
262  }
263  else if (mater=="ingaas" || mater=="gainas")
264  {
265  // dnco= 0.0083; = mass^(1.5)
266  mass = 0.041;
267  }
268  else if (mater=="ingap")
269  {
270  // dnco = 0.02391;
271  //mass = 0.0179;
272  mass = 8.29952143e-2;
273  }
274  else if (mater == "inp")
275  {
276  mass = 0.079;
277  }
278  else
279  {
280  Report::UserFatal0() << material << " material not recognized.";
281  }
282 
283  return mass;
284 }
285 
286 // ----------------------------------------------------------------------------
287 // Function : MaterialSupport::get_DOS_EffectiveMassP
288 // Purpose : returns effective mass for holes for density of states
289 // Special Notes :
290 //
291 // Scope : public
292 // Creator : Eric R. Keiter, SNL
293 // Creation Date :
294 // ----------------------------------------------------------------------------
295 double MaterialSupport::get_DOS_EffectiveMassP (const std::string & material)
296 {
297  // Unlike for electrons, Mc is not applied to holes, so this is simply
298  // the same as the non-DOS version.
299  return getEffectiveMassP (material);
300 }
301 
302 // ----------------------------------------------------------------------------
303 // Function : MaterialSupport::getNc
304 // Purpose : density of states, conduction band
305 // Special Notes :
306 //
307 // Nc = 2*(2*pi*me*kT/h^2)^(3/2)
308 // = 2*(2*pi*me_DOS*m0*kT/h^2)^(3/2)
309 //
310 // Scope : public
311 // Creator : Eric R. Keiter, SNL, Parallel Computational Sciences
312 // Creation Date : 4/10/2014
313 // ----------------------------------------------------------------------------
314 double MaterialSupport::getNc (const std::string & material, double temp)
315 {
316  double h_planck(CONSTplanck); // Planck's constant (in J-s)
317  double e_mass (CONSTemass); // e- mass in kg.
318  double kb (1.3806488e-23); // boltzmann's constant (J/K)
319  double meDOS = get_DOS_EffectiveMassN(material);
320  double dnbnd0 = 2.0*M_PI*meDOS*e_mass*kb*temp/(h_planck*h_planck);
321  double Nc = 2.0*pow(dnbnd0,1.5)/1.0e6;
322 
323  return Nc;
324 }
325 
326 // ----------------------------------------------------------------------------
327 // Function : MaterialSupport::getNv
328 // Purpose : Density of states, valance band.
329 // Special Notes :
330 //
331 // Nv = 2*(2*pi*mh*kT/h^2)^(3/2)
332 // = 2*(2*pi*mh_DOS*m0*kT/h^2)^(3/2)
333 //
334 // Scope : public
335 // Creator : Eric R. Keiter, SNL, Parallel Computational Sciences
336 // Creation Date : 4/10/2014
337 // ----------------------------------------------------------------------------
338 double MaterialSupport::getNv (const std::string & material, double temp)
339 {
340  double h_planck(CONSTplanck); // Planck's constant (in J-s)
341  double e_mass (CONSTemass); // e- mass in kg.
342  double kb (1.3806488e-23); // boltzmann's constant (J/K)
343  double mhDOS = get_DOS_EffectiveMassP(material);
344  double dnbnd0 = 2.0*M_PI*mhDOS*e_mass*kb*temp/(h_planck*h_planck);
345  double Nv = 2.0*pow(dnbnd0,1.5)/1.0e6;
346 
347  return Nv;
348 }
349 
350 // ----------------------------------------------------------------------------
351 // Function : MaterialSupport::getNi
352 // Purpose : returns intrinsic electron concentration.
353 // Special Notes :
354 // Scope : public
355 // Creator : Eric R. Keiter, SNL, Parallel Computational Sciences
356 // Creation Date : 10/24/12
357 // ----------------------------------------------------------------------------
358 double MaterialSupport::getNi (const std::string & material, double temp)
359 {
360  ExtendedString mater = material;
361  mater.toLower();
362  double ni=0.0;
363  double kbq = 8.6173324e-5; // boltzmann's constant (eV/K)
364  double bg = bandgap(mater,temp);
365  double Nc = getNc(mater,temp);
366  double Nv = getNv(mater,temp);
367  ni = sqrt (Nc * Nv) * exp(-bg/(2.0 * kbq * temp));
368  return ni;
369 }
370 
371 // ----------------------------------------------------------------------------
372 // Function : MaterialSupport::getNi_old
373 // Purpose : returns intrinsic electron concentration.
374 // Special Notes :
375 // Scope : public
376 // Creator : Eric R. Keiter, SNL, Parallel Computational Sciences
377 // Creation Date : 7/19/03
378 // ----------------------------------------------------------------------------
379 double MaterialSupport::getNi_old (const std::string & material, double temp)
380 {
381  ExtendedString mater = material;
382  mater.toLower();
383  double ni=0.0;
384 
385  if (mater == "si")
386  {
387  ni = 4.9e15
388  * pow(getEffectiveMassN(mater)*getEffectiveMassP(mater),0.75)
389  * pow(6.0,0.5) * pow(temp, 1.5) * exp(-bandgap(mater,temp)/
390  (2.0 * 8.6174e-5 * temp));
391  // ni = 1.25e10;
392  }
393  else if (mater == "gaas")
394  {
395  ni = 4.9e15
396  * pow(getEffectiveMassN(mater)*getEffectiveMassP(mater),0.75)
397  * pow(temp, 1.5) * exp(-bandgap(mater,temp)/
398  (2.0 * 8.6174e-5 * temp));
399  }
400  else if (mater == "ge")
401  {
402  ni = 4.9e15
403  * pow(getEffectiveMassN(mater)*getEffectiveMassP(mater),0.75)
404  * 2.0 * pow(temp, 1.5) * exp(-bandgap(mater,temp)/
405  (2.0 * 8.6174e-5 * temp));
406  // ni = 2.5e13;
407  }
408  // for the next several, as they are all III-V materials, I copied the
409  // gaas functions. I *think* this is correct, as I *think* that Mc is
410  // going to be 1.0 for all of these.
411  else if (mater=="inalas" || mater=="alinas") // indium aluminum arsenide
412  {
413  ni = 4.9e15
414  * pow(getEffectiveMassN(mater)*getEffectiveMassP(mater),0.75)
415  * pow(temp, 1.5) * exp(-bandgap(mater,temp)/
416  (2.0 * 8.6174e-5 * temp));
417  }
418  else if (mater=="ingaas" || mater=="gainas") // indium galium arsenide
419  {
420  ni = 4.9e15
421  * pow(getEffectiveMassN(mater)*getEffectiveMassP(mater),0.75)
422  * pow(temp, 1.5) * exp(-bandgap(mater,temp)/
423  (2.0 * 8.6174e-5 * temp));
424  }
425  else if (mater == "inp")
426  {
427  ni = 4.9e15
428  * pow(getEffectiveMassN(mater)*getEffectiveMassP(mater),0.75)
429  * pow(temp, 1.5) * exp(-bandgap(mater,temp)/
430  (2.0 * 8.6174e-5 * temp));
431  }
432  else
433  {
434  std::string msg = "MaterialSupport::getNi: ";
435  msg += material;
436  msg += " material not recognized.\n";
437  N_ERH_ErrorMgr::report( N_ERH_ErrorMgr::DEV_FATAL_0,msg);
438  }
439 
440  return ni;
441 }
442 
443 // ----------------------------------------------------------------------------
444 // Function : MaterialSupport::getRelPerm
445 // Purpose : returns relative permitivity
446 // Special Notes :
447 // Scope : public
448 // Creator : Eric R. Keiter, SNL, Parallel Computational Sciences
449 // Creation Date : 7/19/03
450 // ----------------------------------------------------------------------------
451 double MaterialSupport::getRelPerm (const std::string & material)
452 {
453  ExtendedString mater = material;
454  mater.toLower();
455 
456  double perm;
457  if (mater == "si")
458  {
459  perm = 11.8;
460  }
461  else if (mater == "sio2")
462  {
463  perm = 3.9;
464  }
465  else if (mater == "ge" )
466  {
467  perm = 16.0;
468  }
469  else if (mater == "gaas")
470  {
471  perm = 13.2;
472  }
473  else if (mater=="inalas" || mater=="alinas") // indium aluminum arsenide
474  {
475  perm = 12.5;
476  }
477  else if (mater=="ingaas" || mater=="gainas") // indium galium arsenide
478  {
479  perm = 14.0;
480  }
481  else if (mater == "inp")
482  {
483  perm = 12.6;
484  }
485  else
486  {
487  Report::UserFatal0() << material << " material not recognized.";
488  }
489 
490  return perm;
491 }
492 
493 // ----------------------------------------------------------------------------
494 // Function : MaterialSupport::calcRsrh
495 // Purpose : Calculates schockley-read-hall recombination.
496 //
497 // Special Notes : For this function, it shouldn't matter if the variables
498 // are scaled or not.
499 //
500 // The material dependence here comes indirectly, from the
501 // lifetimes, the carrier densities, and Ni, the intrinsic
502 // concentration.
503 //
504 // Scope : public
505 // Creator : Eric R. Keiter, SNL, Parallel Computational Sciences
506 // Creation Date : 6/27/03
507 // ----------------------------------------------------------------------------
509  (const std::string & material, double ni, double n, double p, double tn, double tp)
510 {
511  double Ni = ni;
512  double pn = Ni*Ni;
513 
514  double A = (n*p-pn);
515  double B = (tp*(n+Ni)+tn*(p+Ni));
516 
517  double arg = CONSTMAX_EXP_ARG;
518  if (B >= exp(arg)) B = exp(arg);
519 
520  return (A/B);
521 }
522 
523 // ----------------------------------------------------------------------------
524 // Function : MaterialSupport::pdRsrhN
525 // Purpose : Calculates partial derivatives for schockley-read-hall
526 // recombination, with respect to electron density.
527 //
528 // Special Notes : For this function, it shouldn't matter if the variables
529 // are scaled or not.
530 //
531 // The material dependence here comes indirectly, from the
532 // lifetimes, the carrier densities, and Ni, the intrinsic
533 // concentration.
534 //
535 // Scope : public
536 // Creator : Eric R. Keiter, SNL, Parallel Computational Sciences
537 // Creation Date : 7/19/03
538 // ----------------------------------------------------------------------------
540  (const std::string & material, double ni, double n, double p, double tn, double tp)
541 {
542  double Ni = ni;
543  double pdRsrhN;
544  double A1, B1, C1;
545  double dAdn;
546  double dBdn;
547 
548  double pn = Ni*Ni;
549 
550  double arg = CONSTMAX_EXP_ARG;
551 
552  A1 = (n*p-pn);
553  if (A1 >= exp(arg)) A1 = exp(arg);
554 
555  dAdn = (p);
556 
557  C1 = (tp*(n+Ni)+tn*(p+Ni));
558  if (C1 >= exp(arg)) C1 = exp(arg);
559 
560  B1 = 1.0/C1;
561  dBdn = -1.0/(C1*C1) * tp;
562 
563  pdRsrhN = dAdn * B1 + dBdn * A1;
564 
565  return pdRsrhN;
566 }
567 
568 // ----------------------------------------------------------------------------
569 // Function : MaterialSupport::pdRsrhP
570 // Purpose : Calculates partial derivatives for schockley-read-hall
571 // recombination, with respect to hole density.
572 //
573 // Special Notes : For this function, it shouldn't matter if the variables
574 // are scaled or not.
575 //
576 // The material dependence here comes indirectly, from the
577 // lifetimes, the carrier densities, and Ni, the intrinsic
578 // concentration.
579 //
580 // Scope : public
581 // Creator : Eric R. Keiter, SNL, Parallel Computational Sciences
582 // Creation Date : 7/19/03
583 // ----------------------------------------------------------------------------
585  (const std::string & material, double ni, double n, double p, double tn, double tp)
586 {
587  double Ni = ni;
588  double pdRsrhP;
589  double A1, B1, C1;
590  double dAdp;
591  double dBdp;
592 
593  double pn = Ni*Ni;
594 
595  double arg = CONSTMAX_EXP_ARG;
596 
597  A1 = (n*p-pn);
598  if (A1 >= exp(arg)) A1 = exp(arg);
599 
600  dAdp = (n);
601 
602  C1 = (tp*(n+Ni)+tn*(p+Ni));
603  if (C1 >= exp(arg)) C1 = exp(arg);
604 
605  B1 = 1.0/C1;
606  dBdp = -1.0/(C1*C1) * tn;
607 
608  pdRsrhP = dAdp * B1 + dBdp * A1;
609 
610  return pdRsrhP;
611 }
612 
613 
614 // ----------------------------------------------------------------------------
615 // Function : MaterialSupport::calcRaug
616 // Purpose : Calculates Auger recombination.
617 //
618 // Special Notes : For this function, it shouldn't matter if the variables
619 // are scaled or not.
620 //
621 // I believe (but am not sure) that the constants Cn and Cp
622 // are material dependent. That is part of why the
623 // material name is passed in as an argument. The values
624 // here are for Si.
625 //
626 // Scope : public
627 // Creator : Eric R. Keiter, SNL, Parallel Computational Sciences
628 // Creation Date : 6/27/03
629 // ----------------------------------------------------------------------------
631  (const std::string & material, double ni, double n, double p)
632 {
633  double Ni = ni;
634  double Cn = 2.8e-31;
635  double Cp = 1.2e-31;
636  double pn = Ni*Ni;
637 
638  double A = (n*p-pn);
639  double C = (Cn*n+Cp*p);
640 
641  double arg = CONSTMAX_EXP_ARG;
642  if (C >= exp(arg)) C = exp(arg);
643 
644  return (A*C);
645 }
646 
647 // ----------------------------------------------------------------------------
648 // Function : MaterialSupport::pdRaugN
649 // Purpose : Calculates partial derivative w.r.t. electron density
650 // for Auger recombination.
651 //
652 // Special Notes : For this function, it shouldn't matter if the variables
653 // are scaled or not.
654 //
655 // I believe (but am not sure) that the constants Cn and Cp
656 // are material dependent. That is part of why the
657 // material name is passed in as an argument. The values
658 // here are for Si.
659 //
660 // Scope : public
661 // Creator : Eric R. Keiter, SNL, Parallel Computational Sciences
662 // Creation Date : 7/19/03
663 // ----------------------------------------------------------------------------
665  (const std::string & material, double ni, double n, double p)
666 {
667  double Ni = ni;
668  double pdRaugN;
669  double A1, B1;
670  double dAdn;
671  double dBdn;
672 
673  double Cn = 2.8e-31;
674  double Cp = 1.2e-31;
675  double pn = Ni*Ni;
676  double arg = CONSTMAX_EXP_ARG;
677 
678  A1 = (n*p-pn);
679  if (A1 >= exp(arg)) A1 = exp(arg);
680 
681  dAdn = (p);
682 
683  B1 = (Cn*n+Cp*p);
684  if (B1 >= exp(arg)) B1 = exp(arg);
685 
686  dBdn = Cn;
687 
688  pdRaugN = dAdn*B1 + A1*dBdn;
689 
690  return pdRaugN;
691 }
692 
693 // ----------------------------------------------------------------------------
694 // Function : MaterialSupport::pdRaugP
695 // Purpose : Calculates partial derivative w.r.t. hole density
696 // for Auger recombination.
697 //
698 // Special Notes : For this function, it shouldn't matter if the variables
699 // are scaled or not.
700 //
701 // I believe (but am not sure) that the constants Cn and Cp
702 // are material dependent. That is part of why the
703 // material name is passed in as an argument. The values
704 // here are for Si.
705 //
706 // Scope : public
707 // Creator : Eric R. Keiter, SNL, Parallel Computational Sciences
708 // Creation Date : 7/19/03
709 // ----------------------------------------------------------------------------
711  (const std::string & material, double ni, double n, double p)
712 {
713  double Ni = ni;
714  double pdRaugP;
715  double A1, B1;
716  double dAdp;
717  double dBdp;
718 
719  double Cn = 2.8e-31;
720  double Cp = 1.2e-31;
721  double pn = Ni*Ni;
722  double arg = CONSTMAX_EXP_ARG;
723 
724  A1 = (n*p-pn);
725  if (A1 >= exp(arg)) A1 = exp(arg);
726 
727  dAdp = (n);
728 
729  B1 = (Cn*n+Cp*p);
730  if (B1 >= exp(arg)) B1 = exp(arg);
731 
732  dBdp = Cp;
733 
734  pdRaugP = dAdp*B1 + A1*dBdp;
735 
736  return pdRaugP;
737 }
738 
739 //----------------------------------------------------------------------------
740 // Function : MaterialSupport::workfunc
741 // Purpose : This function returns the workfunction
742 // of various metals
743 //
744 // Special Notes :
745 //
746 // Scope : public
747 // Creator : Deborah Fixel, SNL, Parallel Computational Sciences
748 // Creation Date : 7/15/03
749 //----------------------------------------------------------------------------
750 double MaterialSupport::workfunc(std::string & metal)
751 {
752  double wkfunc=0.0;
753 
754  ExtendedString metalName = metal;
755  metalName.toLower ();
756 
757  if (metalName=="al")
758  {
759  wkfunc = 4.10; //aluminum
760  }
761  else if (metalName=="ppoly")
762  {
763  wkfunc = 5.25; // p+-polysilicon
764  }
765  else if (metalName=="npoly")
766  {
767  wkfunc = 4.17; // n+-polysilicon
768  }
769  else if (metalName=="mo")
770  {
771  wkfunc = 4.53; // molybdenum
772  }
773  else if (metalName=="w")
774  {
775  wkfunc = 4.63; // tungsten
776  }
777  else if (metalName=="modi")
778  {
779  wkfunc = 4.80; // molybdenum disilicide
780  }
781  else if (metalName=="wdi")
782  {
783  wkfunc = 4.80; // tungsten disilicide
784  }
785  else if (metalName=="cu")
786  {
787  wkfunc = 4.25; // copper
788  }
789  else if (metalName=="pt")
790  {
791  wkfunc = 5.30; // platinum
792  }
793  else if (metalName=="au")
794  {
795  wkfunc = 4.80; // gold
796  }
797  else if (metalName=="neutral")
798  {
799  wkfunc = 0.0;
800  }
801  else
802  {
803  Report::UserFatal0() << metalName << " material not recognized.";
804  }
805 
806  return wkfunc;
807 }
808 //----------------------------------------------------------------------------
809 // Function : MaterialSupport::affin
810 // Purpose : This function returns the electron affinity
811 // of various semiconductor materials
812 //
813 // Special Notes :
814 //
815 // Scope : public
816 // Creator : Deborah Fixel, SNL, Parallel Computational Sciences
817 // Creation Date : 7/15/03
818 //---------------------------------------------------------------------------
819 double MaterialSupport::affin(const std::string & material)
820 {
821 
822  double afty=0.0;
823 
824  ExtendedString materialName = material;
825  materialName.toLower();
826 
827  if (materialName=="si")
828  {
829  afty = 4.17; // silicon
830  }
831  else if (materialName=="ge")
832  {
833  afty = 4.00; // germanium
834  }
835  else if (materialName=="gaas")
836  {
837  afty = 4.07; // gallium arsenide
838  }
839  else if (materialName=="sio2")
840  {
841  afty = 0.97; // silicon dioxide
842  }
843  else if (materialName=="nitride")
844  {
845  afty = 0.97; // silicon nitride
846  }
847  else if (materialName=="sapphire")
848  {
849  afty = 0.97; // sapphire (also known as aluminum oxide)
850  }
851  else
852  {
853  Report::UserError0() << materialName << " material not recognized.";
854  }
855 
856  return afty;
857 }
858 
859 //----------------------------------------------------------------------------
860 // Function : MaterialSupport::bandgap
861 // Purpose : This function returns the electronic bandgap
862 // of various semiconductor materials.
863 //
864 // Special Notes : Reference for temperature-dependent semiconductor
865 // materials is "The Standard Thermodynamic Function
866 // of the Formation of Electrons and Holes in Ge, Si,
867 // GaAs, and GaP," by C. D. Thurmond, J. Electrochem. Soc.,
868 // vol. 122, p. 1133, 1975.
869 //
870 // Scope : public
871 // Creator : Deborah Fixel, SNL, Parallel Computational Sciences
872 // Creation Date : 7/18/03
873 //---------------------------------------------------------------------------
874 double MaterialSupport::bandgap(const std::string & material, double temp)
875 {
876  double gap = 0.0;
877  ExtendedString materialName = material;
878  materialName.toLower();
879 
880  if (materialName=="si") // silicon
881  {
882  gap = 1.17 - 4.73e-4*pow(temp,2.0)/(temp + 636.0);
883  }
884  else if (materialName=="ge") // germanium
885  {
886  gap = 0.7437 - 4.774e-4*pow(temp,2.0)/(temp + 235);
887  }
888  else if (materialName=="gaas") // gallium arsenide
889  {
890  gap = 1.519 - 5.405e-4*pow(temp,2.0)/(temp + 204);
891  }
892  else if (materialName=="ingap")
893  {
894  gap = 1.86098;
895  }
896  else if (materialName=="sio2") // silicon dioxide
897  {
898  gap = 9.00;
899  }
900  else if (materialName=="nitride") // silicon nitride
901  {
902  gap = 4.7;
903  }
904  else if (materialName=="sapphire") // sapphire
905  {
906  gap = 4.7;
907  }
908  else if (materialName=="inalas" || materialName=="alinas") // indium aluminum arsenide
909  {
910  gap = 1.46;
911  }
912  else if (materialName=="ingaas" || materialName=="gainas") // indium galium arsenide
913  {
914  gap = 0.75;
915  }
916  else if (materialName=="inp") // indium phosphide
917  {
918  gap = 1.07;
919  }
920  else
921  {
922  Report::UserError0() << materialName << " material not recognized.";
923  }
924 
925  return gap;
926 }
927 
928 
929 
930 //----------------------------------------------------------------------------
931 // Function : MaterialSupport::Ebgn
932 // Purpose : Band-gap narrowing
933 // Special Notes :
934 // Scope : public
935 // Creator : Eric R. Keiter, SNL
936 // Creation Date : 4/18/2014
937 //---------------------------------------------------------------------------
939  const std::string & material,
940  const std::string & bgnModel,
941  double dope,
942  bool ntype)
943 {
944  double Ebgn=0.0;
945 
946  if (bgnModel=="slotboom") // parameters taken from Medici manual
947  {
948  Ebgn = slotboomEbgn( material, dope, ntype) ;
949  }
950  else if (bgnModel=="bennet-wilson") // default model for Sentaurus.
951  {
952  Ebgn = bennetWilsonEbgn ( material, dope, ntype) ;
953  }
954  else if (bgnModel=="jain") // consistent with Wampler's XPD code.
955  {
956  Ebgn = jainEbgn( material, dope, ntype) ;
957  }
958  else if (bgnModel=="jain2") // consistent with Wampler's XPD code.
959  {
960  Ebgn = jain2Ebgn( material, dope, ntype) ;
961  }
962  else if (bgnModel=="jain3") // consistent with Wampler's XPD code.
963  {
964  Ebgn = jain3Ebgn( material, dope, ntype) ;
965  }
966  else // assume this is the default
967  {
968  Ebgn = jainEbgn( material, dope, ntype) ;
969  }
970 
971  return Ebgn;
972 }
973 
974 
975 //----------------------------------------------------------------------------
976 // Function : MaterialSupport::bennetWilsonEbgn
977 // Purpose : Band-gap narrowing, using the Bennet-Wilson model.
978 // Special Notes :
979 // Scope : public
980 // Creator : Eric R. Keiter, SNL
981 // Creation Date : 10/2/2014
982 //---------------------------------------------------------------------------
983 double MaterialSupport::bennetWilsonEbgn ( const std::string & material, double dope, bool ntype)
984 {
985  double Ebgn=0.0;
986  if (material=="si")
987  {
988  double Eref = 6.84e-3;
989  double Nref = 3.162e+18;
990  if (dope >= Nref) // Bennet-Wilson model
991  {
992  Ebgn = Eref*std::pow(log(dope/Nref),2.0);
993  }
994  }
995  else
996  {
997  // bennet-wilson not implemented for this material
998  Ebgn=0.0;
999  }
1000  return Ebgn;
1001 }
1002 
1003 //----------------------------------------------------------------------------
1004 // Function : MaterialSupport::slotboomEbgn
1005 // Purpose : Band-gap narrowing, using the Slotboom model.
1006 // Special Notes :
1007 // Scope : public
1008 // Creator : Eric R. Keiter, SNL
1009 // Creation Date : 10/2/2014
1010 //---------------------------------------------------------------------------
1011 double MaterialSupport::slotboomEbgn ( const std::string & material, double dope, bool ntype)
1012 {
1013  double Ebgn = 0.0;
1014  double n0_bgn=0.0;
1015  double v0_bgn=0.0;
1016  double con_bgn=0.0;
1017 
1018  if (material=="si") // silicon
1019  {
1020  // Slotboom model constants:
1021  n0_bgn = 1.0e17; // Nref
1022  v0_bgn = 9.0e-3; // Eref
1023  con_bgn = 0.5;
1024 #if 0
1025  // Klassen model constants
1026  double n0_bgn = 1.3e17; // Nref
1027  double v0_bgn = 6.92e-3; // Eref
1028  double con_bgn = 0.5;
1029 #endif
1030  }
1031  else if (material=="ge") // germanium
1032  {
1033  n0_bgn = 1.0e17;
1034  v0_bgn = 9.0e-3;
1035  con_bgn = 0.5;
1036  }
1037  else if (material=="gaas") // gallium arsenide
1038  {
1039  n0_bgn = 1.0e17;
1040  v0_bgn = 0.0;
1041  con_bgn = 0.0;
1042  }
1043  else if (material=="ingap")
1044  {
1045  n0_bgn = 1.0e17;
1046  v0_bgn = 0.0;
1047  con_bgn = 0.0;
1048  }
1049  else if (material=="sio2") // silicon dioxide
1050  {
1051  n0_bgn = 1.0e17; // Nref
1052  v0_bgn = 9.0e-3; // Eref
1053  con_bgn = 0.5;
1054  }
1055  // commenting the following materials out until the numbers can be checked
1056 #if 0
1057  else if (material=="nitride") // silicon nitride
1058  {
1059  n0_bgn = 1.0;
1060  v0_bgn = 0.0;
1061  con_bgn = 0.0;
1062  }
1063  else if (material=="sapphire") // sapphire
1064  {
1065  n0_bgn = 1.0;
1066  v0_bgn = 0.0;
1067  con_bgn = 0.0;
1068  }
1069  else if (material=="inalas" || material=="alinas") // indium aluminum arsenide
1070  {
1071  n0_bgn = 1.0e17;
1072  v0_bgn = 0.0;
1073  con_bgn = 0.0;
1074  }
1075  else if (material=="ingaas" || material=="gainas") // indium galium arsenide
1076  {
1077  Ebgn = 0.12;
1078  }
1079  else if (material=="inp") // indium phosphide
1080  {
1081  Ebgn = 9.4e-2;
1082  }
1083 #endif
1084  else
1085  {
1086  Report::UserError() << material << " material not recognized";
1087  return Ebgn;
1088  }
1089 
1090  double tmp1 = log(dope/n0_bgn);
1091  Ebgn = (v0_bgn) * (tmp1 + sqrt(tmp1*tmp1 + con_bgn));
1092 
1093  return Ebgn;
1094 }
1095 
1096 //----------------------------------------------------------------------------
1097 // Function : MaterialSupport::jainEbgn
1098 //
1099 // Purpose : Band-gap narrowing, using the Jain model.
1100 //
1101 // This corresponds to the BGN2 model in Davinci/Medici
1102 //
1103 // Special Notes :
1104 //
1105 // Scope : public
1106 // Creator : Eric R. Keiter, SNL
1107 // Creation Date : 4/18/2014
1108 //---------------------------------------------------------------------------
1109 double MaterialSupport::jainEbgn ( const std::string & material, double dope, bool ntype)
1110 {
1111  double Ebgn=0.0;
1112 
1113  double deltaEcn=0.0;
1114  double deltaEvn=0.0;
1115  double deltaEcp=0.0;
1116  double deltaEvp=0.0;
1117 
1118  double anc_bgn = 0.0;
1119  double bnc_bgn = 0.0;
1120  double cnc_bgn = 0.0;
1121  double anv_bgn = 0.0;
1122  double bnv_bgn = 0.0;
1123  double cnv_bgn = 0.0;
1124  double apc_bgn = 0.0;
1125  double bpc_bgn = 0.0;
1126  double cpc_bgn = 0.0;
1127  double apv_bgn = 0.0;
1128  double bpv_bgn = 0.0;
1129  double cpv_bgn = 0.0;
1130 
1131  if (material=="si") // silicon
1132  {
1133  anc_bgn = -14.84e-3;
1134  bnc_bgn = 0.0;
1135  cnc_bgn = 0.78e-3;
1136 
1137  anv_bgn = 0.0;
1138  bnv_bgn = 15.08e-3;
1139  cnv_bgn = 0.74e-3;
1140 
1141  apc_bgn = 0.0;
1142  bpc_bgn = -16.27e-3;
1143  cpc_bgn = -0.18e-3;
1144 
1145  apv_bgn = 18.46e-3;
1146  bpv_bgn = 0.0;
1147  cpv_bgn = -2.63e-3;
1148  }
1149  else if (material=="ge") // germanium
1150  {
1151  anc_bgn = -8.67e-3;
1152  bnc_bgn = 0.0;
1153  cnc_bgn = -2.02e-3;
1154  anv_bgn = 0.0;
1155  bnv_bgn = 8.14e-3;
1156  cnv_bgn = 2.29e-3;
1157  apc_bgn = -8.21e-3;
1158  bpc_bgn = 0.0;
1159  cpc_bgn = -2.19e-3;
1160  apv_bgn = 0.0;
1161  bpv_bgn = 9.18e-3;
1162  cpv_bgn = 3.58e-3;
1163  }
1164  else if (material=="gaas") // gallium arsenide
1165  {
1166  anc_bgn = -16.30e-3;
1167  bnc_bgn = 0.0;
1168  cnc_bgn = -18.13e-3;
1169  anv_bgn = 0.0;
1170  bnv_bgn = 7.47e-3;
1171  cnv_bgn = 72.52e-3;
1172  apc_bgn = -9.71e-3;
1173  bpc_bgn = 0.0;
1174  cpc_bgn = -0.47e-3;
1175  apv_bgn = 0.0;
1176  bpv_bgn = 12.19e-3;
1177  cpv_bgn = 3.41e-3;
1178  }
1179  else if (material=="ingap")
1180  { // these are the gaas numbers!
1181  anc_bgn = -16.3e-3;
1182  bnc_bgn = 0.0;
1183  cnc_bgn = -18.13e-3;
1184  anv_bgn = 0.0;
1185  bnv_bgn = 7.47e-3;
1186  cnv_bgn = 72.52e-3;
1187  apc_bgn = -9.71e-3;
1188  bpc_bgn = 0.0;
1189  cpc_bgn = -0.47e-3;
1190  apv_bgn = 0.0;
1191  bpv_bgn = 12.19e-3;
1192  cpv_bgn = 3.41e-3;
1193  }
1194  else if (material=="sio2") // silicon dioxide (use same as Si)
1195  {
1196  anc_bgn = -14.84e-3;
1197  bnc_bgn = 0.0;
1198  cnc_bgn = 0.78e-3;
1199 
1200  anv_bgn = 0.0;
1201  bnv_bgn = 15.08e-3;
1202  cnv_bgn = 0.74e-3;
1203 
1204  apc_bgn = 0.0;
1205  bpc_bgn = -16.27e-3;
1206  cpc_bgn = -0.18e-3;
1207 
1208  apv_bgn = 18.46e-3;
1209  bpv_bgn = 0.0;
1210  cpv_bgn = -2.63e-3;
1211  }
1212  // commenting the following materials out until the numbers can be checked
1213 #if 0
1214  else if (material=="nitride") // silicon nitride
1215  {
1216  // zero
1217  }
1218  else if (material=="sapphire") // sapphire
1219  {
1220  // zero
1221  }
1222 #endif
1223  else if (material=="inalas" || material=="alinas") // indium aluminum arsenide
1224  { // these are the gaas numbers!
1225  anc_bgn = -16.3e-3;
1226  bnc_bgn = 0.0;
1227  cnc_bgn = -18.13e-3;
1228  anv_bgn = 0.0;
1229  bnv_bgn = 7.47e-3;
1230  cnv_bgn = 72.52e-3;
1231  apc_bgn = -9.71e-3;
1232  bpc_bgn = 0.0;
1233  cpc_bgn = -0.47e-3;
1234  apv_bgn = 0.0;
1235  bpv_bgn = 12.19e-3;
1236  cpv_bgn = 3.41e-3;
1237  }
1238  else if (material=="ingaas" || material=="gainas") // indium galium arsenide
1239  { // these are the gaas numbers!
1240  anc_bgn = -16.3e-3;
1241  bnc_bgn = 0.0;
1242  cnc_bgn = -18.13e-3;
1243  anv_bgn = 0.0;
1244  bnv_bgn = 7.47e-3;
1245  cnv_bgn = 72.52e-3;
1246 
1247  apc_bgn = -9.71e-3;
1248  bpc_bgn = 0.0;
1249  cpc_bgn = -0.47e-3;
1250  apv_bgn = 0.0;
1251  bpv_bgn = 12.19e-3;
1252  cpv_bgn = 3.41e-3;
1253  }
1254  else if (material=="inp") // indium phosphide
1255  { // these are the gaas numbers!
1256  anc_bgn = -16.3e-3;
1257  bnc_bgn = 0.0;
1258  cnc_bgn = -18.13e-3;
1259  anv_bgn = 0.0;
1260  bnv_bgn = 7.47e-3;
1261  cnv_bgn = 72.52e-3;
1262  apc_bgn = -9.71e-3;
1263  bpc_bgn = 0.0;
1264  cpc_bgn = -0.47e-3;
1265  apv_bgn = 0.0;
1266  bpv_bgn = 12.19e-3;
1267  cpv_bgn = 3.41e-3;
1268  }
1269  else
1270  {
1271  Report::UserError() << material << " material not recognized";
1272  return fabs(Ebgn);
1273  }
1274 
1275  double dopeScaled=fabs(dope)/1.0e+18;
1276 
1277  if (ntype)
1278  {
1279  deltaEcn=
1280  +anc_bgn*std::pow(dopeScaled,(1.0/3.0))
1281  +bnc_bgn*std::pow(dopeScaled,(0.25))
1282  +cnc_bgn*std::pow(dopeScaled,(0.5));
1283 
1284  deltaEvn=
1285  +anv_bgn*std::pow(dopeScaled,(1.0/3.0))
1286  +bnv_bgn*std::pow(dopeScaled,(0.25))
1287  +cnv_bgn*std::pow(dopeScaled,(0.5));
1288 
1289  Ebgn = deltaEcn-deltaEvn;
1290  }
1291  else // p-type
1292  {
1293  deltaEcp=
1294  +apc_bgn*std::pow(dopeScaled,(1.0/3.0))
1295  +bpc_bgn*std::pow(dopeScaled,(0.25))
1296  +cpc_bgn*std::pow(dopeScaled,(0.5));
1297 
1298  deltaEvp=
1299  +apv_bgn*std::pow(dopeScaled,(1.0/3.0))
1300  +bpv_bgn*std::pow(dopeScaled,(0.25))
1301  +cpv_bgn*std::pow(dopeScaled,(0.5));
1302 
1303  Ebgn = deltaEcp-deltaEvp;
1304  }
1305 
1306  return fabs(Ebgn);
1307 }
1308 
1309 
1310 //----------------------------------------------------------------------------
1311 // Function : MaterialSupport::jain2Ebgn
1312 // Purpose : Band-gap narrowing, using the Jain model, another version.
1313 //
1314 // This one is from the original Jain paper, rather than
1315 // from the DaVinci manual. Only a few materials have been
1316 // set up.
1317 //
1318 // Special Notes :
1319 //
1320 // Scope : public
1321 // Creator : Eric R. Keiter, SNL
1322 // Creation Date : 4/18/2014
1323 //---------------------------------------------------------------------------
1324 double MaterialSupport::jain2Ebgn ( const std::string & material, double dope, bool ntype)
1325 {
1326  double deltaEbgn=0.0;
1327 
1328  double A_p=0.0;
1329  double B_p=0.0;
1330  double C_p=0.0;
1331 
1332  double A_n=0.0;
1333  double B_n=0.0;
1334  double C_n=0.0;
1335 
1336 #if 0
1337  if (material=="si") // silicon
1338  {
1339  }
1340  else if (material=="ge") // germanium
1341  {
1342  }
1343  else
1344 #endif
1345 
1346  if (material=="gaas") // gallium arsenide
1347  {
1348  A_p=9.83e-9;
1349  B_p=3.90e-7;
1350  C_p=3.90e-12;
1351 
1352  A_n=16.5e-9;
1353  B_n=2.39e-7;
1354  C_n=91.4e-12;
1355  }
1356 #if 0
1357  else if (material=="ingap")
1358  { // these are the gaas numbers!
1359  }
1360  else if (material=="sio2") // silicon dioxide (use same as Si)
1361  {
1362  }
1363  else if (material=="nitride") // silicon nitride
1364  {
1365  // zero
1366  }
1367  else if (material=="sapphire") // sapphire
1368  {
1369  // zero
1370  }
1371  else if (material=="inalas" || material=="alinas") // indium aluminum arsenide
1372  { // these are the gaas numbers!
1373  }
1374 #endif
1375  else if (material=="ingaas" || material=="gainas") // indium galium arsenide
1376  { // these are the gaas numbers!
1377  A_p=9.20e-9;
1378  B_p=3.57e-7;
1379  C_p=3.65e-12;
1380 
1381  A_n=15.5e-9;
1382  B_n=1.95e-7;
1383  C_n=159.0e-12;
1384  }
1385 #if 0
1386  else if (material=="inp") // indium phosphide
1387  { // these are the gaas numbers!
1388  }
1389 #endif
1390  else
1391  {
1392  Report::UserError() << material << " material not recognized";
1393  return deltaEbgn;
1394  }
1395 
1396  double dopeScaled=fabs(dope);
1397 
1398  if (ntype) // n-type
1399  {
1400  deltaEbgn=
1401  +A_n*std::pow(dopeScaled,(1.0/3.0))
1402  +B_n*std::pow(dopeScaled,(0.25))
1403  +C_n*std::pow(dopeScaled,(0.5));
1404  }
1405  else // p-type
1406  {
1407  deltaEbgn=
1408  +A_p*std::pow(dopeScaled,(1.0/3.0))
1409  +B_p*std::pow(dopeScaled,(0.25))
1410  +C_p*std::pow(dopeScaled,(0.5));
1411  }
1412 
1413  return deltaEbgn;
1414 }
1415 
1416 
1417 //----------------------------------------------------------------------------
1418 // Function : MaterialSupport::jain3Ebgn
1419 // Purpose : Band-gap narrowing, using the Jain model, another version
1420 // Special Notes : Ntype vs. Ptype is determined by the sign of "dope". I
1421 // have only had time to set up a few materials.
1422 // Scope : public
1423 // Creator : Eric R. Keiter, SNL
1424 // Creation Date : 4/18/2014
1425 //---------------------------------------------------------------------------
1426 double MaterialSupport::jain3Ebgn ( const std::string & material, double dope, bool ntype)
1427 {
1428  double deltaEbgn=0.0;
1429  double A_p=0.0;
1430  double A_n=0.0;
1431 
1432 #if 0
1433  if (material=="si") // silicon
1434  {
1435  }
1436  else if (material=="ge") // germanium
1437  {
1438  }
1439  else
1440 #endif
1441 
1442  if (material=="gaas") // gallium arsenide
1443  {
1444  A_p=2.6e-8;
1445  //A_n=16.5e-9;
1446  }
1447 #if 0
1448  else if (material=="ingap")
1449  { // these are the gaas numbers!
1450  }
1451  else if (material=="sio2") // silicon dioxide (use same as Si)
1452  {
1453  }
1454  else if (material=="nitride") // silicon nitride
1455  {
1456  // zero
1457  }
1458  else if (material=="sapphire") // sapphire
1459  {
1460  // zero
1461  }
1462  else if (material=="inalas" || material=="alinas") // indium aluminum arsenide
1463  { // these are the gaas numbers!
1464  }
1465 #endif
1466  else if (material=="ingaas" || material=="gainas") // indium galium arsenide
1467  {
1468  A_p=2.43e-8;
1469  //A_n=15.5e-9;
1470  }
1471  else if (material=="gasb") // indium phosphide
1472  {
1473  A_p=2.22e-8;
1474  }
1475  else
1476  {
1477  Report::UserError() << material << " material not recognized";
1478  return deltaEbgn;
1479  }
1480 
1481  double dopeScaled=fabs(dope);
1482 
1483  if (ntype) // n-type
1484  {
1485  deltaEbgn=A_n*std::pow(dopeScaled,(1.0/3.0));
1486  }
1487  else // p-type
1488  {
1489  deltaEbgn=A_p*std::pow(dopeScaled,(1.0/3.0));
1490  }
1491 
1492  return deltaEbgn;
1493 }
1494 
1495 // ----------------------------------------------------------------------------
1496 // Function : MaterialSupport::calcLt
1497 // Purpose : This function calculates carrier lifetimes.
1498 //
1499 // Special Notes : holeFlag parameter indicates electrons or holes:
1500 // holeFlag = true -> holes
1501 // holeFlag = false -> electrons
1502 //
1503 // This function assumes that conc is an absolute value.
1504 //
1505 // This function comes from this paper:
1506 //
1507 // "Analysis of High-Efficiency Silicon Solar Cells",
1508 // IEEE Transactions on Electron Devices, by Harry T.
1509 // Weaver and R. D. Nasby, vol. ED-28, no. 5, May 1981.
1510 //
1511 // In the paper, conc = total doping, i.e. (N_A + N_D)
1512 //
1513 // Scope : public
1514 // Creator : Eric R. Keiter, SNL, Parallel Computational Sciences
1515 // Creation Date : 6/20/03
1516 // ----------------------------------------------------------------------------
1517 double MaterialSupport::calcLt (bool holeFlag, double conc, std::string material)
1518 {
1519  double lt = 0.0;
1520  double LT0, Nref;
1521 
1522  conc = fabs(conc);
1523 
1524  if (material=="si")
1525  {
1526  if (holeFlag)
1527  {
1528  LT0 = 3.52e-5;
1529  Nref = 7.1e15;
1530  lt = LT0 / (1.0 + conc / Nref);
1531  }
1532  else
1533  {
1534  LT0 = 3.95e-4;
1535  Nref = 7.1e15;
1536  lt = LT0 / (1.0 + conc / Nref);
1537  }
1538  }
1539  else if (material=="gaas")
1540  {
1541  if (holeFlag)
1542  // Adding in SILVACO GaAs defaults here
1543  {
1544  LT0 = 2.0e-8;
1545  Nref = 5.0e16;
1546  lt = LT0 / (1.0 + conc / Nref);
1547  }
1548  else
1549  // Adding in SILVACO GaAs defaults here
1550  {
1551  LT0 = 1.0e-9;
1552  Nref = 5.0e16;
1553  lt = LT0 / (1.0 + conc / Nref);
1554  }
1555  }
1556  else
1557  {
1558  Report::UserFatal0() << material << " material not recognized.";
1559  }
1560 
1561  return lt;
1562 }
1563 
1564 } // namespace Device
1565 } // namespace Xyce
double getNi_old(const std::string &material, double temp)
double get_DOS_EffectiveMassP(const std::string &material)
#define CONSTemass
Definition: N_DEV_Const.h:55
Pure virtual class to augment a linear system.
double getEffectiveMassP(const std::string &material)
#define CONSTMAX_EXP_ARG
Definition: N_DEV_Const.h:110
double pdRaugN(const std::string &material, double ni, double n, double p)
double getNc(const std::string &material, double temp)
double calcRaug(const std::string &material, double ni, double n, double p)
double getRelPerm(const std::string &material)
double workfunc(std::string &metal)
double bandgap(const std::string &material, double temp)
double bennetWilsonEbgn(const std::string &material, double dope, bool ntype)
double Ebgn(const std::string &material, const std::string &bgnModel, double dope, bool ntype)
double getEffectiveMassN(const std::string &material)
double calcRsrh(const std::string &material, double ni, double n, double p, double tn, double tp)
double slotboomEbgn(const std::string &material, double dope, bool ntype)
double calcLt(bool holeFlag, double conc, std::string material="si")
#define CONSTplanck
Definition: N_DEV_Const.h:54
double pdRsrhN(const std::string &material, double ni, double n, double p, double tn, double tp)
double pdRaugP(const std::string &material, double ni, double n, double p)
double jain3Ebgn(const std::string &material, double dope, bool ntype)
double jain2Ebgn(const std::string &material, double dope, bool ntype)
double jainEbgn(const std::string &material, double dope, bool ntype)
#define M_PI
double affin(const std::string &material)
double getNv(const std::string &material, double temp)
double getNi(const std::string &material, double temp)
double pdRsrhP(const std::string &material, double ni, double n, double p, double tn, double tp)
double get_DOS_EffectiveMassN(const std::string &material)