half-trigate-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 default 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 &  source_segment = device.segmentation()[1];
  SegmentType const & channel_segment = device.segmentation()[2];
  SegmentType const &   drain_segment = device.segmentation()[3];
  SegmentType const &   oxide_segment = device.segmentation()[4];
  SegmentType const &    gate_segment = device.segmentation()[5];
  SegmentType const &    body_segment = device.segmentation()[6];
 
  SegmentType const &  source_contact_segment = device.segmentation()[7];
  SegmentType const &   drain_contact_segment = device.segmentation()[8];
  SegmentType const &    body_contact_segment = device.segmentation()[9];
 
  std::cout << "* init_device(): Setting materials..." << std::endl;
  device.set_material(viennashe::materials::metal(), gate_segment);
  device.set_material(viennashe::materials::hfo2(), oxide_segment);
  device.set_material(viennashe::materials::si(),  source_segment);
  device.set_material(viennashe::materials::si(), channel_segment);
  device.set_material(viennashe::materials::si(),   drain_segment);
  device.set_material(viennashe::materials::si(),    body_segment);
 
  device.set_material(viennashe::materials::metal(), source_contact_segment);
  device.set_material(viennashe::materials::metal(),  drain_contact_segment);
  device.set_material(viennashe::materials::metal(),   body_contact_segment);
 
  std::cout << "* init_device(): Setting doping..." << std::endl;
 
  device.set_doping_n(1e18, channel_segment);
  device.set_doping_p(1e14, channel_segment);
 
  device.set_doping_n(1e26, source_segment);
  device.set_doping_p(1e6,  source_segment);
 
  device.set_doping_n(1e26, drain_segment);
  device.set_doping_p(1e6,  drain_segment);
 
  device.set_doping_n(1e18, body_segment);
  device.set_doping_p(1e14, body_segment);
 
  std::cout << "* init_device(): Setting contacts..." << std::endl;
 
  double gnd   = 0.0;
  double vcc   = 0.3;
  double vgate = 0.8;
 
  device.set_contact_potential(vgate, gate_segment);
  device.set_contact_potential(gnd,   source_contact_segment);
  device.set_contact_potential(vcc,   drain_contact_segment);
  device.set_contact_potential(gnd,   body_contact_segment);
}
 
int main(int argc, char** argv)
{
  typedef viennashe::device<viennagrid::tetrahedral_3d_mesh> DeviceType;
 
  std::cout << viennashe::preamble() << std::endl;
 
  int size,opt,s,h;
  std::cout << "* main(): Creating and scaling device..." << std::endl;
  DeviceType device;
  device.load_mesh("../examples/data/half-trigate57656.mesh");
  device.scale(1e-9);
  PetscInitialize(&argc, &argv, (char *) 0, "");
  std::string LSolver("petsc_parallel_linear_solver");
  MPI_Comm_size(MPI_COMM_WORLD, &size);
  PetscInitialize(&argc, &argv, (char *) 0, "");
  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 ;
  std::cout << "* main(): Initializing device..." << std::endl;
  init_device(device);
  if(s == 1 && size != 1) device.refine(size) ;
  std::cout << "* main(): Creating DD simulator..." << std::endl;
 
  // Create the configuration object
  viennashe::config dd_cfg;
 
  // Specify that the drift-diffusion system for electrons and holes,
  // both using the continuity equations, should be solved:
  dd_cfg.with_electrons(true);
  dd_cfg.with_holes(true);
  dd_cfg.set_electron_equation(viennashe::EQUATION_CONTINUITY);
  dd_cfg.set_hole_equation(viennashe::EQUATION_CONTINUITY);
 
  //   dd_cfg.nonlinear_solver().set(viennashe::solvers::nonlinear_solver_ids::newton_nonlinear_solver);
 
  dd_cfg.nonlinear_solver().damping(0.4);  // The damping factor
  dd_cfg.nonlinear_solver().max_iters(50); // Maximum of nonlinear iterations
 
  std::cout << "* main(): Creating and launching DD simulator..." << std::endl;
  viennashe::simulator<DeviceType> dd_simulator(device,   // the device created before
                                                dd_cfg);  // the configuration
  dd_simulator.run();
 
  viennashe::io::write_quantities_to_VTK_file(dd_simulator,            // simulator object
                                              "half-trigate_dd_quan"); // file name
 
 
  std::cout << "* main(): Setting up first-order SHE (non-self consistent!)..." << std::endl;
  viennashe::config config;
 
  config.with_electrons(true); config.with_holes(true);
  config.set_electron_equation(viennashe::EQUATION_SHE); // Use SHE for electrons
  config.set_hole_equation(viennashe::EQUATION_CONTINUITY); // Use DD for holes
 
  config.max_expansion_order(1);
  h == 0 ?config.energy_spacing(0.031 * viennashe::physics::constants::q/N):
    config.energy_spacing(0.031 * viennashe::physics::constants::q/(size));
  config.linear_solver().set(LSolver);
  config.linear_solver().max_iters(2000);
  config.linear_solver().setArgv(argv);
  config.linear_solver().setArgc(argc);
  config.nonlinear_solver().max_iters(1);
 
  std::cout << "* main(): Computing first-order SHE (requires about 5 GB RAM)..." << 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();
 
  PetscFinalize();
  viennashe::io::write_quantities_to_VTK_file(she_simulator,            // simulator object
                                              "half-trigate_she_quan"); // file name
 
  viennashe::io::write_quantity_to_VTK_file(she_simulator.potential(),        device, "trigate_she_potential");
  viennashe::io::write_quantity_to_VTK_file(she_simulator.electron_density(), device, "trigate_she_electrons");
 
  std::cout << "* main(): Results can now be viewed with your favorite VTK viewer (e.g. ParaView)." << std::endl;
  std::cout << std::endl;
  std::cout << "*********************************************************" << std::endl;
  std::cout << "*           ViennaSHE finished successfully             *" << std::endl;
  std::cout << "*********************************************************" << std::endl;
 
  return EXIT_SUCCESS;
 
}