FLOOXS » TclLib » Device

Device — TclLib Procs

126 documented proc(s) in TclLib/Device/.

2Bound · 2BoundSide · 2Defect · 311Eqn · ::AlGaN::PolarizationCharge · ::Elastic::bond_transform · ::Elastic::miller_rotation · ::Elastic::parse_miller_digits · ::Hamiltonians::Expr::is_num · ::Hamiltonians::Expr::lit · ::Hamiltonians::Expr::neg · ::Hamiltonians::Expr::scale · ::Matrix::invNxN · ::Matrix::multAx · ::Matrix::multNxN · ::Matrix::transpose · __CompareBands · __DirectStatistics · __DOS1D · __DOS2D · __EllipsoidalDimMap · __EllipsoidalMassTensor · __IndirectStatistics · __interpolate_linear_vec · __mult_sweep · __RotateTensor · __RotateTensorDiag · __SiliconCompliance · __Stats1D · __Stats2D · AddSolution · BandGap · BandGapGamma · BandGapL · BandGapX · BandOverlapLoop · ClusterEqn · ComputeModes · CplxMult · Cubic::CubicSpline · Cubic::SolveTridiag · DefectBound · DefectBoundSide · DefectBulk · DGEquation · DirectTunnelEnergy · dopant_has · dopant_has2 · DopantBulk · DopantConstant · DopantDefectPair · DopantDefectReact · DopantFermi · DopantPair · DopantReact · EllipsoidalMassTensor · EqnsVerySimple · GetdU · GetMobilityTensor · Hamiltonians::Generic::__BuildLKMatrix · Hamiltonians::Generic::__DiscretizeLinear · Hamiltonians::Generic::__LKPeqn · Hamiltonians::Generic::__LKQeqn · Hamiltonians::Generic::__LKReqn · Hamiltonians::Generic::__LKSeqn · Hamiltonians::Generic::__SplitTopPlus · Hamiltonians::Generic::DiscretizeTerm · Hamiltonians::Generic::KDiscretize · Hamiltonians::Generic::KKDiscretize · Hamiltonians::Generic::LK · Hamiltonians::Generic::LKFromMaterial · Hamiltonians::Generic::MapTerm · Init · InitDopant · InterpBowing · InterpLinear · IntNumIntegral · LK_KGrid · LKElectrostatics · logN · LoopBulkDall · LoopBulkNall · LoopEng · Ltun · Masetti · Nc · NcGamma · NcL · NcX · PoissonSchrodinger · QSolve::__pick · QSolve::__tunnelDosScale · QSolve::__tunnelTdos · QSolve::BandEnergies · QSolve::ComputeOmegaMsq · QSolve::DirectTunnelCurrent · QSolve::DirectTunnelCurrentKP · QSolve::IndirectTunnelCurrent · QSolve::MatData · QSolve::NonParabolicityCorrection · QSolve::QuantumLocals · QSolve::Schrodinger100Solve · QSolve::Schrodinger100SolveKP · QSolve::SchrodingerSolveElec · Schenk · SchrodingerDirectCurrent · SchrodingerDirectCurrentKPMeff · SchrodingerIndirectUnscaledTransmission · SchrodingerSolveEllipsoidal · SchrodingerSolveLVal · SchrodingerSolveXVal · Segregation · SetSiliconStrainParams · SetSiliconStrainParams100 · SetStrainParamsList · SG · SmicEqn · Solve · SoRBulk · SortLowHigh · SRH · StressDriftTest · Transpose · Trapezoidal · VacNumIntegral · VoxelVolumeTest

Interface dispatcher for dimers.

Per-side interface equation for dimers (I2 / V2 at Oxide/Silicon).

Di-defect (I2 / V2) self-equation + cross-coupling into Base, RecombDefect,
BiMolecular partners.

311Eqn manages D311 AND C311 self equations, plus cross-coupling into Int
and I2.  Registered on C311 (per master Params/Silicon/C311); $Sol = C311.

Polarization sheet charge at a III-N heterointerface (e.g. AlGaN/GaN
2DEG).  Unchanged from the pre-port implementation — operates on the
named interface, not on AlGaN bulk state.

