1#ifndef VIENNASHE_SHE_SCATTERING_SURFACE_ACOUSTIC_PHONON_SCATTERING_HPP
2#define VIENNASHE_SHE_SCATTERING_SURFACE_ACOUSTIC_PHONON_SCATTERING_HPP
18#ifdef VIENNASHE_USE_DISABLED_CODE
34#include "viennagrid/forwards.h"
35#include "viennagrid/algorithm/inner_prod.hpp"
36#include "viennagrid/algorithm/norm.hpp"
51 template <
typename DeviceType,
typename ControllerType,
typename ElectricFieldAccessor>
52 class surface_acoustic_phonon_scattering :
public scattering_base<DeviceType, ControllerType>
54 typedef scattering_base<DeviceType, ControllerType> base_type;
55 typedef typename base_type::FacetType FacetType;
56 typedef typename base_type::CellType CellType;
59 typedef typename base_type::scatter_processes_type scatter_processes_type;
60 typedef scatter_processes_type value_type;
62 explicit surface_acoustic_phonon_scattering(
const viennashe::materials::surface_acoustic_phonon_scattering_parameters & params,
63 ElectricFieldAccessor
const & Efield)
64 : _params(params), _Efield(Efield) { }
67 scatter_processes_type operator()(DeviceType
const & device,
68 ControllerType
const & controller,
69 VertexType
const & elem,
70 double kinetic_energy,
73 return get(device, controller, elem, kinetic_energy, ctype);
76 scatter_processes_type operator()(DeviceType
const & device,
77 ControllerType
const & controller,
78 EdgeType
const & elem,
79 double kinetic_energy,
82 return get(device, controller, elem, kinetic_energy, ctype);
100 template <
typename ElementType>
101 scatter_processes_type get(DeviceType
const & device,
102 ControllerType
const & controller,
103 ElementType
const & elem,
104 double kinetic_energy,
107 scatter_processes_type result(1);
110 result[0].initial_energy(kinetic_energy);
111 result[0].final_energy(kinetic_energy);
112 result[0].rate(getScatteringRate(device, controller, elem, kinetic_energy, ctype));
117 template <
typename DeviceType,
typename ControllerType,
typename ElementType>
118 double getScatteringRate(DeviceType
const & device,
119 ControllerType
const & controller,
120 ElementType
const & elem,
121 double kinetic_energy,
124 const double temp = device.get_lattice_temperature(elem);
125 const double Ep = this->get_electric_field_n(device, elem);
127 double rate = this->getScatteringRate(temp, Ep, ctype);
130 if ( std::abs(rate) < std::numeric_limits<double>::epsilon() ) rate = 0.0;
135 template <
typename DeviceType >
136 double get_electric_field_n(DeviceType
const & device,
137 typename viennagrid::result_of::ncell<typename DeviceType::mesh_type::config_type, 0 > ::type
const & vt)
const
139 typedef typename DeviceType::mesh_type MeshType;
140 typedef typename MeshType::config_type Config;
141 typedef typename Config::cell_tag CellTag;
142 typedef typename viennagrid::result_of::point<Config>::type PointType;
145 typename ElectricFieldAccessor::value_type Eacc = _Efield(vt);
146 for ( std::size_t i = 0; i < PointType::dim; i++) E[i] = Eacc[i];
148 PointType n = device.vector_to_next_insulator(vt);
150 if ( distance > 0) n /= distance;
152 return viennagrid::inner_prod(E, n);
155 template <
typename DeviceType >
156 double get_electric_field_n(DeviceType
const & device,
157 typename viennagrid::result_of::ncell<typename DeviceType::mesh_type::config_type, 1 > ::type
const & edge)
const
159 typedef typename DeviceType::mesh_type MeshType;
160 typedef typename MeshType::config_type Config;
161 typedef typename Config::cell_tag CellTag;
162 typedef typename viennagrid::result_of::point<Config>::type PointType;
163 typedef typename viennagrid::result_of::ncell<typename DeviceType::mesh_type::config_type, 0 > ::type VertexType;
165 const double Emag = _Efield(edge);
166 VertexType
const & vt1 = viennagrid::ncells < 0 > (edge)[0];
167 VertexType
const & vt2 = viennagrid::ncells < 0 > (edge)[1];
169 PointType n = 0.5 * ( device.vector_to_next_insulator(vt1) + device.vector_to_next_insulator(vt2) );
171 if ( distance > 0) n /= distance;
173 PointType E = (vt2.point() - vt1.point()) ;
176 return viennagrid::inner_prod(E, n);
183 const double delta = _params.get_potential_well_strength(ctype);
187 if (Ep == 0.0)
return 0.0;
188 return q / (3.0 * kB * T / (2.0 * Ep) + delta * std::pow((hbar * q * hbar * q) / (mstar * Ep), 1.0 / 3.0));
195 const double ul = _params.get_longitudinal_sound_velocity(ctype);
196 const double E1 = _params.get_deformation_potential(ctype);
197 const double rho = _params.get_mass_density(ctype);
200 if (Ep == 0.0)
return 0.0;
203 double scattering_rate = 2.0 * pi * kB * T * E1 * E1 / (hbar * ul * ul * rho);
204 scattering_rate = scattering_rate * this->getSurfaceInversionLayerWidth(T, Ep, ctype);
208 return _params.get_fit_factor() * scattering_rate;
213 viennashe::materials::surface_acoustic_phonon_scattering_parameters _params;
214 ElectricFieldAccessor
const & _Efield;
Contains the definition of per-device accessors (read-only!) for various quantities.
Contains the dispersion relations for different materials and different polarities.
A logging facility providing fine-grained control over logging in ViennaSHE.
A very simple material database. Needs to be replaced by something more versatile soon.
Provides a number of fundamental math constants.
VectorType::value_type norm_2(VectorType const &v)
@ SURFACE_ACOUSTIC_PHONON_SCATTERING
The main ViennaSHE namespace. All functionality resides inside this namespace.
carrier_type_id
Enumeration type for selecting the carrier type.
Provides a number of fundamental constants. All constants in SI units.
Returns a few helper routines for computing physical quantities. To be replaced in the future.
static double dos_effective_mass(viennashe::carrier_type_id ctype)
static const double pi
Pi.
static const double q
Elementary charge.
static const double kB
Boltzmann constant.
static const double hbar
Modified Planck constant.
Defines the log keys used within the viennashe::she namespace.
Common classes for scattering operators.