resistor.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, double vcc)
{
  // ViennaGrid types for mesh handling:
  typedef typename DeviceType::mesh_type           MeshType;
 
  typedef typename viennagrid::result_of::const_cell_range<MeshType>::type   CellContainer;
 
  // Container of all cells in the mesh:
  CellContainer cells(device.mesh());
 
  device.set_material(viennashe::materials::si()); // Silicon everywhere
 
  // overwrite the material of the two cells on the left and right:
  device.set_material(viennashe::materials::metal(), cells[0]);
  device.set_material(viennashe::materials::metal(), cells[cells.size()-1]);
 
  std::cout << "* init_device(): Setting doping..." << std::endl;
  device.set_doping_n(1e28);
  device.set_doping_p(1e4);
 
  device.set_contact_potential(0.0, cells[0]);
  device.set_contact_potential(vcc, cells[cells.size()-1]);
}
 
 
int main()
{
  typedef viennagrid::line_1d_mesh       MeshType;
  typedef viennashe::device<MeshType>    DeviceType;
 
  std::cout << viennashe::preamble() << std::endl;
 
  DeviceType device;
 
 
  viennashe::util::device_generation_config generator_params;
 
  generator_params.add_segment(0.0,  1e-6, 11);  //start at x=0, length 1um, 11 points
 
  device.generate_mesh(generator_params);
 
 
  std::cout << "* main(): Initializing device..." << std::endl;
  init_device(device, 1.0);
 
 
  std::cout << "* main(): Creating DD simulator..." << std::endl;
 
  viennashe::config dd_cfg;
 
  // Linear solver: Use a dense linear solver, because the mesh is small (no preconditioning troubles):
  dd_cfg.linear_solver().set(viennashe::solvers::linear_solver_ids::dense_linear_solver);
 
  // Nonlinear solver: 20 Gummel iterations with a damping parameter of 0.25:
  dd_cfg.nonlinear_solver().max_iters(20);
  dd_cfg.nonlinear_solver().damping(0.25);
 
  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, "resistor_dd_quan");
 
  std::cout << "* main(): Setting up SHE..." << std::endl;
 
  viennashe::config config;
 
  config.with_electrons(true);
  config.set_electron_equation(viennashe::EQUATION_SHE);
 
  config.with_holes(true);
  config.set_hole_equation(viennashe::EQUATION_CONTINUITY);
 
  // Nonlinear solver: Only one Gummel iteration with very high damping (to avoid changes to the potential)
  config.nonlinear_solver().max_iters(1);
  config.nonlinear_solver().damping(0.001);
 
  // SHE: First-order simulation using an energy spacing of 15.5meV and a kinetic energy range of at least 1eV:
  config.max_expansion_order(1);
  config.energy_spacing(0.0155 * viennashe::physics::constants::q);
  config.min_kinetic_energy_range(1.0 * viennashe::physics::constants::q);
 
  // configure scattering mechanisms. We use phonon scattering only for now.
  config.scattering().acoustic_phonon().enabled(true);
  config.scattering().optical_phonon().enabled(true);
  config.scattering().ionized_impurity().enabled(false);
  config.scattering().impact_ionization().enabled(false);
  config.scattering().electron_electron(false);
 
 
  std::cout << "* main(): Computing SHE (electrons only) ..." << 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::gnuplot_edf_writer edfwriter;
  edfwriter(device, viennashe::util::any_filter(), she_simulator.edf(viennashe::ELECTRON_TYPE_ID), "resistor_edf.dat");
 
  typedef viennashe::simulator<DeviceType>::she_quantity_type she_quan_type;
  viennashe::she::current_density_wrapper<DeviceType, she_quan_type> Jn(device, config,
                she_simulator.quantities().electron_distribution_function());
 
  viennashe::io::write_cell_quantity_for_gnuplot(Jn, device, "resistor_Jn.dat");
  viennashe::io::write_cell_quantity_for_gnuplot(she_simulator.electron_density(), device, "resistor_n.dat");
 
  viennashe::io::write_quantities_to_VTK_file(she_simulator, "resistor_she_quan");
 
 
  std::cout << "* main(): Computing SHE (electrons only) with EE scattering ..." << std::endl;
  config.nonlinear_solver().max_iters(10);
  config.scattering().electron_electron(true);
 
  viennashe::simulator<DeviceType> she_simulator_ee(device, config);
 
  she_simulator_ee.set_initial_guess(viennashe::quantity::potential(),        she_simulator.potential());
  she_simulator_ee.set_initial_guess(viennashe::quantity::electron_density(), she_simulator.electron_density());
  she_simulator_ee.set_initial_guess(viennashe::quantity::hole_density(),     she_simulator.hole_density());
 
  she_simulator_ee.run();
 
  std::cout << "* main(): Writing SHE result..." << std::endl;
 
  edfwriter(device, viennashe::util::any_filter(), she_simulator_ee.edf(viennashe::ELECTRON_TYPE_ID), "resistor_edf_ee.dat");
 
  viennashe::io::write_cell_quantity_for_gnuplot(she_simulator_ee.electron_density(), device, "resistor_n_ee.dat");
 
  viennashe::she::carrier_energy_wrapper<she_quan_type> avge (config, she_simulator_ee.quantities().electron_distribution_function());
  viennashe::io::write_cell_quantity_for_gnuplot(avge, device, "resistor_avg_ee.dat");
 
  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;
}