Build 6x6 Bond matrix from a 3x3 rotation matrix.
Converts first-order (vector) rotation to second-order (Voigt tensor) rotation.

Build a 3x3 rotation matrix from Miller indices.

Syntax:
  (hkl)<uvw>             — default: () → column 2 (z), <> → column 0 (x)
  (axis:hkl)<axis:uvw>   — explicit axis assignment

Examples:
  (001)<100>             — (001) surface, [100] channel. Normal→z, channel→x
  (x:001)<y:100>         — (001) surface normal along x, [100] along y
  (x:110)<z:1-10>        — (110) normal along x (1D quantum), [-110] along z

The third direction is always the cross product of the other two,
placed in whichever column remains.

The rotation matrix rows are crystal [100],[010],[001] directions.
The columns are device x,y,z directions.

Parse a signed Miller index string (e.g., "001", "-110", "1-10") into a list of 3 integers.

True if v is a strict Tcl number (so native `expr` arithmetic is safe).

Pass v through as an alagator-safe sub-expression.
  number → returned untouched (Tcl auto-stringifies on splice; matches
           the legacy `[expr {...}]` byte representation exactly so
           pure-Si/Ge expression strings stay bit-identical)
  string → wrapped in parens so precedence at the splice site is preserved

Negate v.  Numbers fold via `expr` (raw-double pass-through); strings
are wrapped.

c * v where c is a Tcl number and v is number-or-expression.
Constant-folds via native `expr` when v is numeric (preserves the
raw-double string repr legacy code emitted).  Splices into a
parenthesised string when v is an expression.

Generic NxN inverse via Gauss-Jordan elimination with partial pivoting.

Matrix A times vector x multiplication
Returns a vector

multiplies two NxN matricies

Returns the transpose of matrix A

Deduplicate equivalent bands

Statistics used in direct band to band tunneling
quantum calculations
Takes an energy, quasi fermis, and temperature

Returns the 1D Density of states value for a given
temperature and effective mass

Returns the 2D Density of states value for a given
temperature and effective mass

__EllipsoidalDimMap — confinement-direction k-product discretizer for the
ellipsoidal effective-mass Hamiltonian, by string substitution on a built
expression (kx*kx*s -> VelX(GradX(s)), etc.).  Relocated verbatim from the
retired ::LK::DimMap (this is its only caller).

Legacy alias — older decks (and the auto-loaded tclIndex) reference the
underscored name.

Statistics used in indirect band to band tunneling
quantum calculations
Takes an energy, quasi fermis, temperature, and phonon energy

Vectorized linear interpolation for a sorted list of query points.
Single pass O(n+m) where n = len(x), m = len(xv).
Values outside the data range are clamped to the nearest endpoint.

Multiplicative (geometric) sweep — same interface as __linear_sweep but
steps by multiplication instead of addition.  step is a factor (e.g. 1.2).

Takes a 3x3 Tensor list and crystal rotation vector
returns a rotated tensor

Same procedure but only outputs Diag

Resolve Silicon's elastic compliance triple {c11 c12 c44} from the
active device dict's BandStructure StrainParams slice — the dict-read
replacement for the old ::Silicon::c11/c12/c44 namespace vars.  Both
stress helpers below are Silicon-hardcoded global emitters, so they
read Silicon's slice directly from [::Defaults::device].

Returns the 1D Density of states with integral function for a given
temperature, effective mass and potential

Returns the 2D Density of states with integral function for a given
temperature, effective mass and potential

to do pod we need a set of solutions
this procedure adds a solution as a function of bias

Effective (minimum) bandgap — for ni calculations
At x<~0.85 the X-valley is lowest; above that, L takes over.
We return a smooth minimum via Alagator ternary.

Gamma-valley (direct gap) — matters for optical transitions and direct tunneling

L-valley — dominant conduction band for Ge-rich alloys

X-valley (Delta minimum) — dominant conduction band for Si-rich alloys

Loop over energies from the bottom of the conduction band to the 
top of the valance band. Only produces values if the bands overlap
fxn is a function that is called at every point in the loop with that energy
dU is the energy step size
mat is the material used

