Ne-T_sol.py ダウンロード/コピー

Ne-T_sol.py をダウンロード

Ne-T_sol.py
Ne-T_sol.py
  1#!/usr/bin/env python3
  2"""Parabolic-band semiconductor carrier statistics (energies eV, densities cm^-3).
  3Install: python -m pip install numpy scipy matplotlib
  4Example: python carrier_statistics.py --ND 1e18 --NA 1e16 --save carriers.png
  5Ev=0, Ec=Eg; ED=Ec-Ed, EA=Ev+Ea. Effective masses are in units of m0.
  6Fj is the normalized complete Fermi-Dirac integral, not a Boltzmann approximation.
  7Fixed Eg/masses, independent impurities, and 3D parabolic bands are assumed.
  8"""
  9import argparse
 10from dataclasses import dataclass
 11from math import exp, gamma, log, pi, sqrt
 12from pathlib import Path
 13
 14import numpy as np
 15from scipy.constants import Boltzmann, electron_mass, elementary_charge, h
 16from scipy.integrate import quad
 17from scipy.optimize import brentq
 18from scipy.special import expit
 19
 20KB = Boltzmann / elementary_charge  # eV/K
 21
 22
 23@dataclass(frozen=True)
 24class Model:
 25    Eg: float = 1.12
 26    me: float = 1.08  # density-of-states effective mass (includes valley degeneracy)
 27    mh: float = 0.56
 28    ND: float = 1e16
 29    NA: float = 0.0
 30    Ed: float = 0.045  # donor binding energy below Ec
 31    Ea: float = 0.045  # acceptor binding energy above Ev
 32    gD: float = 2.0
 33    gA: float = 4.0
 34
 35
 36def m2Nc(m, T):
 37    """Effective conduction-band DOS [cm^-3], with spin degeneracy 2."""
 38    return 2 * (2 * pi * m * electron_mass * Boltzmann * T / h**2)**1.5 / 1e6
 39
 40
 41def m2Nv(m, T):
 42    """Effective valence-band DOS [cm^-3]."""
 43    return m2Nc(m, T)
 44
 45
 46def fe(E, Ef, T):
 47    return expit((Ef - np.asarray(E)) / (KB * T))
 48
 49
 50def fh(E, Ef, T):
 51    # Avoid cancellation in 1-fe for a nearly full valence band.
 52    return expit((np.asarray(E) - Ef) / (KB * T))
 53
 54
 55def Fj(eta, j=0.5):
 56    """F_j(eta)=integral_0^inf x^j expit(eta-x) dx / Gamma(j+1).
 57
 58    x=t^2 removes the square-root endpoint for j=1/2. Divide the
 59    integration interval into the occupied region and the thermal tail so
 60    adaptive quadrature resolves the Fermi edge even at very large eta.
 61    For eta<0, factor out exp(eta) using an EXACT logistic identity;
 62    this retains relative accuracy without a Boltzmann approximation.
 63    The omitted x>max(eta,0)+80 tail is exponentially small.
 64    """
 65    if not np.isfinite(eta) or j <= -0.5:
 66        raise ValueError('Fj requires finite eta and j > -0.5')
 67    scale = exp(eta) if eta < 0 else 1.0
 68    if scale == 0:
 69        return 0.0  # below floating-point representability
 70    def integrand(t):
 71        x = t*t
 72        f = exp(-x) * expit(x - eta) if eta < 0 else expit(eta - x)
 73        return 2 * t**(2*j + 1) * f
 74    cuts = [0.0]
 75    if eta > 0:
 76        cuts += [sqrt(max(eta - 40, 0)), sqrt(eta)]
 77    cuts += [sqrt(max(eta, 0) + 80)]
 78    cuts = sorted(set(cuts))
 79    value = sum(quad(integrand, a, b, epsabs=1e-11, epsrel=2e-9,
 80                     limit=200)[0] for a, b in zip(cuts[:-1], cuts[1:]))
 81    return scale * value / gamma(j + 1)
 82
 83
 84def Ne(Ef, T, s):
 85    return m2Nc(s.me, T) * Fj((Ef - s.Eg) / (KB*T))
 86
 87
 88def Nh(Ef, T, s):
 89    return m2Nv(s.mh, T) * Fj(-Ef / (KB*T))
 90
 91
 92def NDp(Ef, T, s):
 93    """ND+ = ND/[1+gD exp((Ef-ED)/kT)]."""
 94    return s.ND * expit((s.Eg - s.Ed - Ef)/(KB*T) - log(s.gD))
 95
 96
 97def NAm(Ef, T, s):
 98    """NA- = NA/[1+gA exp((EA-Ef)/kT)]."""
 99    return s.NA * expit((Ef - s.Ea)/(KB*T) - log(s.gA))
