mosfet-PETSC.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>
#include <petscksp.h>
#include <unistd.h>
// ViennaSHE includes:
#include "viennashe/core.hpp"
 
// ViennaGrid mesh configurations:
#include "viennagrid/config/default_configs.hpp"
#define N 16
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(1.0, drain_contact);
  device.set_contact_potential(0.0, body_contact);
 
}
 
int main(int argc, char **argv)
{
  int size,opt,s,h;
  typedef viennashe::device<viennagrid::triangular_2d_mesh> DeviceType;
  typedef DeviceType::segment_type SegmentType;
  std::string LSolver("petsc_parallel_linear_solver");
  std::cout << viennashe::preamble() << std::endl;
  PetscInitialize(&argc, &argv, (char *) 0, "");
  MPI_Comm_size(MPI_COMM_WORLD, &size);
  opt = getopt(argc, argv, "seS");
  switch(opt){
    case 's': s = 1;h = 0 ; break; // Space refining
    case 'e': s = 0;h = 1 ; break; // Energy refining
    case 'S': s = 0;h = 0 ; break; // Strong Scale
    default:
      break;
  }
 
  s = 0;h = 0 ;
// Set MPI here just to fix bug
//  int world_rank;
//  int error = MPI_Init(&argc, &argv);
//  MPI_Comm_rank(MPI_COMM_WORLD, &world_rank);
 
  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);
  if(s == 1 && size != 1) device.refine(size) ;
//  if (world_rank == 0)
//  {
 
    std::cout << "* main(): Creating DD simulator..." << std::endl;
 
    viennashe::config dd_cfg;
 
    // enable electrons and holes and specify that for each of them a continuity equation should be solved:
    dd_cfg.with_electrons(true);
    dd_cfg.with_holes(true);
    dd_cfg.linear_solver().setArgv(argv);
    dd_cfg.linear_solver().setArgc(argc);
    // dd_cfg.linear_solver().set(LSolver);
    // enable the use of PETSc on the simulator
    dd_cfg.set_electron_equation(viennashe::EQUATION_CONTINUITY);
    dd_cfg.set_hole_equation(viennashe::EQUATION_CONTINUITY);
 
    // Nonlinear solver parameters: 200 Gummel iterations with rather high damping
    //dd_cfg.nonlinear_solver().set("newton");
    dd_cfg.nonlinear_solver().setThreshold(200);
    dd_cfg.nonlinear_solver().max_iters(200);
    dd_cfg.nonlinear_solver().damping(0.125);
 
    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_petsc_dd_quan");
 
    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 (
//        true, true, false, false, false, true, false,
//        viennashe::solvers::linear_solver_ids::petsc_parallel_linear_solver,
//        viennashe::solvers::nonlinear_solver_ids::PETSC_nonlinear_solver);
//  }
  viennashe::config config;
  // Set the expansion order to 1 for SHE
  config.max_expansion_order(1);
 
  // Use both carrier types
  config.with_electrons(true);
  config.with_holes(true);
 
  // Configure equation
  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
  h == 0 ?config.energy_spacing(0.031 * viennashe::physics::constants::q/N):
      config.energy_spacing(0.031 * viennashe::physics::constants::q/(size));
 
  // Set the scattering mechanisms
  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().set(LSolver);
  config.linear_solver().max_iters(2000);
  config.linear_solver().setArgv(argv);
  config.linear_solver().setArgc(argc);
 
  // Configure the nonlinear solver to 40 Gummel iterations with a damping parameter 0.4
  config.nonlinear_solver().setThreshold(800);
  config.nonlinear_solver().max_iters(50);
  // config.nonlinear_solver().set("newton");
  config.nonlinear_solver().damping(0.4); // 0.2|800 - 0.4|276 - 0.6|182 - 0.8|135 - 1|108 - 1.1|97
 
  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());
 //      }
// Trigger the actual simulation:
  she_simulator.run();
 
// Finalize PETSC
//  viennashe::solvers::PETSC_handler<NumericT,VectorType>::finalize();
 
//  if (world_rank == 0)
//       {
  PetscFinalize();
  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_petsc_she_edf");
 
//  viennashe::io::write_quantity_to_VTK_file(she_simulator.potential(), device,
 //     "mosfet_petsc_she_potential");
 // viennashe::io::write_quantity_to_VTK_file(she_simulator.electron_density(),
  //    device, "mosfet_petsc_she_electrons");
 
 // viennashe::io::write_quantities_to_VTK_file<DeviceType>(she_simulator,
  //    "mosfet_petsc_she_quan");
 
//  std::cout << "* main(): Drain hole current Id_e = "
//      << viennashe::get_terminal_current(device, config,
//          she_simulator.quantities().electron_distribution_function(), body,
//          drain_contact) * 1e-6 << std::endl;
//  std::cout << "Id_h = " << viennashe::get_terminal_current(
//      device, config, she_simulator.quantities().hole_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;
 
  //     }
 // PetscFinalize();
  //MPI_Finalize();
  return EXIT_SUCCESS;
}