ClusterEqn manages Smic's bulk equation AND back-propagates to 6 partner
species (Int, I2, Vac, V2, D311, C311).  Pre-resolves DiffLimit via subst
(Alagator does not evaluate `[Tcl]` substitutions in eqn= values).

only take a subset of modes with this proc for ramping purposes

Multiply complex numbers that are stored as two separate values

#+##########################################################################

CubicSpline - returns the x,y coordinates of the cubic spline using
xy control points.
xy => {{x0 y0} {x1 y1} .... {xn yn}}

XY points MUST BE SORTED by increasing x

#+##########################################################################
SolveTriDiag -- solves the linear system for tridiagoal NxN matrix A
using Gaussian elimination (no pivoting). Since A is sparse, we pass
in three diagonals:
    sub(i)  => a(i,i-1)    diag(i) => a(i,i)    sup(i)  => a(i,i+1)

Result is returned in b[1:n]

Interface bulk-side dispatcher.  Walks both sides and calls
DefectBoundSide for each side where DiffModel is "Numeric" (matched via
matparam_sub).  If the side has no DiffModel set, that side is skipped
(which is the typical case — only the bulk side with the diffusing
species gets a boundary condition).

Per-side interface equation.  Writes to the C++ EqnComplex via a separate
code path than the bulk Equation accumulator — uses the existing
`solution Mat /Other name=Sol side=Side value="…"` shape directly rather
than going through pde_*.

The trapping term that touches Vac's BULK equation does go through
pde_append, because that IS a cross-coupling into the bulk accumulator.

Build the bulk rate equation for $Sol (Int or Vac) in $Mat (Silicon):
  ddt(Sol) - D0 · grad(ScaleSol) + IVRecomb
plus the scratch terms EqSol, ScaleSol, IVRecomb, PressureSol used by it.

# Full Density Gradient Correction:

Computes the direct tunneling energy using the effective mass approximation
Takes an conduction band sub band energy Eci
Conduction band effective mass
Takes an valance band sub band energy Evi
Valance band effective mass

Helper: check if a per-(Mat, Sol, Key) parameter is set (returns "" if not).

Same but for the nested Mat/Sol/Def/Key form.  Delegates to matparam_sub3
so the inherit chain is honored: a child material picks up its parent's
per-(dopant, defect) params without redeclaring them.

DopantBulk: top-level dispatcher.  Reads DiffModel / ActiveModel / Charge
switches and routes to the right sub-builder; finally folds the active
species into the global Charge term.

Simple constant-diffusivity model: ddt(Sol) - D * grad(SolActive).

Per-(dopant, defect) flux contribution for the Pair model.  Builds the
DiffDef diffusivity and the FluxSolDef term; subtracts the flux from
the dopant's residual, adds a dopant-defect binding term to the defect's
residual.

Per-(dopant, defect) reaction for the React model.

Fermi-level dependent diffusivity.  Reads D0, optional Dn/Dnn/Dp/Dpp
coefficients for the Fermi-expansion in Noni and Poni.  For charged
species the diffusivity gets a 1/(Poni) or 1/(Noni) factor and the grad
argument picks up a (Poni) or (Noni) factor — same shape as master.

Pair model — substitutional via 1/(1 + Σ Bind*Defect), then per-(Sol,Def)
flux contribution.

React model — substitutional is dopant total minus sum of (dopant, defect)
species; per-(Sol, Def) reactions wire flux + binding.

Build the 3x3 inverse mass tensor for an ellipsoidal valley
with longitudinal mass ml along direction {dx dy dz} and
transverse mass mt perpendicular.

Silicon::EqnsVerySimple — minimal single-band DD equation set
(Masetti-only mobility, no BGN, no DP-tensor, R=G=0).  Replaces
Silicon's multi-valley + Klaassen-Canali + BGN baseline emission
with a simpler form suitable for trap-only physics tests
(InterfaceTraps-Edge / -Mid).  Call AFTER `device pull T= Temp
feqf` to overwrite the dispatcher-emitted multi-valley equations.

Get dU from the number of integration points that you want

takes a mobility vector
returns a tensor 3x3 list

