ViennaSHE 1.3.0
Free open-source semiconductor device simulator using spherical harmonics expansions techniques.
config.hpp
Go to the documentation of this file.
1#ifndef VIENNASHE_SHE_CONFIG_HPP
2#define VIENNASHE_SHE_CONFIG_HPP
3
4/* ============================================================================
5 Copyright (c) 2011-2022, Institute for Microelectronics,
6 Institute for Analysis and Scientific Computing,
7 TU Wien.
8
9 -----------------
10 ViennaSHE - The Vienna Spherical Harmonics Expansion Boltzmann Solver
11 -----------------
12
13 http://viennashe.sourceforge.net/
14
15 License: MIT (X11), see file LICENSE in the base directory
16=============================================================================== */
17
18
19#include <iostream>
20#include <algorithm>
21#include <memory>
22
23#include "viennashe/forwards.h"
26
31
33
38namespace viennashe
39{
40 namespace detail
41 {
43 {
44 density_gradient_config() : lambda_(0.2), dirichlet_(-0.11), bnd_type_id_(viennashe::BOUNDARY_DIRICHLET)
45 {
46 robin_coeffs_.alpha = 0.0;
47 robin_coeffs_.beta = 0.0;
48 }
49
50 density_gradient_config(double lambda, double alpha, double beta)
51 : lambda_(lambda), dirichlet_(0.0), bnd_type_id_(viennashe::BOUNDARY_ROBIN)
52 {
53 robin_coeffs_.alpha = alpha;
54 robin_coeffs_.beta = beta;
55 }
56
57 double lambda() const { return lambda_; }
58 void lambda(double l) { lambda_ = l; }
59
60 double dirichlet_boundary_value() const { return dirichlet_; }
61 void dirichlet_boundary_value(double d) { dirichlet_ = d; }
62
63 viennashe::boundary_type_id boundary_type() const { return bnd_type_id_; }
64
65 void boundary_type(viennashe::boundary_type_id newid) { bnd_type_id_ = newid; }
66
69
70 private:
71 double lambda_;
73 double dirichlet_;
74 viennashe::boundary_type_id bnd_type_id_;
75 };
76
77 } // namespace detail
78
81 {
82 enum { parabolic_dispersion, // parabolic dispersion for holes
83 modena_dispersion, // modena dispersion for holes
84 ext_vecchi_dispersion // extended Vecchi model, Jin et al. TED 2011
85 };
86 };
87
88
91 {
92 public:
94
96 viennashe::boundary_type_id type() const { return she_bnd_id_; }
97
100 {
102 she_bnd_id_ = new_id;
103 else
104 throw invalid_boundary_condition_exception("Encountered invalid boundary type for SHE. Only BOUNDARY_DIRICHLET and BOUNDARY_GENERATION_RECOMBINATION supported!");
105 }
106
108 double generation_recombination_rate() const { return tau_; }
112 void generation_recombination_rate(double new_tau) { if (new_tau > 0) tau_ = new_tau; }
113
114 private:
115 viennashe::boundary_type_id she_bnd_id_;
116 double tau_; // generation/recombination rate (0.1 fs). Might need further calibration. The shorter the rate, the stronger is the distribution function clamped to the contact
117 };
118
119
120
122 class config
124 {
125 public:
129
130
132 with_electrons_( true ),
133 electron_equation_id_(EQUATION_CONTINUITY),
134 with_holes_( true ),
135 hole_equation_id_(EQUATION_CONTINUITY),
136 with_traps_( false ),
137 with_trap_selfconsistency_( false ),
138 dispersion_relation_electrons_( new viennashe::physics::modena_dispersion<viennashe::materials::si>(viennashe::ELECTRON_TYPE_ID) ),
139 dispersion_relation_holes_( new viennashe::physics::modena_dispersion<viennashe::materials::si>(viennashe::HOLE_TYPE_ID) ),
140 she_discretization_id_(SHE_DISCRETIZATION_EVEN_ODD_ORDER_DF),
141 she_scaling_id_(SHE_SCALING_KINETIC_ENERGY),
142 L_max_(1), adaptive_expansions_(false),
143 energy_spacing_(31.0 * viennashe::physics::constants::q / 1000.0),
144 min_kinetic_energy_range_electrons_(viennashe::physics::constants::q),
145 min_kinetic_energy_range_holes_(viennashe::physics::constants::q),
146 max_kinetic_energy_range_electrons_(5.0*viennashe::physics::constants::q), // ~5 eV is the work function for most semiconductors
147 max_kinetic_energy_range_holes_(5.0*viennashe::physics::constants::q), // ~5 eV is the work function for most semiconductors
148 use_h_transformation_(true),
149 use_quantum_correction_(false),
150 scatter_conf_(),
151 linear_solver_conf_(),
152 nonlinear_solver_conf_(),
153 with_hde_(false),
154 with_quantum_correction_(false),
155 time_step_size_(0),
156 she_boundary_conf_(),
157 dg_config_electrons_(0.2, -5.5e-4, -7.5e-5),
158 dg_config_holes_(0.22, -4.2e-4, 8.3e-5)
159 {}
160
161 config(config const & other) :
162 with_electrons_( other.with_electrons_ ),
163 electron_equation_id_(other.electron_equation_id_),
164 with_holes_( other.with_holes_ ),
165 hole_equation_id_(other.hole_equation_id_),
166 with_traps_( other.with_traps_ ),
167 with_trap_selfconsistency_(other.with_trap_selfconsistency_),
168 dispersion_relation_electrons_(other.dispersion_relation_electrons_->clone()) ,
169 dispersion_relation_holes_(other.dispersion_relation_holes_->clone()) ,
170 she_discretization_id_(other.she_discretization_id_),
171 she_scaling_id_(other.she_scaling_id_),
172 L_max_(other.L_max_), adaptive_expansions_(other.adaptive_expansions_),
173 energy_spacing_(other.energy_spacing_),
174 min_kinetic_energy_range_electrons_(other.min_kinetic_energy_range_electrons_),
175 min_kinetic_energy_range_holes_(other.min_kinetic_energy_range_holes_),
176 max_kinetic_energy_range_electrons_(other.max_kinetic_energy_range_electrons_),
177 max_kinetic_energy_range_holes_(other.max_kinetic_energy_range_holes_),
178 use_h_transformation_(other.use_h_transformation_),
179 use_quantum_correction_(other.use_quantum_correction_),
180 scatter_conf_(other.scatter_conf_),
181 linear_solver_conf_(other.linear_solver_conf_),
182 nonlinear_solver_conf_(other.nonlinear_solver_conf_),
183 with_hde_(other.with_hde_),
184 with_quantum_correction_(other.with_quantum_correction_),
185 time_step_size_(other.time_step_size_),
186 she_boundary_conf_(other.she_boundary_conf_),
187 dg_config_electrons_(other.dg_config_electrons_),
188 dg_config_holes_(other.dg_config_holes_)
189 {}
190
191 void operator=(config const & other)
192 {
193 with_electrons_ = other.with_electrons_;
194 with_holes_ = other.with_holes_;
195 with_traps_ = other.with_traps_;
196 with_trap_selfconsistency_ = other.with_trap_selfconsistency_;
197// dispersion_relation_electrons_ = std::auto_ptr< viennashe::physics::dispersion_base >(other.dispersion_relation_electrons_->clone());
198// dispersion_relation_holes_ = std::auto_ptr< viennashe::physics::dispersion_base >(other.dispersion_relation_holes_->clone());
199 dispersion_relation_electrons_ = std::unique_ptr< viennashe::physics::dispersion_base >(other.dispersion_relation_electrons_->clone());
200 dispersion_relation_holes_ = std::unique_ptr< viennashe::physics::dispersion_base >(other.dispersion_relation_holes_->clone());
201 she_discretization_id_ = other.she_discretization_id_;
202 she_scaling_id_ = other.she_scaling_id_;
203 L_max_ = other.L_max_;
204 adaptive_expansions_ = other.adaptive_expansions_;
205 energy_spacing_ = other.energy_spacing_;
206 min_kinetic_energy_range_electrons_ = other.min_kinetic_energy_range_electrons_;
207 min_kinetic_energy_range_holes_ = other.min_kinetic_energy_range_holes_;
208 max_kinetic_energy_range_electrons_ = other.max_kinetic_energy_range_electrons_;
209 max_kinetic_energy_range_holes_ = other.max_kinetic_energy_range_holes_;
210 use_h_transformation_ = other.use_h_transformation_;
211 use_quantum_correction_ = other.use_quantum_correction_;
212 scatter_conf_ = other.scatter_conf_;
213 linear_solver_conf_ = other.linear_solver_conf_;
214 nonlinear_solver_conf_ = other.nonlinear_solver_conf_;
215 with_hde_ = other.with_hde_;
216 with_quantum_correction_ = other.with_quantum_correction_;
217 time_step_size_ = other.time_step_size_;
218 she_boundary_conf_ = other.she_boundary_conf_;
219 dg_config_electrons_ = other.dg_config_electrons_;
220 dg_config_holes_ = other.dg_config_holes_;
221 }
222
224
226 bool with_electrons() const { return with_electrons_; }
228 void with_electrons(bool b) { with_electrons_ = b; }
229
230 equation_id get_electron_equation() const { return electron_equation_id_; }
231 void set_electron_equation(equation_id equ_id) { electron_equation_id_ = equ_id; }
232
234 bool with_holes() const { return with_holes_; }
236 void with_holes(bool b) { with_holes_ = b; }
237
238 equation_id get_hole_equation() const { return hole_equation_id_; }
239 void set_hole_equation(equation_id equ_id) { hole_equation_id_ = equ_id; }
240
241
243 bool with_traps() const { return with_traps_; }
245 void with_traps(bool b) { with_traps_ = b; }
247 bool with_trap_selfconsistency() const { return with_trap_selfconsistency_; }
249 void with_trap_selfconsistency(bool b) { with_trap_selfconsistency_ = b; }
250
251
252
255 {
256 return viennashe::physics::dispersion_proxy(dispersion_relation_electrons_.get());
257 }
258
261 {
262 return viennashe::physics::dispersion_proxy(dispersion_relation_holes_.get());
263 }
264
267 {
268 if (ctype == viennashe::ELECTRON_TYPE_ID)
269 return viennashe::physics::dispersion_proxy(dispersion_relation_electrons_.get());
270 else if (ctype == viennashe::HOLE_TYPE_ID)
271 return viennashe::physics::dispersion_proxy(dispersion_relation_holes_.get());
272 else
273 throw viennashe::carrier_type_not_supported_exception("In dispersion_relation");
274 }
275
280 void dispersion_relation_electrons(long dispersion_id)
281 {
283 = dispersion_relation_impl<viennashe::materials::si>(viennashe::ELECTRON_TYPE_ID, dispersion_id);
284
285 if (disp_ptr == NULL)
286 {
287 std::stringstream ss;
288 ss << "No electron dispersion found with id: " << dispersion_id << std::endl;
290 }
291 dispersion_relation_electrons_ = std::unique_ptr< viennashe::physics::dispersion_base >( disp_ptr );
292
293 // dispersion_relation_electrons_ = std::auto_ptr< viennashe::physics::dispersion_base >( disp_ptr );
294 }
295
301 void dispersion_relation(long dispersion_id, viennashe::carrier_type_id ctype)
302 {
303 if (ctype == viennashe::ELECTRON_TYPE_ID)
304 dispersion_relation_electrons(dispersion_id);
305 else
306 dispersion_relation_holes(dispersion_id);
307 }
308
313 void dispersion_relation(const std::string name)
314 {
315 this->dispersion_relation_electrons(this->get_dispersion_relation_id_impl(name));
316 this->dispersion_relation_holes(this->get_dispersion_relation_id_impl(name));
317 }
318
323 void dispersion_relation_electrons(const std::string name)
324 {
325 this->dispersion_relation_electrons(this->get_dispersion_relation_id_impl(name));
326 }
327
328
333 void dispersion_relation_holes(long dispersion_id) //TODO: Think about incorporation of materials here
334 {
336 = dispersion_relation_impl<viennashe::materials::si>(viennashe::HOLE_TYPE_ID, dispersion_id);
337
338 if (disp_ptr == NULL)
339 {
340 std::stringstream ss;
341 ss << "No hole dispersion found with id: " << dispersion_id << std::endl;
343 }
344
345 //dispersion_relation_holes_ = std::auto_ptr< viennashe::physics::dispersion_base >( disp_ptr );
346 dispersion_relation_holes_ = std::unique_ptr< viennashe::physics::dispersion_base >( disp_ptr );
347
348 }
349
354 void dispersion_relation_holes(const std::string name)
355 {
356 this->dispersion_relation_holes(this->get_dispersion_relation_id_impl(name));
357 }
358
359
360 she_discretization_type_id she_discretization_type() const { return she_discretization_id_; }
361 void she_discretization_type(she_discretization_type_id discretization_id) { she_discretization_id_ = discretization_id; }
362
363 she_scaling_type_id she_scaling_type() const { return she_scaling_id_; }
364 void she_scaling_type(she_scaling_type_id scaling_id) { she_scaling_id_ = scaling_id; }
365
366
367 // Expansion order:
369 long max_expansion_order() const { return L_max_; }
370
372 void max_expansion_order(long new_L)
373 {
374 assert(new_L > 0);
375 L_max_ = new_L;
376 }
377
379 bool adaptive_expansions() const { return adaptive_expansions_; }
381 void adaptive_expansions(bool b) { adaptive_expansions_ = b; }
382
383 //
384 // Minimum kinetic energy range:
385 //
386
389 {
390 if (ctype == ELECTRON_TYPE_ID)
391 return min_kinetic_energy_range_electrons_;
392 else
393 return min_kinetic_energy_range_holes_;
394 }
395
398 {
399 if (e_new > 0)
400 {
401 if (ctype == ELECTRON_TYPE_ID)
402 min_kinetic_energy_range_electrons_ = e_new;
403 else
404 min_kinetic_energy_range_holes_ = e_new;
405 }
406 }
407
408
409 // set both
411 void min_kinetic_energy_range(double e_new)
412 {
413 if (e_new > 0)
414 {
415 min_kinetic_energy_range_electrons_ = e_new;
416 min_kinetic_energy_range_holes_ = e_new;
417 }
418 }
419
420 //
421 // Maximum kinetic energy range:
422 //
423
426 {
427 if (ctype == ELECTRON_TYPE_ID)
428 return max_kinetic_energy_range_electrons_;
429 else
430 return max_kinetic_energy_range_holes_;
431 }
432
435 {
436 if (e_new > 0)
437 {
438 if (ctype == ELECTRON_TYPE_ID)
439 max_kinetic_energy_range_electrons_ = e_new;
440 else
441 max_kinetic_energy_range_holes_ = e_new;
442 }
443 }
444
445
446 // set both
448 void max_kinetic_energy_range(double e_new)
449 {
450 if (e_new > 0)
451 {
452 max_kinetic_energy_range_electrons_ = e_new;
453 max_kinetic_energy_range_holes_ = e_new;
454 }
455 }
456
457
458
460 double energy_spacing() const { return energy_spacing_; }
462 void energy_spacing(double new_spacing) { energy_spacing_ = new_spacing; }
463
465 bool use_h_transformation() const { return use_h_transformation_; }
467 void use_h_transformation(bool b) { use_h_transformation_ = b; }
468
469
470 //
471 // scattering
472 //
473
475 viennashe::she::scatter_config & scattering() { return scatter_conf_; }
477 viennashe::she::scatter_config const & scattering() const { return scatter_conf_; }
478
479
480 //
481 // linear solver
482 //
483
485 linear_solver_config_type & linear_solver() { return linear_solver_conf_; }
487 linear_solver_config_type const & linear_solver() const { return linear_solver_conf_; }
488
489
490 //
491 // nonlinear solver
492 //
493
495 nonlinear_solver_config_type & nonlinear_solver() { return nonlinear_solver_conf_; }
497 nonlinear_solver_config_type const & nonlinear_solver() const { return nonlinear_solver_conf_; }
498
499 //
500 // HDE
501 //
502 bool with_hde() const { return with_hde_; }
503 void with_hde(bool v) { with_hde_ = v; }
504
505 //
506 // Quantum Correction
507 //
508
509 bool quantum_correction() const { return use_quantum_correction_; }
510 void quantum_correction(bool use_quantum_correction) { use_quantum_correction_ = use_quantum_correction; }
511
512 bool with_quantum_correction() const { return with_quantum_correction_; }
513 void with_quantum_correction(bool b) { with_quantum_correction_ = b; }
514
515 //
516 // Density Gradient
517 //
518
520 {
521 if (ctype == viennashe::ELECTRON_TYPE_ID)
522 return dg_config_electrons_;
523 else
524 return dg_config_holes_;
525 }
526
528 {
529 if (ctype == viennashe::ELECTRON_TYPE_ID)
530 return dg_config_electrons_;
531 else
532 return dg_config_holes_;
533 }
534
536 double time_step_size() const { return time_step_size_; }
537 //void time_step_size(double s) { assert(s >= 0 && bool("Time step size must not be negative!")); time_step_size_ = s; }
538
540 she_boundary_conditions_config const & she_boundary_conditions() const { return she_boundary_conf_; }
542
543 //
544 // Insulator Distance
545 //
546 bool setup_insulator_distances() const { return this->scattering().surface().enabled(); }
547
548 private:
549
550 template <typename MaterialTag>
551 viennashe::physics::dispersion_base * dispersion_relation_impl(viennashe::carrier_type_id ctype, long dispersion_id)
552 {
553 switch(dispersion_id)
554 {
561 default:
562 return NULL;
563 };
564 return NULL;
565 }
566
567 long get_dispersion_relation_id_impl(std::string name)
568 {
569 // to upper to ease the comparison and to be case insensitive
570 std::transform(name.begin(), name.end(), name.begin(), ::tolower);
571
572 if (name == "parabolic_dispersion")
573 {
575 }
576 else if (name == "modena_dispersion")
577 {
578 return modena_dispersion;
579 }
580 else if (name == "ext_vecchi_dispersion" || name == "fullband")
581 {
583 }
584 else
585 {
586 return -1;
587 }
588 }
589
590 bool with_electrons_;
591 equation_id electron_equation_id_;
592 bool with_holes_;
593 equation_id hole_equation_id_;
594 bool with_traps_;
595 bool with_trap_selfconsistency_;
596 std::unique_ptr< viennashe::physics::dispersion_base > dispersion_relation_electrons_;
597 std::unique_ptr< viennashe::physics::dispersion_base > dispersion_relation_holes_;
598 she_discretization_type_id she_discretization_id_;
599 she_scaling_type_id she_scaling_id_;
600
601 long L_max_;
602 bool adaptive_expansions_;
603
604 double energy_spacing_;
605 double min_kinetic_energy_range_electrons_;
606 double min_kinetic_energy_range_holes_;
607 double max_kinetic_energy_range_electrons_;
608 double max_kinetic_energy_range_holes_;
609 bool use_h_transformation_;
610
611 bool use_quantum_correction_;
612 viennashe::she::scatter_config scatter_conf_;
613 linear_solver_config_type linear_solver_conf_;
614 nonlinear_solver_config_type nonlinear_solver_conf_;
615
616 bool with_hde_;
617 bool with_quantum_correction_;
618
619 double time_step_size_;
620 she_boundary_conditions_config she_boundary_conf_;
621
622 detail::density_gradient_config dg_config_electrons_;
623 detail::density_gradient_config dg_config_holes_;
624
625
626 };
627
628} // namespace viennashe
629
630#endif
Exception thrown in the case that any code does not support the given carrier type.
Definition: exception.hpp:154
The main SHE configuration class. To be adjusted by the user for his/her needs.
Definition: config.hpp:124
void she_scaling_type(she_scaling_type_id scaling_id)
Definition: config.hpp:364
void with_electrons(bool b)
Activates are deactivates electrons in the simulation.
Definition: config.hpp:228
void dispersion_relation_electrons(const std::string name)
Sets a new dispersion relation for electrons.
Definition: config.hpp:323
linear_solver_config_type const & linear_solver() const
Returns the configuration object for the linear solver.
Definition: config.hpp:487
she_boundary_conditions_config const & she_boundary_conditions() const
Definition: config.hpp:540
double min_kinetic_energy_range(viennashe::carrier_type_id ctype) const
Returns the minimum kinetic energy range for the selected carrier.
Definition: config.hpp:388
void with_trap_selfconsistency(bool b)
Activates or deactivates trap self-consistency in the simulation.
Definition: config.hpp:249
viennashe::physics::dispersion_proxy dispersion_relation(viennashe::carrier_type_id ctype) const
Returns the dispersion relation for electrons.
Definition: config.hpp:266
viennashe::physics::dispersion_proxy dispersion_relation_type
Definition: config.hpp:128
she_boundary_conditions_config & she_boundary_conditions()
Definition: config.hpp:541
long max_expansion_order() const
Returns the current maximum expansion order.
Definition: config.hpp:369
void dispersion_relation_holes(long dispersion_id)
Sets a new dispersion relation for holes.
Definition: config.hpp:333
void with_traps(bool b)
Activates or deactivates traps in the simulation.
Definition: config.hpp:245
void max_kinetic_energy_range(double e_new)
Sets the minimum kinetic energy range in the conduction band for electrons and in the valence band fo...
Definition: config.hpp:448
equation_id get_electron_equation() const
Definition: config.hpp:230
bool with_holes() const
Returns true if holes are considered in the simulation.
Definition: config.hpp:234
double time_step_size() const
Definition: config.hpp:536
bool with_hde() const
Definition: config.hpp:502
bool quantum_correction() const
Definition: config.hpp:509
void dispersion_relation_electrons(long dispersion_id)
Sets a new dispersion relation for electrons.
Definition: config.hpp:280
equation_id get_hole_equation() const
Definition: config.hpp:238
bool with_traps() const
Returns true if traps are considered in the simulation.
Definition: config.hpp:243
void she_discretization_type(she_discretization_type_id discretization_id)
Definition: config.hpp:361
viennashe::physics::dispersion_proxy dispersion_relation_electrons() const
Returns the dispersion relation for electrons.
Definition: config.hpp:254
nonlinear_solver_config_type & nonlinear_solver()
Returns the configuration object for the nonlinear solver.
Definition: config.hpp:495
void dispersion_relation(long dispersion_id, viennashe::carrier_type_id ctype)
Sets a new dispersion relation for electrons.
Definition: config.hpp:301
void set_electron_equation(equation_id equ_id)
Definition: config.hpp:231
viennashe::solvers::linear_solver_config linear_solver_config_type
Definition: config.hpp:126
double max_kinetic_energy_range(viennashe::carrier_type_id ctype) const
Returns the minimum kinetic energy range for the selected carrier.
Definition: config.hpp:425
void with_hde(bool v)
Definition: config.hpp:503
linear_solver_config_type & linear_solver()
Returns the configuration object for the linear solver.
Definition: config.hpp:485
double energy_spacing() const
Returns the uniform energy spacing of discrete energies.
Definition: config.hpp:460
void quantum_correction(bool use_quantum_correction)
Definition: config.hpp:510
viennashe::solvers::nonlinear_solver_config nonlinear_solver_config_type
Definition: config.hpp:127
she_scaling_type_id she_scaling_type() const
Definition: config.hpp:363
void energy_spacing(double new_spacing)
Sets a new discrete energy spacing.
Definition: config.hpp:462
void dispersion_relation(const std::string name)
Sets a new dispersion relation for electrons and holes.
Definition: config.hpp:313
bool with_trap_selfconsistency() const
Returns true if traps are considered self-consistently in the simulation.
Definition: config.hpp:247
config(config const &other)
Definition: config.hpp:161
void set_hole_equation(equation_id equ_id)
Definition: config.hpp:239
bool use_h_transformation() const
Returns whether the H-transformation is used.
Definition: config.hpp:465
bool adaptive_expansions() const
Returns the flag for the use of adaptive expansions.
Definition: config.hpp:379
viennashe::she::scatter_config const & scattering() const
Returns the configuration object for scattering.
Definition: config.hpp:477
detail::density_gradient_config & density_gradient(viennashe::carrier_type_id ctype)
Definition: config.hpp:527
void min_kinetic_energy_range(double e_new)
Sets the minimum kinetic energy range in the conduction band for electrons and in the valence band fo...
Definition: config.hpp:411
bool with_electrons() const
Returns true if electrons are considered in the simulation.
Definition: config.hpp:226
void max_expansion_order(long new_L)
Sets a new maximum expansion order. For uniform expansions, new_L will be used all over the device....
Definition: config.hpp:372
void operator=(config const &other)
Definition: config.hpp:191
void dispersion_relation_holes(const std::string name)
Sets a new dispersion relation for holes.
Definition: config.hpp:354
void max_kinetic_energy_range(double e_new, viennashe::carrier_type_id ctype)
Sets the minimum kinetic energy range for the selected carrier.
Definition: config.hpp:434
void with_holes(bool b)
Activates are deactivates holes in the simulation.
Definition: config.hpp:236
she_discretization_type_id she_discretization_type() const
Definition: config.hpp:360
viennashe::physics::dispersion_proxy dispersion_relation_holes() const
Returns the dispersion relation for holes.
Definition: config.hpp:260
viennashe::she::scatter_config & scattering()
Returns the configuration object for scattering.
Definition: config.hpp:475
void use_h_transformation(bool b)
Sets whether the H-transformation should be used for the energy discretization.
Definition: config.hpp:467
detail::density_gradient_config const & density_gradient(viennashe::carrier_type_id ctype) const
Definition: config.hpp:519
bool with_quantum_correction() const
Definition: config.hpp:512
void with_quantum_correction(bool b)
Definition: config.hpp:513
nonlinear_solver_config_type const & nonlinear_solver() const
Returns the configuration object for the nonlinear solver.
Definition: config.hpp:497
void adaptive_expansions(bool b)
Sets the use of adaptive expansions.
Definition: config.hpp:381
void min_kinetic_energy_range(double e_new, viennashe::carrier_type_id ctype)
Sets the minimum kinetic energy range for the selected carrier.
Definition: config.hpp:397
bool setup_insulator_distances() const
Definition: config.hpp:546
Exception for the case that a segment or a segment that does not belong to a mesh is encountered.
Definition: exception.hpp:69
Common interface for band structures.
Definition: dispersion.hpp:41
A proxy object for a dispersion relation. Does NOT take ownership of the provided pointer!
Definition: dispersion.hpp:69
Non-parabolic isotropic dispersion relation proposed by Jin et al. TED 2011 (uses real DOS)
Definition: dispersion.hpp:297
Non-parabolic dispersion relation proposed by the Modena group (spherically symmetric).
Definition: dispersion.hpp:208
Parabolic dispersion relation (spherically symmetric)
Definition: dispersion.hpp:117
A configuration class for scattering mechanisms. Enable or disable scattering mechanisms here.
Definition: config.hpp:361
surface_scattering_parameters const & surface() const
Returns the parameters for surface scattering. Const-version.
Definition: config.hpp:402
Exception for the case that an invalid dispersion relation is specified.
Definition: exception.hpp:32
The boundary condition configuration for SHE
Definition: config.hpp:91
void generation_recombination_rate(double new_tau)
Sets the recombination rate used in a Robin boundary condition.
Definition: config.hpp:112
double generation_recombination_rate() const
Returns the recombination rate used in a Robin boundary condition.
Definition: config.hpp:108
viennashe::boundary_type_id type() const
Returns the type of boundary conditions used by SHE.
Definition: config.hpp:96
void type(viennashe::boundary_type_id new_id)
Setter for the type of boundary conditions used by SHE.
Definition: config.hpp:99
A configuration class holding options for use within the different linear solvers.
Definition: config.hpp:57
A configuration class holding options for use within the different linear solvers.
Definition: config.hpp:253
Contains the dispersion relations for different materials and different polarities.
Provides the exceptions used in the main viennashe namespace.
Contains forward declarations and definition of small classes that must be defined at an early stage.
detail::constants constants
Convenience typedef for accessing mathematical constants, e.g. viennashe::math::constants::pi.
Definition: constants.hpp:49
The main ViennaSHE namespace. All functionality resides inside this namespace.
Definition: accessors.hpp:40
she_discretization_type_id
Definition: forwards.h:144
@ SHE_DISCRETIZATION_EVEN_ODD_ORDER_DF
Definition: forwards.h:145
carrier_type_id
Enumeration type for selecting the carrier type.
Definition: forwards.h:185
@ HOLE_TYPE_ID
Definition: forwards.h:188
@ ELECTRON_TYPE_ID
Definition: forwards.h:187
equation_id
An enumeration of all equation types ViennaSHE supports.
Definition: forwards.h:114
@ EQUATION_CONTINUITY
Definition: forwards.h:117
boundary_type_id
An enumeration of all boundary conditions ViennaSHE supports.
Definition: forwards.h:125
@ BOUNDARY_DIRICHLET
Definition: forwards.h:127
@ BOUNDARY_ROBIN
Definition: forwards.h:129
@ BOUNDARY_GENERATION_RECOMBINATION
Definition: forwards.h:130
she_scaling_type_id
Definition: forwards.h:150
@ SHE_SCALING_KINETIC_ENERGY
Definition: forwards.h:151
Provides a number of fundamental constants. All constants in SI units.
Provides the exceptions used inside the viennashe::she namespace.
Scattering operators (and their parameters) are defined here.
Defines a generic simulator quantity for use within the solvers of ViennaSHE.
The SHE configuration class is defined here.
viennashe::robin_boundary_coefficients< double > & robin_coeffs()
Definition: config.hpp:68
viennashe::robin_boundary_coefficients< double > robin_coeffs() const
Definition: config.hpp:67
density_gradient_config(double lambda, double alpha, double beta)
Definition: config.hpp:50
viennashe::boundary_type_id boundary_type() const
Definition: config.hpp:63
void boundary_type(viennashe::boundary_type_id newid)
Definition: config.hpp:65
Provides IDs for the dispersion relations.
Definition: config.hpp:81