mosfet-dg.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 & gate_contact   = device.segment(1);
  SegmentType const & source_contact = device.segment(2);
  SegmentType const & gate_oxide     = device.segment(3);
  SegmentType const & drain_contact  = device.segment(4);
  SegmentType const & source         = device.segment(5);
  SegmentType const & drain          = device.segment(6);
  SegmentType const & body           = device.segment(7);
  SegmentType const & body_contact   = device.segment(8);
 
  std::cout << "* init_device(): Setting materials..." << std::endl;
  device.set_material(viennashe::materials::metal(),   gate_contact);
  device.set_material(viennashe::materials::metal(), source_contact);
  device.set_material(viennashe::materials::metal(),  drain_contact);
  device.set_material(viennashe::materials::metal(),   body_contact);
 
  device.set_material(viennashe::materials::hfo2(), gate_oxide);
 
  device.set_material(viennashe::materials::si(),  source);
  device.set_material(viennashe::materials::si(),   drain);
  device.set_material(viennashe::materials::si(),    body);
 
  std::cout << "* init_device(): Setting doping..." << std::endl;
  device.set_doping_n(1e24, source);
  device.set_doping_p(1e8,  source);
 
  device.set_doping_n(1e24, drain);
  device.set_doping_p(1e8,  drain);
 
  device.set_doping_n(1e17, body);
  device.set_doping_p(1e15, body);
 
  device.set_contact_potential(0.8, gate_contact);
  device.set_contact_potential(0.0, source_contact);
  device.set_contact_potential(0.1, drain_contact);
  device.set_contact_potential(0.0, body_contact);
 
}
 
 
int main()
{
  typedef viennashe::device<viennagrid::triangular_2d_mesh>       DeviceType;
  typedef DeviceType::segment_type                                SegmentType;
 
  std::cout << viennashe::preamble() << std::endl;
 
  std::cout << "* main(): Creating and scaling device..." << std::endl;
  DeviceType device;
  device.load_mesh("../examples/data/mosfet840.mesh");
  device.scale(1e-9);
 
 
  std::cout << "* main(): Initializing device..." << std::endl;
  init_device(device);
 
  std::cout << "* main(): Creating DD simulator..." << std::endl;
 
  viennashe::config dd_cfg;
 
  // Nonlinear solver parameters: 50 Gummel iterations with moderate damping
  dd_cfg.nonlinear_solver().max_iters(50);
  dd_cfg.nonlinear_solver().damping(0.5);
 
  dd_cfg.quantum_correction(true);
  dd_cfg.with_quantum_correction(false);
 
  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, "mosfet-dg_dd_quan");
 
  // Write only the density gradient correction to a separate VTK file:
  viennashe::io::write_quantity_to_VTK_file(dd_simulator.dg_pot_n(), device, "mosfet-dg_dgpot");
 
  SegmentType const & drain_contact  = device.segment(4);
  SegmentType const & body           = device.segment(6);
 
  std::cout << "* main(): Drain electron current Id_e = " << viennashe::get_terminal_current(device, viennashe::ELECTRON_TYPE_ID,
      dd_simulator.potential(), dd_simulator.electron_density(),
      viennashe::models::create_constant_mobility_model(device, 0.1430),
      body, drain_contact ) * 1e-6 << std::endl;
  std::cout << "* main(): Drain hole current Id_h = " << viennashe::get_terminal_current(device, viennashe::HOLE_TYPE_ID,
      dd_simulator.potential(), dd_simulator.hole_density(),
      viennashe::models::create_constant_mobility_model(device, 0.0460),
      body, drain_contact ) * 1e-6 << std::endl;
 
  std::cout << "* main(): Setting up first-order SHE (semi-self-consistent using 40 Gummel iterations)..." << std::endl;
  viennashe::config config;
 
  // Set the expansion order to 1 for a first-order SHE
  config.max_expansion_order(1);
 
  // Use both carrier types
  config.with_electrons(true); config.with_holes(true);
 
  // Configure equations: SHE for electrons, continuity for holes:
  config.set_electron_equation(viennashe::EQUATION_SHE); // SHE for electrons
  config.set_hole_equation(viennashe::EQUATION_CONTINUITY); // DD for holes
 
  // Energy spacing of 31 meV
  config.energy_spacing(31.0 * viennashe::physics::constants::q / 1000.0);
 
  // Set the scattering mechanisms: We use phonon scattering, but no ionized impurity scattering
  config.scattering().acoustic_phonon().enabled(true);
  config.scattering().optical_phonon().enabled(true);
  config.scattering().ionized_impurity().enabled(false);
 
  // The linear solver should run for at most 2000 iterations:
  config.linear_solver().max_iters(2000);
 
  // The nonlinear solver should use up to 40 Gummel iterations with a damping parameter of 0.4:
  config.nonlinear_solver().max_iters(40);
  config.nonlinear_solver().damping(0.4);
 
  // Configure the first-order quantum correction
  config.quantum_correction(true);       // Solve density gradient ...
  config.with_quantum_correction(false); // ... but don't use it to correct the potential (cf. DD solver above)
 
  std::cout << "* main(): Computing first-order SHE..." << std::endl;
  viennashe::simulator<DeviceType> she_simulator(device, config);
 
  // Set the previous DD solution as an 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.set_initial_guess(viennashe::quantity::density_gradient_electron_correction(), dd_simulator.dg_pot_n());
  she_simulator.set_initial_guess(viennashe::quantity::density_gradient_hole_correction(), dd_simulator.dg_pot_p());
 
  // Run the simulation
  she_simulator.run();
 
  std::cout << "* main(): Writing energy distribution function from first-order SHE result..." << std::endl;
  viennashe::io::she_vtk_writer<DeviceType>()(device,
                                              she_simulator.config(),
                                              she_simulator.quantities().electron_distribution_function(),
                                              "mosfet-dg_she_edf");
 
  viennashe::io::write_quantity_to_VTK_file(she_simulator.potential(), device, "mosfet-dg_she_potential");
  viennashe::io::write_quantity_to_VTK_file(she_simulator.electron_density(), device, "mosfet-dg_she_electrons");
 
  viennashe::io::write_quantities_to_VTK_file(she_simulator, "mosfet-dg_she_quan");
 
  std::cout << "* main(): Drain electron current Id_e = " << viennashe::get_terminal_current(
      device, config, she_simulator.quantities().electron_distribution_function(), body, drain_contact ) * 1e-6
      << std::endl;
 
  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;
 
}