Build the symbolic 6×6 LK Hamiltonian matrix in the angular-momentum
basis |3/2,3/2>, |3/2,1/2>, |3/2,-1/2>, |3/2,-3/2>, |1/2,1/2>, |1/2,-1/2>.
Returns a list-of-lists; element [i][j] is the symbolic expression for
H_ij multiplied through by sol_names[j], or "0" for structural zeros.

Helper: discretize a single linear-in-k term coeff*[i*]ka*s with
rotation R applied to ka.  Lifts each rotated component through
KDiscretize.

P-block: kinetic γ1 term + hydrostatic deformation potential a.
  $s — sol name multiplied through every term
  $P — eV·m², equals -C1 * g1   (number or alagator expression)
  $a — eV, hydrostatic deformation potential   (number or expression)

Q-block: γ2 anisotropy + biaxial deformation potential b.
  $Q — eV·m², equals -C1 * g2   (number or expression)
  $b — eV, biaxial deformation potential   (number or expression)

R-block: γ2/γ3 mixing + b/d shear deformation potentials.
  $R  — eV·m², equals C2 * g2   (number or expression)
  $Sv — eV·m², equals -2 * C2 * g3 (passed as $Sv to avoid Tcl 'S' reuse)
  $b  — eV, biaxial deformation potential
  $d  — eV, shear deformation potential

S-block: γ3 mixing + d shear deformation potential.
  $Sv — eV·m², equals -2 * C2 * g3   (number or expression)
  $d  — eV, shear deformation potential   (number or expression)

Paren-aware split on top-level '+' characters.  Mirrors `split $expr +`
for coefficient strings that contain no parentheses (the legacy numeric
Si/Ge code path), but preserves '+' nested inside parentheses — needed
when Expr-wrapped coefficients contain alagator subexpressions like
"(4.22 + 9.13*SiGeMoleFrac)" that must not be split mid-coefficient.

Hamiltonians::Generic::DiscretizeTerm

Single-pipeline equivalent of MapTerm + valley-center k0 shift.
Expands the crystal-frame k-product around k0_cry (substituting
k_i = k0_i + δk_i), discretizes each resulting δk-piece via KDiscretize
/ KKDiscretize after the Miller rotation R, and returns the list of
expression strings that together give the original term in envelope
form.  k0_cry = {0 0 0} (Γ-valley) reduces to MapTerm.

Signature:
  DiscretizeTerm term s dim R k0_cry k_units

`term` shape mirrors MapTerm: "coeff*[i*]ki*kj*s" or "coeff*s" (constant
/ strain).  Higher-than-quadratic k powers aren't supported (not used
by k.p Hamiltonians beyond Luttinger-Kohn).

Discretize a single linear-in-k term (ki*s) by index a ∈ {0,1,2}.
Used by DiscretizeTerm when expanding around non-zero k0.
  hasI    — 1 if the original term had an i* prefix (i*ki*s)
  k_units — "m" or "cm" (free-k lift identical to KKDiscretize)

Discretize ka*kb*s by index pair (a,b ∈ {0,1,2} = {x,y,z}).
  dim     — number of confined spatial dimensions; first `dim` axes are
            confined (mapped to GradX/Vel), the rest stay as broadcast
            k-parameters
  hasI    — 1 if the original term had an i* prefix (i*ki*kj*s)
  k_units — "m" (broadcast k in 1/m) or "cm" (broadcast k in 1/cm; each
            free k contributes ×1e2 to lift back to 1/m for the eV·m²
            coefficients)

Hamiltonians::Generic::LK

Pure 6-band Luttinger-Kohn k.p Hamiltonian builder.  No state.  All
material-specific quantities arrive as args.

  dim       — number of confined spatial dimensions (0..3)
  miller    — Miller-orientation string for the crystal→device rotation
  params    — dict with keys: g1 g2 g3 delta a b d
                g1, g2, g3 — Luttinger γs (dimensionless)
                delta      — split-off energy (eV; sign forced negative)
                a, b, d    — Bir-Pikus deformation potentials (eV)
              (a0 is not used here; the caller can carry it elsewhere.)
  strain    — dict with keys: exx eyy ezz exy exz eyz
                Each value is substituted directly into the expression
                string — pass numbers (inlined constants) or alagator
                expressions (e.g. "Material(Silicon)*0.001") for region-
                masked strain.  Pass zeros for unstrained.
  sol_names — list of 6 spinor field names in basis order
                |3/2,3/2>, |3/2,1/2>, |3/2,-1/2>, |3/2,-3/2>, |1/2,1/2>,
                |1/2,-1/2>.  These names are referenced in the returned
                expressions; aschro uses them as the eigenvector basis.
  Potential — band-edge field name added to the diagonal (default: Eval).
  k_units   — "m" or "cm".  "cm" matches flooqs's KGrid (1/cm) convention
              and lifts free-k factors by ×10² per free k inside MapTerm.

