nin-diode-2d-hde.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 default mesh configurations:
#include "viennagrid/config/default_configs.hpp"
 
 
template <typename DeviceType>
void init_device(DeviceType & device)
{
  typedef typename DeviceType::mesh_type           MeshType;
  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);
 
  typedef typename viennagrid::result_of::const_cell_range<MeshType>::type   CellContainer;
  typedef typename viennagrid::result_of::iterator<CellContainer>::type      CellIterator;
 
  CellContainer cells(device.mesh());
  for (CellIterator cit = cells.begin();
       cit != cells.end();
       ++cit)
  {
    device.set_lattice_temperature(300.0, *cit);
  }
}
 
 
int main()
{
  typedef viennagrid::triangular_2d_mesh                        MeshType;
  typedef viennashe::device<MeshType>                           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: Up to 80 Gummel iterations:
  dd_cfg.nonlinear_solver().max_iters(80);
 
  // Here we enable the heat equation to solve for temperature explicitly:
  dd_cfg.with_hde(true);
 
 
  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;
 
  // SHE for electrons
  config.with_electrons(true);
  config.set_electron_equation(viennashe::EQUATION_SHE);
 
  // SHE for holes
  config.with_holes(true);
  config.set_hole_equation(viennashe::EQUATION_CONTINUITY);
 
  // Linear solver: Up to 1000 iterations:
  config.linear_solver().max_iters(1000);
 
  // Nonlinear solver: Up to 10 Gummel iterations with a damping parameter of 0.5:
  config.nonlinear_solver().max_iters(10);   //Use higher iteration counts as needed
  config.nonlinear_solver().damping(0.5);
 
  // Explicitly enable the Heat Diffusion Equation:
  config.with_hde(true);
 
  // SHE: Specify a first-order simulation 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-hde_edf");
 
  viennashe::io::write_quantities_to_VTK_file(she_simulator, "nin2d-hde_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;
}