#!/usr/bin/env python3 """Parabolic-band semiconductor carrier statistics (energies eV, densities cm^-3). Install: python -m pip install numpy scipy matplotlib Example: python carrier_statistics.py --ND 1e18 --NA 1e16 --save carriers.png Ev=0, Ec=Eg; ED=Ec-Ed, EA=Ev+Ea. Effective masses are in units of m0. Fj is the normalized complete Fermi-Dirac integral, not a Boltzmann approximation. Fixed Eg/masses, independent impurities, and 3D parabolic bands are assumed. """ import argparse from dataclasses import dataclass from math import exp, gamma, log, pi, sqrt from pathlib import Path import numpy as np from scipy.constants import Boltzmann, electron_mass, elementary_charge, h from scipy.integrate import quad from scipy.optimize import brentq from scipy.special import expit KB = Boltzmann / elementary_charge # eV/K @dataclass(frozen=True) class Model: Eg: float = 1.12 me: float = 1.08 # density-of-states effective mass (includes valley degeneracy) mh: float = 0.56 ND: float = 1e16 NA: float = 0.0 Ed: float = 0.045 # donor binding energy below Ec Ea: float = 0.045 # acceptor binding energy above Ev gD: float = 2.0 gA: float = 4.0 def m2Nc(m, T): """Effective conduction-band DOS [cm^-3], with spin degeneracy 2.""" return 2 * (2 * pi * m * electron_mass * Boltzmann * T / h**2)**1.5 / 1e6 def m2Nv(m, T): """Effective valence-band DOS [cm^-3].""" return m2Nc(m, T) def fe(E, Ef, T): return expit((Ef - np.asarray(E)) / (KB * T)) def fh(E, Ef, T): # Avoid cancellation in 1-fe for a nearly full valence band. return expit((np.asarray(E) - Ef) / (KB * T)) def Fj(eta, j=0.5): """F_j(eta)=integral_0^inf x^j expit(eta-x) dx / Gamma(j+1). x=t^2 removes the square-root endpoint for j=1/2. Divide the integration interval into the occupied region and the thermal tail so adaptive quadrature resolves the Fermi edge even at very large eta. For eta<0, factor out exp(eta) using an EXACT logistic identity; this retains relative accuracy without a Boltzmann approximation. The omitted x>max(eta,0)+80 tail is exponentially small. """ if not np.isfinite(eta) or j <= -0.5: raise ValueError('Fj requires finite eta and j > -0.5') scale = exp(eta) if eta < 0 else 1.0 if scale == 0: return 0.0 # below floating-point representability def integrand(t): x = t*t f = exp(-x) * expit(x - eta) if eta < 0 else expit(eta - x) return 2 * t**(2*j + 1) * f cuts = [0.0] if eta > 0: cuts += [sqrt(max(eta - 40, 0)), sqrt(eta)] cuts += [sqrt(max(eta, 0) + 80)] cuts = sorted(set(cuts)) value = sum(quad(integrand, a, b, epsabs=1e-11, epsrel=2e-9, limit=200)[0] for a, b in zip(cuts[:-1], cuts[1:])) return scale * value / gamma(j + 1) def Ne(Ef, T, s): return m2Nc(s.me, T) * Fj((Ef - s.Eg) / (KB*T)) def Nh(Ef, T, s): return m2Nv(s.mh, T) * Fj(-Ef / (KB*T)) def NDp(Ef, T, s): """ND+ = ND/[1+gD exp((Ef-ED)/kT)].""" return s.ND * expit((s.Eg - s.Ed - Ef)/(KB*T) - log(s.gD)) def NAm(Ef, T, s): """NA- = NA/[1+gA exp((EA-Ef)/kT)].""" return s.NA * expit((Ef - s.Ea)/(KB*T) - log(s.gA)) def deltaQ(Ef, T, s): return Nh(Ef, T, s) - Ne(Ef, T, s) + NDp(Ef, T, s) - NAm(Ef, T, s) def solve(T, s): center = s.Eg / 2 width = max(s.Eg/2, 10*KB*T, 0.1) scale = max(s.ND, s.NA, m2Nc(s.me, T), m2Nv(s.mh, T), 1.0) def q(E): return deltaQ(E, T, s) / scale for _ in range(80): lo, hi = center-width, center+width qlo, qhi = q(lo), q(hi) if not np.isfinite([qlo, qhi]).all(): raise RuntimeError(f'Nonfinite charge at T={T:g} K') if qlo >= 0 and qhi <= 0: return brentq(q, lo, hi, xtol=1e-13, rtol=1e-14) width *= 2 raise RuntimeError(f'Cannot bracket Ef at T={T:g} K') def initialize(argv=None): parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter) defaults = Model() for name in ('Eg', 'me', 'mh', 'ND', 'NA', 'Ed', 'Ea', 'gD', 'gA'): parser.add_argument('--'+name, type=float, default=getattr(defaults, name)) parser.add_argument('--Tmin', type=float, default=50) parser.add_argument('--Tmax', type=float, default=600) parser.add_argument('--nT', type=int, default=112) parser.add_argument('--Nmin', type=float, default=1e10) parser.add_argument('--Nmax', type=float, default=1e22) parser.add_argument('--csv', default='carrier_statistics.csv') parser.add_argument('--save', help='Plot filename, e.g. carriers.png') parser.add_argument('--no-show', action='store_true') a = parser.parse_args(argv) for name in ('Eg', 'me', 'mh', 'gD', 'gA', 'Tmin', 'Tmax', 'Nmin', 'Nmax'): if not np.isfinite(getattr(a, name)) or getattr(a, name) <= 0: parser.error(name+' must be finite and positive') for name in ('ND', 'NA', 'Ed', 'Ea'): if not np.isfinite(getattr(a, name)) or getattr(a, name) < 0: parser.error(name+' must be finite and nonnegative') if a.Ed > a.Eg or a.Ea > a.Eg: parser.error('Impurity binding energies must lie within the gap') if a.Tmax < a.Tmin or a.nT < 1 or a.Nmax <= a.Nmin: parser.error('Require Tmax >= Tmin, nT >= 1, Nmax > Nmin') return a, Model(**{k: getattr(a, k) for k in Model.__dataclass_fields__}) def main(argv=None): a, s = initialize(argv) print('# Ev=0 eV, Ec=Eg; energy=eV, density=cm^-3; masses=m0') print('# Model:', s) print('# T[K] Ef[eV] n p ND+ NA- relative_charge_residual') rows = [] for T in np.linspace(a.Tmin, a.Tmax, a.nT): Ef = solve(T, s) n, p, dp, am = Ne(Ef, T, s), Nh(Ef, T, s), NDp(Ef, T, s), NAm(Ef, T, s) residual = (p-n+dp-am)/max(n+p+dp+am, np.finfo(float).tiny) rows.append((T, Ef, n, p, dp, am, residual)) print(f'{T:9.3f} {Ef: .10f} {n:.6e} {p:.6e} {dp:.6e} {am:.6e} {residual: .3e}') data = np.array(rows) np.savetxt(a.csv, data, delimiter=',', header='T_K,Ef_eV,n_cm-3,p_cm-3,NDplus_cm-3,NAminus_cm-3,relative_charge_residual', comments='') import matplotlib.pyplot as plt fig, ax = plt.subplots(figsize=(9, 5.5), layout='constrained') for col, label, style in ((2, 'n', '-'), (3, 'p', '-'), (4, 'ND+', '--'), (5, 'NA-', '--')): y = np.where(data[:, col] > 0, data[:, col], np.nan) ax.plot(data[:, 0], y, style, label=label) ax.set(yscale='log', ylim=(a.Nmin, a.Nmax), xlabel='Temperature (K)', ylabel=r'Density (cm$^{-3}$)') ax.grid(True, which='both', alpha=0.25) right = ax.twinx() right.plot(data[:, 0], data[:, 1], 'k-', linewidth=2, label='Ef') right.axhline(0, color='gray', linestyle=':', label='Ev') right.axhline(s.Eg, color='gray', linestyle='-.', label='Ec') right.set_ylabel('Energy relative to Ev (eV)') lines, labels = ax.get_legend_handles_labels() l2, lab2 = right.get_legend_handles_labels() ax.legend(lines+l2, labels+lab2, loc='best', ncol=2) ax.set_title('Semiconductor carrier statistics (Fermi-Dirac)') if a.save: fig.savefig(a.save, dpi=180) print(f'# CSV: {Path(a.csv).resolve()}') if not a.no_show: plt.show() plt.close(fig) if __name__ == '__main__': main()