Returns the 6-element list of LK Hamiltonian expression strings ready
for aschro / kaschro.

Hamiltonians::Generic::LKFromMaterial

Convenience: read a material's QuantumKP LK slice (the canonical k.p
parameters in the ::Defaults Quantum domain) and build the 6-band LK
Hamiltonian for it.  Returns {H sols a0} — the equation list, the spinor
solution names, and the lattice constant (m) the caller needs for k-grids.
Replaces the legacy `LK::SetParamsFor $mat; LK::BuildH $dim` idiom.

  mat       — material name (Silicon, Germanium, ...)
  dim       — confined spatial dimensions (0..3)
  Potential — band-edge field on the diagonal (default Eval)
  miller    — crystal→device orientation (default unrotated (001)<100>)
  k_units   — "m" (matches the legacy LK::BuildH default) or "cm"

Discretize a single Hamiltonian term, optionally applying rotation R.
Parses coeff*[i*]ki*kj*s patterns; strain/constant terms pass through.
Returns a list of discretized terms (one for unrotated, up to 9 for rotated).

lastly we can make guesses using the POD equations for each solution

Initialize dopant-defect product solutions.  For React model, these are
real solve variables (XInt, XVac for dopant X).  For other models they are
const placeholders.

Quadratic interpolation with bowing parameter for alloy properties.
Returns an Alagator expression: (1-x)*valA + x*valB - bow*x*(1-x)
x can be a numeric constant or an Alagator field name.

Linear interpolation returning an Alagator expression.
x can be a numeric constant or an Alagator field name.

Trapezoidal integration over loop sizes for interstitial-flavored loops.

LK_KGrid H kmax dk nev dim sols a0 — sweep a polar k-grid, solve the LK
ladder at each point, and return a list of {ky kz Eig EVnames polarizations}
(in-plane / transport polarization factors from the |3/2,±> weights).

LKElectrostatics H nev dim sols a0 — solve the confined LK ladder at k=0 and
return a band tuple {LKV 1.0 Eval Eig mdos} with velocity-based DOS masses
from a finite-difference dispersion (1D: geometric mean of y/z; 2D: z only).

Log-normal size distribution kernel.  Alagator doesn't parse `^` so the
squaring is expanded to `(diff)*(diff)`.

Loop average size Dall.  Alagator-`^` is expanded to `*`.

Loop density Nall — accumulates the local self equation incrementally
(because of nested foreach control flow) and flushes via pde_set_self at
the end.  Cross-coupling is appended inline through pde_append.

Loop elastic energy factor at radius $AvgRad.  Read the elastic moduli
(mu, b, ohm, kerg, nu) preferentially from the per-defect namespace
(::Mat::Sol::Key) but fall back to material-level (::Mat::Key) — this
mirrors master's pdb chain walk that auto-falls-back when the per-(mat,
sol) slot is missing.

In practice LoopEng is called with $Sol = Nall (the loop density species)
inside IntNumIntegral; Nall doesn't carry its own elastic moduli, so the
fall-back to material-level is load-bearing.

Compute the tunneling length in 1D
all parameters are optional
units are nm or um
Econd_o is an offset value for the conduction band
Eval is the name of the valance band
Econd is the name of the conduction band

Masetti Mobility Model from Sentaurus, P at end of parameter is Phospherous, B at end of parameter is Boron
See paper titled Electrical TCAD Simulations of a Germanium pMOSFET Technology

Aggregate electron DOS for ohmic contact calculations.
Returns X-valley Nc, which is the dominant valley in Si-rich compositions
and provides the correct contact boundary condition.

