dispersion.hpp

Go to the documentation of this file.

#ifndef VIENNASHE_PHYSICS_DISPERSION_HPP
#define VIENNASHE_PHYSICS_DISPERSION_HPP
 
/* ============================================================================
   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
=============================================================================== */
 
#include "viennashe/materials/all.hpp"
#include "viennashe/math/constants.hpp"
#include "viennashe/physics/constants.hpp"
#include "viennashe/physics/physics.hpp"
 
#include "viennashe/materials/dos_RSi.hpp"
 
#include <math.h>
 
namespace viennashe
{
  namespace physics
  {
 
    class dispersion_base
    {
      public:
        virtual double density_of_states(double ekin, double theta = 0, double phi = 0) const = 0;
 
        virtual double velocity(double ekin, double theta = 0, double phi = 0) const = 0;
 
        virtual double norm_k(double ekin, double theta = 0, double phi = 0) const = 0;
 
        virtual bool is_isotropic() const { return true; }  //be isotropic by default
 
        virtual dispersion_base * clone() const = 0;
 
        virtual double symmetry_factor() const = 0;
 
        virtual ~dispersion_base() {}
    };
 
 
    class dispersion_proxy
    {
      public:
        dispersion_proxy(dispersion_base const * ptr) : ptr_(ptr) {}
 
        double density_of_states(double ekin, double theta = 0, double phi = 0) const
        {
          return ptr_->density_of_states(ekin, theta, phi);
        }
 
        double velocity(double ekin, double theta = 0, double phi = 0) const
        {
          return ptr_->velocity(ekin, theta, phi);
        }
 
        double norm_k(double ekin, double theta = 0, double phi = 0) const
        {
          return ptr_->norm_k(ekin, theta, phi);
        }
 
        bool is_isotropic() const
        {
          return ptr_->is_isotropic();
        }
 
        dispersion_base const * get() const { return ptr_; }
 
        double symmetry_factor() const { return ptr_->symmetry_factor(); }
 
      private:
        dispersion_base const * ptr_;
    };
 
 
    template <typename MaterialType>
    class parabolic_dispersion : public dispersion_base
    {
        typedef parabolic_dispersion   self_type;
 
      public:
        parabolic_dispersion(viennashe::carrier_type_id ctype) : carrier_type_id_(ctype) {}
 
        /*double energy(double k_norm) const
        {
          double hbar = constants::hbar;
          double mstar = constants::mstar;
          return hbar*hbar * k_norm * k_norm / (2.0 * mstar);
        }*/
 
        double norm_k(double energy, double theta = 0, double phi = 0) const
        {
          (void)theta;(void)phi; //prevents unused parameter warnings
          if (energy <= 0.0)
            return 0.0;
 
          double hbar = constants::hbar;
          double mstar = MaterialType::dos_effective_mass(carrier_type_id_);
          return sqrt( 2.0 * energy * mstar / (hbar * hbar) );
        }
 
        double density_of_states(double eps, double theta = 0, double phi = 0) const
        {
          (void)theta;(void)phi; //prevents unused parameter warnings
          if (eps < 0.0)
            return 0.0;
 
          const double hbar = constants::hbar;
          const double mstar = MaterialType::dos_effective_mass(carrier_type_id_);
          const double pi = viennashe::math::constants::pi;
          const double prefactor = mstar * sqrt(2.0 * mstar) / (8.0 * pi * pi * pi * hbar * hbar * hbar);
 
          return prefactor
                * sqrt(eps);
        }
 
        double velocity(double eps, double theta = 0, double phi = 0) const
        {
          (void)theta;(void)phi; //prevents unused parameter warnings
          if (eps < 0.0)
            return 0.0;
 
          double m_c = MaterialType::conductivity_effective_mass(carrier_type_id_);
          double m_d = MaterialType::dos_effective_mass(carrier_type_id_);
 
          return sqrt(m_c / m_d)  //due to Herring-Vogt transform (see paper by Jin et al.)
                 * sqrt( 2.0 * eps / MaterialType::dos_effective_mass(carrier_type_id_) );
        }
 
        dispersion_base * clone() const { return new self_type(carrier_type_id_); }
 
        double symmetry_factor() const
        {
          if (carrier_type_id_ == ELECTRON_TYPE_ID)
            return 6.0;
          return 4.0;
        }
 
      private:
        viennashe::carrier_type_id carrier_type_id_;
    };
 
 
    template <typename MaterialType>
    class modena_dispersion : public dispersion_base
    {
      public:
        modena_dispersion(viennashe::carrier_type_id ctype, double a = 0.5 / viennashe::physics::constants::q) : carrier_type_id_(ctype), alpha(a) {}
 
