nin-diode-2d.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:
#include "viennagrid/config/default_configs.hpp"
 
 
template <typename DeviceType>
void init_device(DeviceType & device)
{
  typedef typename DeviceType::segment_type          SegmentType;
 
  SegmentType const & contact_left  = device.segment(1);
  SegmentType const & i_center      = device.segment(3);
  SegmentType const & contact_right = device.segment(5);
 
  device.set_material(viennashe::materials::si());
  device.set_doping_n(1e24);
  device.set_doping_p(1e8);
 
  device.set_doping_n(1e21, i_center);
  device.set_doping_p(1e11, i_center);
 
  device.set_material(viennashe::materials::metal(), contact_left);
  device.set_material(viennashe::materials::metal(), contact_right);
 
  device.set_contact_potential(0.0, contact_left);
  device.set_contact_potential(0.5, contact_right);
}
 
 
int main()
{
  typedef viennashe::device<viennagrid::triangular_2d_mesh>       DeviceType;
 
  std::cout << viennashe::preamble() << std::endl;
 
  std::cout << "* main(): Creating device..." << std::endl;
  DeviceType device;
  device.load_mesh("../examples/data/nin2d.mesh");
  device.scale(1e-8);
 
  std::cout << "* main(): Creating device..." << std::endl;
  init_device(device);
 
 
  std::cout << "* main(): Creating DD simulator..." << std::endl;
 
 
  viennashe::config dd_cfg;
 
  // Nonlinear solver: Use up to 40 Gummel iterations:
  dd_cfg.nonlinear_solver().max_iters(40);
 
 
  viennashe::simulator<DeviceType> dd_simulator(device, dd_cfg);
  std::cout << "* main(): Launching DD simulator..." << std::endl;
  dd_simulator.run();
 
  viennashe::io::write_quantities_to_VTK_file(dd_simulator, "nin2d_dd_quan");
 
 
 
  std::cout << "* main(): Setting up SHE..." << std::endl;
 
  viennashe::config config;
 
  // Specify SHE for electrons:
  config.with_electrons(true);
  config.set_electron_equation(viennashe::EQUATION_SHE);
 
  // Nonlinear solver: Up to 20 Gummel iterations with moderate damping of 0.5
  config.nonlinear_solver().max_iters(20);
  config.nonlinear_solver().damping(0.5);
 
  // SHE: Maximum expansion order 1 with an energy spacing of 31 meV:
  config.max_expansion_order(1);
  config.energy_spacing(31.0 * viennashe::physics::constants::q / 1000.0);
 
 
  std::cout << "* main(): Computing SHE..." << std::endl;
  viennashe::simulator<DeviceType> she_simulator(device, config);
  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(),
                                              "nin2d_edf");
 
  viennashe::io::write_quantities_to_VTK_file(she_simulator, "nin2d_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 1e11 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;
}