Gamma-valley electron DOS (1-fold degeneracy)
Si: mGamma ≈ 0.036 (very light, high in the band structure)
Ge: mGamma ≈ 0.041

L-valley electron DOS (4-fold degeneracy)
Ge: ml=1.59, mt=0.0815
Si: L-valley masses ml=1.42, mt=0.13
Computed inline (same method as Germanium::Nc) to match endpoint exactly.

X-valley electron DOS (6-fold degeneracy)
Si: ml=0.9161, mt=0.1905 → md = 6^(2/3)*(ml*mt^2)^(1/3) ≈ 1.084
Ge: X-valley masses ml=1.35, mt=0.29 → md = 6^(2/3)*(ml*mt^2)^(1/3) ≈ 1.42

Silicon Electron and Hole Poisson-Schrodinger loop with predictor corrector
T is temperature, er is the oxide relative permittivity

__pick qd ref — resolve a {Sub Key} mass reference into qd, e.g.
{XValley mct} -> [dict get $qd XValley mct].

__tunnelDosScale dim degen mass — per-dimensionality DOS prefactor for
the indirect-tunnel conduction/valence scale factors (2D: sqrt(2 m E)
surface DOS; 1D: line DOS; 0D: degeneracy count only).

__tunnelTdos qd {form valley} — confinement transverse-DOS mass for a
conduction valley: sqrt_lt -> sqrt(mct*mcl); long -> mct;
ge_l -> sqrt(mct*(mct+2*mcl)/3).

QSolve::BandEnergies bands -> dict {bandname -> eigenvalue-list}.
`bands` is a flat list of band tuples {name degen pot E mdos ...};
pulls the 4th element (E) per name.  Replaces the deprecated
::<Mat>::E* side-effect globals — consumers read energies from here
(or straight from the returned tuples) instead of the namespace var.

QSolve::ComputeOmegaMsq qd — phonon-assisted coupling term |OmegaM|^2
for indirect (phonon-assisted) tunneling.  Reproduces the unit lifts
from the old ::Silicon::QuantumParams / ::Germanium::IndirectTunnelingParams
inline blocks: Dk0 eV/cm -> J/m (x100 then x q_e), rho g/cm^3 -> kg/m^3
(x1000), omega = hw*q/hbar.  Returns J^3*m/(kg*rad) (SI), matching the
scal factor in the tunnel-current procs.

QSolve::DirectTunnelCurrent qd bands T — direct band-to-band tunneling
current.  Pull form of ::<Mat>::DirectTunnelCurrent: the conduction
band, two valence bands, and direct gap come from qd `DirectTunnel`;
eigenvalues from the band tuples.  Thin wrapper over the generic
SchrodingerDirectCurrent engine (no namespace var / E* global).

QSolve::DirectTunnelCurrentKP qd bands T — direct tunneling into the Γ
valley against an LK valence band (Ge).  Pull form of
Germanium::DirectTunnelCurrentKP: mc/Eg from qd `DirectTunnel`, the Γ
eigenvalue and the LK hole tuple from `bands` (no ::<Mat>:: globals);
the LK k-grid is built with the material's Luttinger params.

QSolve::IndirectTunnelCurrent qd bands T — phonon-assisted indirect
band-to-band tunneling current.  Pull form of ::<Mat>::
IndirectTunnelCurrent: conduction valleys (degeneracy + transverse-DOS
mass) and valence bands come from qd `Tunnel`; the FGR coupling is
ComputeOmegaMsq(qd) and the phonon energy qd Phonon hw; eigenvalues from
the band tuples.  Sums every (conduction, valence) crossing through the
generic SchrodingerIndirectUnscaledTransmission engine.  Returns
"<integral_abs> <integral_em> <per-transition abs/em debug...>".

QSolve::MatData mat — per-material quantum-solver data dict.

These are the Schrodinger/tunneling solver's own tuned constants (the
values formerly inlined in ::Silicon::QuantumParams /
::Germanium::{Indirect,}TunnelingParams).  They are deliberately
DISTINCT from the device-pull BandStructure masses (e.g. Si quantum
mcl 0.9163 vs CommonParameters Xml 0.916 vs Valleys ml
0.97) — the confined-subband solver was tuned independently, so the
values must be preserved verbatim.  Kept as a literal table here (the
same on-the-object pattern as flooqs ::Materials) rather than under a
device-pull family: the `Quantum` family name is taken by the
Density-Gradient composer, and these solvers never run through
`device pull`.