100
101
102def deltaQ(Ef, T, s):
103    return Nh(Ef, T, s) - Ne(Ef, T, s) + NDp(Ef, T, s) - NAm(Ef, T, s)
104
105
106def solve(T, s):
107    center = s.Eg / 2
108    width = max(s.Eg/2, 10*KB*T, 0.1)
109    scale = max(s.ND, s.NA, m2Nc(s.me, T), m2Nv(s.mh, T), 1.0)
110    def q(E):
111        return deltaQ(E, T, s) / scale
112    for _ in range(80):
113        lo, hi = center-width, center+width
114        qlo, qhi = q(lo), q(hi)
115        if not np.isfinite([qlo, qhi]).all():
116            raise RuntimeError(f'Nonfinite charge at T={T:g} K')
117        if qlo >= 0 and qhi <= 0:
118            return brentq(q, lo, hi, xtol=1e-13, rtol=1e-14)
119        width *= 2
120    raise RuntimeError(f'Cannot bracket Ef at T={T:g} K')
121
122
123def initialize(argv=None):
124    parser = argparse.ArgumentParser(description=__doc__,
125                                    formatter_class=argparse.RawDescriptionHelpFormatter)
126    defaults = Model()
127    for name in ('Eg', 'me', 'mh', 'ND', 'NA', 'Ed', 'Ea', 'gD', 'gA'):
128        parser.add_argument('--'+name, type=float, default=getattr(defaults, name))
129    parser.add_argument('--Tmin', type=float, default=50)
130    parser.add_argument('--Tmax', type=float, default=600)
131    parser.add_argument('--nT', type=int, default=112)
132    parser.add_argument('--Nmin', type=float, default=1e10)
133    parser.add_argument('--Nmax', type=float, default=1e22)
134    parser.add_argument('--csv', default='carrier_statistics.csv')
135    parser.add_argument('--save', help='Plot filename, e.g. carriers.png')
136    parser.add_argument('--no-show', action='store_true')
137    a = parser.parse_args(argv)
138    for name in ('Eg', 'me', 'mh', 'gD', 'gA', 'Tmin', 'Tmax', 'Nmin', 'Nmax'):
139        if not np.isfinite(getattr(a, name)) or getattr(a, name) <= 0:
140            parser.error(name+' must be finite and positive')
141    for name in ('ND', 'NA', 'Ed', 'Ea'):
142        if not np.isfinite(getattr(a, name)) or getattr(a, name) < 0:
143            parser.error(name+' must be finite and nonnegative')
144    if a.Ed > a.Eg or a.Ea > a.Eg:
145        parser.error('Impurity binding energies must lie within the gap')
146    if a.Tmax < a.Tmin or a.nT < 1 or a.Nmax <= a.Nmin:
147        parser.error('Require Tmax >= Tmin, nT >= 1, Nmax > Nmin')
148    return a, Model(**{k: getattr(a, k) for k in Model.__dataclass_fields__})
149
150
151def main(argv=None):
152    a, s = initialize(argv)
153    print('# Ev=0 eV, Ec=Eg; energy=eV, density=cm^-3; masses=m0')
154    print('# Model:', s)
155    print('# T[K] Ef[eV] n p ND+ NA- relative_charge_residual')
156    rows = []
157    for T in np.linspace(a.Tmin, a.Tmax, a.nT):
158        Ef = solve(T, s)
159        n, p, dp, am = Ne(Ef, T, s), Nh(Ef, T, s), NDp(Ef, T, s), NAm(Ef, T, s)
160        residual = (p-n+dp-am)/max(n+p+dp+am, np.finfo(float).tiny)
161        rows.append((T, Ef, n, p, dp, am, residual))
162        print(f'{T:9.3f} {Ef: .10f} {n:.6e} {p:.6e} {dp:.6e} {am:.6e} {residual: .3e}')
163    data = np.array(rows)
164    np.savetxt(a.csv, data, delimiter=',',
165               header='T_K,Ef_eV,n_cm-3,p_cm-3,NDplus_cm-3,NAminus_cm-3,relative_charge_residual', comments='')
166    import matplotlib.pyplot as plt
167    fig, ax = plt.subplots(figsize=(9, 5.5), layout='constrained')
168    for col, label, style in ((2, 'n', '-'), (3, 'p', '-'), (4, 'ND+', '--'), (5, 'NA-', '--')):
169        y = np.where(data[:, col] > 0, data[:, col], np.nan)
170        ax.plot(data[:, 0], y, style, label=label)
171    ax.set(yscale='log', ylim=(a.Nmin, a.Nmax), xlabel='Temperature (K)',
172           ylabel=r'Density (cm$^{-3}$)')
173    ax.grid(True, which='both', alpha=0.25)
174    right = ax.twinx()
175    right.plot(data[:, 0], data[:, 1], 'k-', linewidth=2, label='Ef')
176    right.axhline(0, color='gray', linestyle=':', label='Ev')
177    right.axhline(s.Eg, color='gray', linestyle='-.', label='Ec')
178    right.set_ylabel('Energy relative to Ev (eV)')
179    lines, labels = ax.get_legend_handles_labels()
180    l2, lab2 = right.get_legend_handles_labels()
181    ax.legend(lines+l2, labels+lab2, loc='best', ncol=2)
182    ax.set_title('Semiconductor carrier statistics (Fermi-Dirac)')
183    if a.save:
184        fig.savefig(a.save, dpi=180)
185    print(f'# CSV: {Path(a.csv).resolve()}')
186    if not a.no_show:
187        plt.show()
188    plt.close(fig)
189
190
191if __name__ == '__main__':
192    main()