Add effective DOS classes for the Charge solver

tidy3d/__init__.py

@@ -52,13 +52,17 @@
 from tidy3d.components.tcad.types import (
     AugerRecombination,
     CaugheyThomasMobility,
+    ConstantEffectiveDOS,
     ConstantMobilityModel,
     ConvectionBC,
     CurrentBC,
+    DualValleyEffectiveDOS,
     HeatFluxBC,
     HeatFromElectricSource,
     HeatSource,
     InsulatingBC,
+    IsotropicEffectiveDOS,
+    MultiValleyEffectiveDOS,
     RadiativeRecombination,
     ShockleyReedHallRecombination,
     SlotboomBandGapNarrowing,
@@ -606,6 +610,10 @@ def set_logging_level(level: str) -> None:
     "SteadyCapacitanceData",
     "CaugheyThomasMobility",
     "ConstantMobilityModel",
+    "ConstantEffectiveDOS",
+    "IsotropicEffectiveDOS",
+    "MultiValleyEffectiveDOS",
+    "DualValleyEffectiveDOS",
     "SlotboomBandGapNarrowing",
     "ShockleyReedHallRecombination",
     "FossumCarrierLifetime",

tidy3d/components/material/tcad/charge.py

@@ -11,6 +11,7 @@
 from tidy3d.components.tcad.doping import DopingBoxType
 from tidy3d.components.tcad.types import (
     BandGapNarrowingModelType,
+    EffectiveDOSModelType,
     MobilityModelType,
     RecombinationModelType,
 )
@@ -256,14 +257,14 @@ class SemiconductorMedium(AbstractChargeMedium):
 
     """
 
-    N_c: pd.PositiveFloat = pd.Field(
+    N_c: Union[pd.PositiveFloat, EffectiveDOSModelType] = pd.Field(
         ...,
         title="Effective density of electron states",
         description=r"$N_c$ Effective density of states in the conduction band.",
         units="cm^(-3)",
     )
 
-    N_v: pd.PositiveFloat = pd.Field(
+    N_v: Union[pd.PositiveFloat, EffectiveDOSModelType] = pd.Field(
         ...,
         title="Effective density of hole states",
         description=r"$N_v$ Effective density of states in the valence band.",

tidy3d/components/tcad/effective_DOS.py

@@ -0,0 +1,158 @@
+from abc import ABC, abstractmethod
+
+import numpy as np
+import pydantic.v1 as pd
+
+from tidy3d.components.base import Tidy3dBaseModel
+from tidy3d.constants import C_0, HBAR, K_B
+
+from ...exceptions import DataError
+
+# constants definition
+m_e_C_square = 0.51099895069e6  # (electron mass * C_0^2) in eV
+m_e_eV = 0.51099895069e6 / C_0 / C_0  # equivalent electron mass in eV
+um_3_to_cm_3 = 1e12  # conversion factor from micron^(-3) to cm^(-3)
+
+DOS_aux_const = 2.0 * np.power((m_e_eV * K_B) / (2 * np.pi * HBAR * HBAR), 1.5) * um_3_to_cm_3
+
+
+class EffectiveDOS(Tidy3dBaseModel, ABC):
+    """Abstract class for the effective density of states"""
+
+    @abstractmethod
+    def _calc_eff_DOS(self, T: float):
+        """Abstract method to calculate the effective density of states."""
+        pass
+
+    @abstractmethod
+    def _calc_eff_DOS_derivative(self, T: float):
+        """Abstract method to calculate the temperature derivative of the effective density of states."""
+        pass
+
+    def get_effective_DOS(self, T: float):
+        if T <= 0:
+            raise DataError(
+                f"Incorrect temperature value ({T}) for the effectve density of states calculation."
+            )
+
+        return self._calc_eff_DOS(T)
+
+    def get_effective_DOS_derivative(self, T: float):
+        if T <= 0:
+            raise DataError(
+                f"Incorrect temperature value ({T}) for the effectve density of states calculation."
+            )
+
+        return self._calc_eff_DOS_derivative(T)
+
+
+class ConstantEffectiveDOS(EffectiveDOS):
+    """Constant effective density of states model."""
+
+    N: pd.PositiveFloat = pd.Field(
+        ..., title="Effective DOS", description="Effective density of states", units="cm^(-3)"
+    )
+
+    def _calc_eff_DOS(self, T: float):
+        return self.N
+
+    def _calc_eff_DOS_derivative(self, T: float):
+        return 0.0
+
+
+class IsotropicEffectiveDOS(EffectiveDOS):
+    """Effective density of states model that assumes single valley and isotropic effective mass.
+    The model assumes the standard equation for the 3D semiconductor with parabolic energy dispersion:
+
+    .. math::
+
+        \\begin{equation}
+             \\mathbf{N_eff} = 2 * (\\frac{m_eff * m_e * k_B T}{2 \\pi \\hbar^2})^(3/2)
+        \\end{equation}
+    """
+
+    m_eff: pd.PositiveFloat = pd.Field(
+        ...,
+        title="Effective mass",
+        description="Effective mass of the carriers",
+        units="Electron mass",
+    )
+
+    def _calc_eff_DOS(self, T: float):
+        return np.power(self.m_eff * T, 1.5) * DOS_aux_const
+
+    def _calc_eff_DOS_derivative(self, T: float):
+        return self._calc_eff_DOS(T) * 1.5 / T
+
+
+class MultiValleyEffectiveDOS(EffectiveDOS):
+    """Effective density of states model that assumes multiple equivalent valleys and anisotropic effective mass.
+    The model assumes the standard equation for the 3D semiconductor with parabolic energy dispersion:
+
+    .. math::
+
+        \\begin{equation}
+             \\mathbf{N_eff} = 2 * N_valley (\\frac{(m_{eff_long} * m_{eff_trans} * m_{eff_trans})^(1/2) * m_e * k_B * T}{2 \\pi * \\hbar^2})^(3/2)
+        \\end{equation}
+    """
+
+    m_eff_long: pd.PositiveFloat = pd.Field(
+        ...,
+        title="Longitudinal effective mass",
+        description="Effective mass of the carriers in the longitudinal direction",
+        units="Electron mass",
+    )
+
+    m_eff_trans: pd.PositiveFloat = pd.Field(
+        ...,
+        title="Longitudinal effective mass",
+        description="Effective mass of the carriers in the transverse direction",
+        units="Electron mass",
+    )
+
+    N_valley: pd.PositiveFloat = pd.Field(
+        ..., title="Number of valleys", description="Number of effective valleys"
+    )
+
+    def _calc_eff_DOS(self, T: float):
+        return (
+            self.N_valley
+            * np.power(self.m_eff_long * self.m_eff_trans * self.m_eff_trans, 0.5)
+            * np.power(T, 1.5)
+            * DOS_aux_const
+        )
+
+    def _calc_eff_DOS_derivative(self, T: float):
+        return self._calc_eff_DOS(T) * 1.5 / T
+
+
+class DualValleyEffectiveDOS(EffectiveDOS):
+    """Effective density of states model that assumes combibation of light holes and heavy holes with isotropic effective masses.
+    The model assumes the standard equation for the 3D semiconductor with parabolic energy dispersion:
+
+    .. math::
+
+        \\begin{equation}
+             \\mathbf{N_eff} = 2 * ( {\\frac{m_{eff_lh} * m_e * k_B * T}{2 \\pi \\hbar^2})^(3/2) + (\\frac{m_{eff_hh} * m_e * k_B * T}{2 \\pi \\hbar^2})^(3/2) )
+        \\end{equation}
+    """
+
+    m_eff_lh: pd.PositiveFloat = pd.Field(
+        ...,
+        title="Light hole effective mass",
+        description="Effective mass of the light holes",
+        units="Electron mass",
+    )
+
+    m_eff_hh: pd.PositiveFloat = pd.Field(
+        ...,
+        title="Heavy hole effective mass",
+        description="Effective mass of the heavy holes",
+        units="Electron mass",
+    )
+
+    def _calc_eff_DOS(self, T: float):
+        return (np.power(self.m_eff_lh * T, 1.5) + np.power(self.m_eff_hh * T, 1.5)) * DOS_aux_const
+
+    def _calc_eff_DOS_derivative(self, T: float):
+        return self._calc_eff_DOS(T) * 1.5 / T

tidy3d/components/tcad/types.py

@@ -3,6 +3,12 @@
 from tidy3d.components.tcad.bandgap import SlotboomBandGapNarrowing
 from tidy3d.components.tcad.boundary.charge import CurrentBC, InsulatingBC, VoltageBC
 from tidy3d.components.tcad.boundary.heat import ConvectionBC, HeatFluxBC, TemperatureBC
+from tidy3d.components.tcad.effective_DOS import (
+    ConstantEffectiveDOS,
+    DualValleyEffectiveDOS,
+    IsotropicEffectiveDOS,
+    MultiValleyEffectiveDOS,
+)
 from tidy3d.components.tcad.generation_recombination import (
     AugerRecombination,
     RadiativeRecombination,
@@ -19,6 +25,9 @@
 from tidy3d.components.tcad.source.heat import HeatSource, UniformHeatSource
 from tidy3d.components.types import Union
 
+EffectiveDOSModelType = Union[
+    ConstantEffectiveDOS, IsotropicEffectiveDOS, MultiValleyEffectiveDOS, DualValleyEffectiveDOS
+]
 MobilityModelType = Union[CaugheyThomasMobility, ConstantMobilityModel]
 RecombinationModelType = Union[
     AugerRecombination, RadiativeRecombination, ShockleyReedHallRecombination