Non-parabolicity correction for an ellipsoidal subband ladder.
  E         - list of subband eigenvalues (eV)
  EV        - eigenvector solution-name prefix (EV0, EV1, ... must exist)
  BandEdge  - band-edge potential field name
  alpha     - non-parabolicity parameter (1/eV)
reference doi: 10.1063/1.3500553

QSolve::QuantumLocals mat — returns a script (for `eval`) that sets the
legacy ::<Mat>::QuantumParams / IndirectTunnelingParams locals
(mct mcl mvlh mvhh hbar q me pi hw OmegaMsq) from MatData — a drop-in for
the deleted per-material param-var blocks, used by the band-solve /
generation procs that haven't been fully restructured into pull form.

QSolve::Schrodinger100Solve qd ?dooxide? — confined band solve along
[100], data-driven off the qd `Bands` descriptor (was the per-material
::<Mat>::Schrodinger100Solve).  Each band entry:
  kind  elec|hole         pot   band-edge field
  meff  {Sub Key} ref     degen tuple degeneracy
  mdos  DOS mass          np    (optional) non-parabolicity alpha
  conv_mcl (optional)     transport->DOS confinement-mass conversion
                          m -> 3*m*mct/(2*m+mct)  (L-valley)
Solve method: when the material declares `ConfineOxideMask <mat>` and
dooxide==0, the confined eigenproblem is the oxide-penetrating aschro
(band edge masked by a large oxide potential); otherwise the plain
`schro` effective-mass solve.  Returns {elec hole} band-tuple lists;
does NOT set any ::<Mat>:: global (see BandEnergies).

QSolve::Schrodinger100SolveKP qd ?dooxide? — confined band solve with
LK (k.p) valence holes instead of the effective-mass holes of
Schrodinger100Solve.  Pull form of ::<Mat>::Schrodinger100SolveKP.
Electrons come from the qd `KP elec` descriptor (per-band solve =
schro | aschro_plain, optional non-parabolicity / L-valley mass
conversion); holes are the LK ladder (LK::BuildH on the material's
Luttinger params -> LKElectrostatics).  Returns {elec hole}; no E* global.

QSolve::SchrodingerSolveElec qd nev ... — confined electron Δ/X-valley
solve.  Generic body (was ::Silicon::SchrodingerSolveElec); the only
material input is the X-valley mass pair from `qd`.  The rest is the
already-generic SchrodingerSolveEllipsoidal / SchrodingerSolveXVal
engine.  Preserves the full band tuple incl. the 6th device-frame
inverse-mass element appended by SchrodingerSolveEllipsoidal.

The driving force, SRH, band gap, and thermal voltage are arguments
This expression modifies an SRH like expression

Computes direct tunnel current using the Bigelow method
Ec is the gamma electron sub band energies
EVc is the gamma electron eigen vector base names
mc is the gamma electron effective mass
Evlh is the light hole sub band energies
EVvlh is the light hole eigen vector base names
mvlh is the light hole effective mass
Evhh is the heavy hole sub band energies
EVvhh is the heavy hole eigen vector base names
mvhh is the heavy hole effective mass
Eg is the direct band gap
T is the temperature

Computes direct tunnel current using the Bigelow method assuming kp
Ec is the gamma electron sub band energies
EVc is the gamma electron eigen vector base names
mc is the gamma electron effective mass
Ev is the hole sub band energies
EV is the hole eigen vector base names
mv is the hole effective mass
Eg is the direct band gap
T is the temperature

Computes indirect tunneling transmission for a given conduction and valance band
Ev is list of eigenvalues for the valance band
EVv is the valance band eigenvector base name
Ec is list of eigenvalues for the conduction band
EVc is the conduction band eigenvector base name
hw is the phonon energy
T is the temperature value or field
N is the Number of integration points
Returns units of inverse cm

Solve the Schrodinger equation for a set of ellipsoidal valleys.