        double norm_k(double energy, double theta = 0, double phi = 0) const
        {
          (void)theta;(void)phi; //prevents unused parameter warnings
          if (energy < 0.0)
            return 0.0;
 
          const double hbar = constants::hbar;
          const double mstar = MaterialType::dos_effective_mass(carrier_type_id_);
          return sqrt( 2.0 * energy * (1.0 + alpha * energy) * mstar / (hbar * hbar) );
        }
 
        double density_of_states(double eps, double theta = 0, double phi = 0) const
        {
          (void)theta;(void)phi; //prevents unused parameter warnings
          if (eps > 0.0)
          {
            const double hbar = constants::hbar;
            const double mstar = MaterialType::dos_effective_mass(carrier_type_id_);
            const double pi = viennashe::math::constants::pi;
            const double prefactor = mstar * sqrt(2.0 * mstar) / (8.0 * pi * pi * pi * hbar * hbar * hbar);
 
            return prefactor * 4.0 * pi
                   * (1.0 + 2.0 * alpha * eps)
                   * sqrt( eps * (1.0 + alpha * eps));
          }
 
          return 0.0;
        }
 
        double velocity(double eps, double theta = 0, double phi = 0) const
        {
          (void)theta;(void)phi; //prevents unused parameter warnings
          if (eps < 0)
            return 0;
 
          double gamma = eps * (1.0 + alpha * eps);
          double dgam = 1.0 + 2.0 * alpha * eps;  //derivative of gamma w.r.t. eps
 
          double m_c = MaterialType::conductivity_effective_mass(carrier_type_id_);
          double m_d = MaterialType::dos_effective_mass(carrier_type_id_);
 
          return sqrt(m_c / m_d)  //due to Herring-Vogt transform (see paper by Jin et al.)
                 * sqrt( 2.0 * gamma / MaterialType::dos_effective_mass(carrier_type_id_)) / dgam;
        }
 
        dispersion_base * clone() const { return new modena_dispersion(carrier_type_id_, alpha); }
 
        double symmetry_factor() const
        {
          if (carrier_type_id_ == ELECTRON_TYPE_ID)
            return 6.0;
          return 4.0;
        }
 
      private:
        viennashe::carrier_type_id carrier_type_id_;
        double alpha;
    };
 
 
    template <typename MaterialType>
    class ext_vecchi_dispersion : public dispersion_base
    {
      public:
        ext_vecchi_dispersion(viennashe::carrier_type_id ctype, double a = 0.5 / viennashe::physics::constants::q) : carrier_type_id_(ctype), alpha(a)  {}
 
        double norm_k(double energy, double theta = 0, double phi = 0) const
        {
          (void)theta;(void)phi; //prevents unused parameter warnings
          if (energy < 0.0) { return 0.0; }
 
          //throw dispersion_not_invertible_exception("Cannot invert dispersion relation for extended Vecchi model!");
          //return 0;
 
          double hbar = constants::hbar;
          double mstar = MaterialType::dos_effective_mass(carrier_type_id_);
          return sqrt( 2.0 * energy * mstar / (hbar * hbar) );
        }
 
        double density_of_states(double eps, double theta = 0, double phi = 0) const
        {
          (void)theta;(void)phi; //prevents unused parameter warnings
          if (eps > 0.0)
            return viennashe::materials::dos_relaxed_silicon::get_density_of_states(eps, carrier_type_id_);
 
          return 0.0;
        }
 
        double velocity(double eps, double theta = 0, double phi = 0) const
        {
          (void)theta;(void)phi; //prevents unused parameter warnings
          if (eps > 0.0)
          {
            const double m_c = MaterialType::conductivity_effective_mass(carrier_type_id_);
            const double m_d = MaterialType::dos_effective_mass(carrier_type_id_);
 
            return sqrt(m_c / m_d)  // due to Herring-Vogt transform
                   * viennashe::materials::dos_relaxed_silicon::get_group_velocity(eps, carrier_type_id_);
          }
 
          return 0.0;
        }
 
        dispersion_base * clone() const { return new ext_vecchi_dispersion(carrier_type_id_); }
 
        double symmetry_factor() const
        {
          if (carrier_type_id_ == ELECTRON_TYPE_ID)
            return 6.0;
          return 4.0;
        }
 
      private:
        viennashe::carrier_type_id carrier_type_id_;
        double alpha;
    };
 
 
 
  } //namespace physics
} //namespace viennashe
 
#endif