np-diode-bipolar.cpp

Go to the documentation of this file.

/* ============================================================================
   Copyright (c) 2011-2022, Institute for Microelectronics,
                            Institute for Analysis and Scientific Computing,
                            TU Wien.
 
                            -----------------
     ViennaSHE - The Vienna Spherical Harmonics Expansion Boltzmann Solver
                            -----------------
 
                    http://viennashe.sourceforge.net/
 
   License:         MIT (X11), see file LICENSE in the base directory
=============================================================================== */
 
#if defined(_MSC_VER)
  // Disable name truncation warning obtained in Visual Studio
  #pragma warning(disable:4503)
#endif
 
#include <iostream>
#include <cstdlib>
#include <vector>
 
// ViennaSHE includes:
#include "viennashe/core.hpp"
 
// ViennaGrid mesh configurations and centroid() algorithm:
#include "viennagrid/config/default_configs.hpp"
#include "viennagrid/algorithm/centroid.hpp"
 
template <typename DeviceType>
void init_device(DeviceType & device)
{
  typedef typename DeviceType::segment_type          SegmentType;
 
  SegmentType const & contact_left  = device.segment(0);
  SegmentType const & n_left        = device.segment(1);
  SegmentType const & i_center      = device.segment(2);
  SegmentType const & p_right       = device.segment(3);
  SegmentType const & contact_right = device.segment(4);
 
  device.set_material(viennashe::materials::metal(), contact_left);
  device.set_material(viennashe::materials::si(),          n_left);
  device.set_material(viennashe::materials::si(),          i_center);
  device.set_material(viennashe::materials::si(),          p_right);
  device.set_material(viennashe::materials::metal(), contact_right);
 
  device.set_doping_n(1e22, n_left);
  device.set_doping_p(1e10, n_left);
 
  device.set_doping_n(1e16, i_center);
  device.set_doping_p(1e16, i_center);
 
  device.set_doping_n(1e10, p_right);
  device.set_doping_p(1e22, p_right);
 
 
  viennashe::trap_level trap;
  trap.collision_cross_section(3.2e-20);
  trap.density(1e21);
  trap.energy(0.3 * viennashe::physics::constants::q);  //  0.3 eV above center of band gap
  device.add_trap_level(trap);
 
  // second trap level with different energy, but same density and collision cross section:
  trap.energy(-0.3 * viennashe::physics::constants::q); // -0.3 eV below center of band gap
  device.add_trap_level(trap);
 
 
  device.set_contact_potential( 0.0, contact_left);
  device.set_contact_potential(-0.2, contact_right);
}
 
 
int main()
{
  typedef viennagrid::quadrilateral_2d_mesh                     MeshType;
  typedef viennashe::device<MeshType>                           DeviceType;
 
  std::cout << viennashe::preamble() << std::endl;
 
  std::cout << "* main(): Creating device..." << std::endl;
  DeviceType device;
 
  viennashe::util::device_generation_config generator_params;
 
  generator_params.add_segment(0.0,    1.0e-7, 2,   //start at x=0,     length 100nm,  2 points
                               0.0,    1.0e-8, 3);  //start at y=0,     length  10nm,  3 points
  generator_params.add_segment(0.0,    1.0e-7, 2,   //start at x=0,     length 100nm,  2 points
                               1.0e-8, 1.0e-7, 21); //start at y= 20nm, length 100nm, 21 points
  generator_params.add_segment(0.0,    1.0e-7, 2,   //start at x=0,     length 100nm,  2 points
                               1.1e-7, 5.0e-9, 2);  //start at y=220nm, length   5nm,  2 points
  generator_params.add_segment(0.0,    1.0e-7, 2,   //start at x=0,     length 100nm,  2 points
                               1.15e-7,1.0e-7, 21); //start at y=230nm, length 100nm, 21 points
  generator_params.add_segment(0.0,    1.0e-7, 2,   //start at x=0,     length 100nm,  2 points
                               2.15e-7,1.0e-8, 3);  //start at y=430,   length  10nm,  3 points
 
  device.generate_mesh(generator_params);
 
  std::cout << "* main(): Initializing device..." << std::endl;
  init_device(device);
 
  std::cout << "* main(): Creating DD simulator..." << std::endl;
 
  viennashe::config dd_cfg; // Per default the config is set to DD with Gummel iterations
 
  // Nonlinear solver: Use up to 100 Gummel iterations with a rather strong damping of 0.2
  dd_cfg.nonlinear_solver().max_iters(100);
  dd_cfg.nonlinear_solver().damping(0.2);
 
  viennashe::simulator<DeviceType> dd_simulator(device, dd_cfg);
 
  std::cout << "* main(): Launching simulator..." << std::endl;
  dd_simulator.run();
 
  viennashe::io::write_quantities_to_VTK_file(dd_simulator, "np-diode_dd_quan");
 
 
  std::cout << "* main(): Setting up SHE..." << std::endl;
 
  viennashe::config config;
  // Configure a first-order bipolar SHE
  config.with_electrons(true);
  config.set_electron_equation(viennashe::EQUATION_SHE);
 
  config.with_holes(true);
  config.set_hole_equation(viennashe::EQUATION_SHE);
 
  config.with_traps(true);
  config.with_trap_selfconsistency(true);
 
  // Linear solver: Set up to 1000 iterations
  config.linear_solver().max_iters(1000);
 
  // Nonlinear solver: Set up to 20 Gummel iterations with a moderate damping of 0.3
  config.nonlinear_solver().max_iters(20);
  config.nonlinear_solver().damping(0.3);
 
  // SHE: Set first-order expansion and use an energy spacing of 12.5 meV
  config.max_expansion_order(1);
  config.energy_spacing(viennashe::physics::constants::q / 80.0);
 
 
  std::cout << "* main(): Computing first-order SHE..." << std::endl;
 
  viennashe::simulator<DeviceType> she_simulator(device, config);
 
  // Use the DD solution as initial guess
  she_simulator.set_initial_guess(viennashe::quantity::potential(),        dd_simulator.potential());
  she_simulator.set_initial_guess(viennashe::quantity::electron_density(), dd_simulator.electron_density());
  she_simulator.set_initial_guess(viennashe::quantity::hole_density(),     dd_simulator.hole_density());
 
  she_simulator.run();
 
  std::cout << "* main(): Writing SHE result..." << std::endl;
  viennashe::io::she_vtk_writer<DeviceType>()(device,
                                              she_simulator.config(),
                                              she_simulator.quantities().electron_distribution_function(),
                                              "np-diode-she");
 
  viennashe::io::write_quantities_to_VTK_file(she_simulator, "np-diode_she_quan");
 
  std::cout << "* main(): Results can now be viewed with your favorite VTK viewer (e.g. ParaView)." << std::endl;
  std::cout << "* main(): Don't forget to scale the z-axis by about a factor of 1e12 when examining the distribution function." << std::endl;
  std::cout << std::endl;
  std::cout << "*********************************************************" << std::endl;
  std::cout << "*           ViennaSHE finished successfully             *" << std::endl;
  std::cout << "*********************************************************" << std::endl;
 
  return EXIT_SUCCESS;
}