Arguments:
  Econd       - band edge potential name (Alagator field)
  ml          - longitudinal effective mass (m0 units)
  mt          - transverse effective mass (m0 units)
  directions  - list of valley direction vectors, e.g., {{1 0 0} {0 1 0} {0 0 1}}
  dotransport - compute transport mass if true
  nev         - number of eigenvalues
  prefix      - solution variable prefix (e.g., "EVX" or "EVL")
  alpha       - 3x3 crystal-to-device rotation matrix
  shear_alpha - shear deformation potential (Ξu' rotation coeff) used by
                the `shear_list` term; default 53.0 (Silicon).
  a0          - lattice constant (m) used only as the finite-difference
                step scale for the transport-mass k-derivative; default
                5.43e-10 (Silicon).

L-valley solver: 4 valleys along <111> directions

X-valley solver: 6 valleys along <100> directions

Interface segregation — uses the slash form for side-qualified Sol
references (see src/BasePDE/lexical.cc for the lexer patch).

SetSiliconStrainParams — empty back-compat shim.  The k.p +
piezoresistance + PiezoHall constants it used to stamp are now
top-level data declarations at the bottom of this file, so the data is
in place by the time any consumer (Silicon::Eqns, SGEqns, the
orientation variants below, test decks) reads it.  Decks that call
this proc explicitly still work — the call is a no-op since the data
is already stamped, and re-stamping would just be redundant.

Orientation-specific variant — call SetSiliconStrainParams then override
the k.p values for a (100) wafer surface.

SetStrainParamsList — explicit positional list override.  Kept verbatim
for decks that use it; the list maps to specific keys in order.

Silicon::SG — SG-mode entry point: sources the SG-specific Silicon
baseline (Masetti + Canali mobility, Flat single-band, Transport=SG,
SRH+Auger recombination) and runs `device pull T= $T sg` to register
the full SG infrastructure (Elec/Hole PDE, Qfn/Qfp const, per-axis
Emfn{x,y,z}/Emfp{x,y,z}, SGOhmic contacts).  Replaces the legacy
SGDevicePackage proc.

Small interstitial cluster (Smic) — formation from Int + I2; recombination
with V2 → base.

Run a Galerkin POD-projected Newton solve using the per-variable
bases stored in this namespace.  Returns the iteration count.  The
caller is expected to have already set up an initial guess (e.g. via
POD::Init) so the warm start lives in the column space of V.

Super-saturation ratio bulk equation.  Sets SoR's self equation directly.

Sort a tcl list of numbers low to high

SRH recombination

StressDriftTest — per-component stress regression check.

Used by voxel process decks that compute `averagestress3d` over a
fixed sub-region after stress solves and want to gate on the result.
Designed to coexist with VoxelVolumeTest: volume catches geometry-
construction bugs; stress catches PDE / elasticity / Newton solver
bugs.

Drift model:
  - When |gold| > abs_floor, use RELATIVE drift: |cur - gold| / |gold|.
  - When |gold| <= abs_floor, the component is near the noise floor;
    use ABSOLUTE drift: |cur - gold|, bounded by abs_floor.
Two-mode handling so a near-zero component (szz ~ 1e7 Pa next to a
sxx of ~5 GPa) doesn't fail a 15% relative check on noise.

Args:
  cur=      {sxx syy szz}  three-element list from averagestress3d
  gold=     {sxx syy szz}  reference values
  rel=      relative drift bound (default 0.15 = 15%)
  abs=      absolute floor in Pa (default 1e8 = 0.1 GPa)
  label=    descriptive prefix for log lines (default "")

Transpose a tcl list that is holding numeric matrix data

Simple trapezoidal integration formula
U is a list of evenly spaced values
dU is the separation of the values

Trapezoidal integration over loop sizes for vacancy-flavored loops.

VoxelVolumeTest — volume-integration regression check for voxel decks.

Loops over the FieldServer's currently-meshed bulk materials, integrates
each material's volume (`integrate eqn=Material($mat)`), and compares
against a stored gold-value dict. Drift > `bound` percent on any single
material fails the test. Platform-independent metric — replaces the
old structure-to-structure CompareStruct gating in voxel test decks.

Requires the deck to have called `meshvoxel` first (integrate operates
on the tet mesh, not the voxel brick).