driftlet 1.0.1 → 1.1.1

package/src/solver.js

@@ -661,7 +661,7 @@ export class Solver {
     }
     this.res = new Float64Array(N + 1);
     this.delta = new Float64Array(N + 1);
-    this.rowScale = new Float64Array(N + 1).fill(1); // each row's scaling in the factorised system
+    this.rowDiv = new Float64Array(N + 1).fill(1); // what each row is divided by in the factorised system
   }
 
   _factor() {
@@ -801,6 +801,19 @@ export class Solver {
     this._laws();
   }
 
+  // A stretch's amount from its regions' starting concentrations (c0), per unit area, before
+  // any state exists: Infinity where one isn't given (set by a level, or doping), to order it last.
+  _roughAmount(st) {
+    const { regions, grid } = this.model;
+    let t = 0;
+    for (let q = st.regions[0]; q <= st.regions[1]; q++) {
+      const reg = regions[q], c0 = reg.c0Profile[st.species] ? profileAt(reg.c0Profile[st.species], grid.x[grid.regionStart[q]]) : reg.c0[st.species];
+      if (!(c0 >= 0)) return Infinity;
+      t += c0 * (grid.x[grid.regionEnd[q]] - grid.x[grid.regionStart[q]]);
+    }
+    return t;
+  }
+
   // Whether a stretch's species moves through it (mobile in every region, or a metal's carrier),
   // or stays still in every region (D = 0: trap states, conserved node by node).
   _moves(st) {
@@ -1305,7 +1318,18 @@ export class Solver {
     // Reduced row echelon form; the free columns give the null space. Immobile stretches' columns
     // go first, so that a combination of them alone (trap states, X⁰ + X⁻) comes out on its own,
     // to be kept node by node, apart from any that moves (e⁻ − X⁰, the electrons the traps hold).
-    const order = [...Array(C).keys()].sort((a, b) => (b < S && this._still(this.stretches[b])) - (a < S && this._still(this.stretches[a])));
+    // Then the stretches by their starting amounts, least first, and by name: a trace species
+    // pivoted after an abundant one comes out added to it (A + B ⇌ C with B at 1 M and A at 1e-14
+    // gave B + C and A − B, where A + C was lost to round-off), and the basis followed the listing.
+    const still = (k) => (k < S && this._still(this.stretches[k]) ? 1 : 0);
+    const rough = this.stretches.map((st) => this._roughAmount(st)), name = (k) => model.species[this.stretches[k].species].name;
+    const order = [...Array(C).keys()].sort((a, b) => {
+      if (still(a) !== still(b)) return still(b) - still(a);
+      if (a >= S || b >= S) return a - b;
+      if (rough[a] !== rough[b]) return rough[a] - rough[b];
+      const na = name(a), nb = name(b);
+      return na < nb ? -1 : na > nb ? 1 : a - b;
+    });
     const pivots = [];
     let r = 0;
     for (const col of order) {
@@ -2270,10 +2294,23 @@ export class Solver {
       return;
     }
     let q = this.rhoFixed[g], dq = 0;
+    const lin = this.lin;
     for (let i = 0; i < n; i++) {
       const k = g * n + i, r = 1 + i;
       if (!this.present[k]) continue;
       const Kz = this._Kz(g, i);
+      if (lin) {
+        // In difference form (see DifferenceTerms): storage of i and its charge, in each
+        // δη_j − z_j δφ̂ through K_ij.
+        res[R[b * M + r]] += (v * (c[k] - this.cOld[k])) / dt;
+        q += F * z[i] * c[k];
+        const Kg = g * n * n + i * n;
+        for (let j = 0; j < n; j++) {
+          const Kij = this.nodeIdeal[g] ? (i === j ? c[k] : 0) : this.K[Kg + j];
+          if (Kij !== 0) lin.node(R[b * M + 1 + j], R[b * M], z[j], v * Kij, -v * F * z[i] * Kij, R[b * M + r]);
+        }
+        continue;
+      }
       this._storage(g, i, dt, Kz);
       q += F * z[i] * c[k];
       dq += F * z[i] * Kz;
@@ -2282,7 +2319,7 @@ export class Solver {
     // (where no charge responds and no field reaches, φ isn't defined, nor an unknown)
     if (!this.phiUndefined[g]) {
       res[R[b * M]] -= v * q;
-      this._j(b, 0, b, 0, v * dq);
+      if (!lin) this._j(b, 0, b, 0, v * dq);
     }
   }
 
@@ -2420,7 +2457,7 @@ export class Solver {
           aHi += rx.nu[p] * u[b * M + 1 + rx.sp[p]];
           aLo += rx.nu[p] * uLo[b * M + 1 + rx.sp[p]];
         }
-        const { rate, Cn, Cp, Ca } = this._srhRate(law, c[g * n + law.n.i], c[g * n + law.p.i], aHi + aLo);
+        const { rate, Cn, Cp, Ca } = this._srhRate(law, c[g * n + law.n.i], c[g * n + law.p.i], aHi + aLo, ...this._srhDegen(g, g, law));
         dr.fill(0);
         this._dlnc(g, law.n.i, Cn, dr);
         this._dlnc(g, law.p.i, Cp, dr);
@@ -2690,39 +2727,28 @@ export class Solver {
   // still exactly zero at equilibrium. c_L and ex depend on every ζ at their node through K.
   _segmentConcentrated(s, bL, bR, mat, h, vel) {
     const R = this.rix;
-    const { n, M, u, uLo, res, c, z, K, ex, jL, jR } = this;
-    const gL = s, gR = s + 1, KL = gL * n * n, KR = gR * n * n;
+    const { n, M, res, z, K } = this;
+    const KL = s * n * n, KR = (s + 1) * n * n;
     for (let i = 0; i < n; i++) {
       if (!mat.present[i] || mat.D[i] === 0) continue;
       const r = 1 + i, zi = z[i];
-      const cL = c[gL * n + i], cR = c[gR * n + i];
-      const g = mat.D[i] / h;
-      const pe = (vel * h) / mat.D[i];
-      const d = zi * (u[bR * M] - u[bL * M]) + ex[gR * n + i] - ex[gL * n + i] - pe;
-      const deta = u[bR * M + r] - u[bL * M + r] + (uLo[bR * M + r] - uLo[bL * M + r]) - pe;
-      const E = Math.expm1(deta);
-      const B = bernoulli(d), Bp = bernoulliDerivative(d);
-      const gBc = g * B * cL;
-      const N = -gBc * E;
-      const dNdd = -g * Bp * cL * E;
-      // Left node: ∂N/∂ζ_Lj = −gE(B + B′)K_L,ij − dNdd·δ_ij, plus the direct η_L,i term.
-      const fL = -g * E * (B + Bp);
-      jL[0] = -fL * this._Kz(gL, i);
-      for (let j = 0; j < n; j++) jL[1 + j] = fL * K[KL + i * n + j];
-      jL[r] += -dNdd + gBc * (E + 1);
-      // Right node: ∂N/∂ζ_Rj = dNdd·(δ_ij − K_R,ij/c_R), plus the direct η_R,i term.
-      jR.fill(0);
-      if (cR > 0) {
-        const fR = -dNdd / cR;
-        jR[0] = -fR * this._Kz(gR, i);
-        for (let j = 0; j < n; j++) jR[1 + j] = fR * K[KR + i * n + j];
-      } else {
-        jR[0] = dNdd * zi; // K/c → δ as c → 0
-        jR[r] -= dNdd;
-      }
-      jR[r] += dNdd - gBc * (E + 1);
+      const { N, E, gBc, dNdd, fL, cR } = this._fluxConcentrated(s, bL, bR, mat, h, vel, i);
       res[R[bL * M + r]] += N;
       res[R[bR * M + r]] -= N;
+      if (this.lin) {
+        // In difference form (see DifferenceTerms): b on Δη_i and z_i·∂N/∂d on Δφ̂, and the rest
+        // as side terms in each δη_j − z_j δφ̂ at either end (c_L and the excess potentials).
+        const rL = R[bL * M + r], rR = R[bR * M + r], pL = R[bL * M], pR = R[bR * M];
+        this.lin.segment(rL, rR, pL, pR, zi, 0, -gBc * (E + 1), zi * dNdd);
+        for (let j = 0; j < n; j++) {
+          const wL = fL * K[KL + i * n + j] - (j === i ? dNdd : 0);
+          const wR = cR > 0 ? dNdd * ((j === i ? 1 : 0) - K[KR + i * n + j] / cR) : 0;
+          if (wL !== 0) this.lin.side(rL, rR, R[bL * M + 1 + j], pL, z[j], wL);
+          if (wR !== 0) this.lin.side(rL, rR, R[bR * M + 1 + j], pR, z[j], wR);
+        }
+        continue;
+      }
+      const { jL, jR } = this;
       for (let k = 0; k < M; k++) {
         if (jL[k] !== 0) {
           this._j(bL, r, bL, k, jL[k]);
@@ -2736,6 +2762,40 @@ export class Solver {
     }
   }
 
+  // Species i's flux across segment s of a non-ideal region, toward +x, and its derivatives in
+  // this.jL and this.jR (over the unknowns of the blocks bL and bR).
+  _fluxConcentrated(s, bL, bR, mat, h, vel, i) {
+    const { n, M, u, uLo, c, z, K, ex, jL, jR } = this;
+    const gL = s, gR = s + 1, KL = gL * n * n, KR = gR * n * n, r = 1 + i, zi = z[i];
+    const cL = c[gL * n + i], cR = c[gR * n + i];
+    const g = mat.D[i] / h;
+    const pe = (vel * h) / mat.D[i];
+    const d = zi * (u[bR * M] - u[bL * M]) + ex[gR * n + i] - ex[gL * n + i] - pe;
+    const deta = u[bR * M + r] - u[bL * M + r] + (uLo[bR * M + r] - uLo[bL * M + r]) - pe;
+    const E = Math.expm1(deta);
+    const B = bernoulli(d), Bp = bernoulliDerivative(d);
+    const gBc = g * B * cL;
+    const N = -gBc * E;
+    const dNdd = -g * Bp * cL * E;
+    // Left node: ∂N/∂ζ_Lj = −gE(B + B′)K_L,ij − dNdd·δ_ij, plus the direct η_L,i term.
+    const fL = -g * E * (B + Bp);
+    jL[0] = -fL * this._Kz(gL, i);
+    for (let j = 0; j < n; j++) jL[1 + j] = fL * K[KL + i * n + j];
+    jL[r] += -dNdd + gBc * (E + 1);
+    // Right node: ∂N/∂ζ_Rj = dNdd·(δ_ij − K_R,ij/c_R), plus the direct η_R,i term.
+    jR.fill(0);
+    if (cR > 0) {
+      const fR = -dNdd / cR;
+      jR[0] = -fR * this._Kz(gR, i);
+      for (let j = 0; j < n; j++) jR[1 + j] = fR * K[KR + i * n + j];
+    } else {
+      jR[0] = dNdd * zi; // K/c → δ as c → 0
+      jR[r] -= dNdd;
+    }
+    jR[r] += dNdd - gBc * (E + 1);
+    return { N, E, gBc, dNdd, fL, cR };
+  }
+
   // Ohmic conduction in a metal, in mixed form. The flux J (slot 0 of the left node) obeys
   //   η_R − η_L + J/g = 0,  g = σ RT/(z²F² h)   (Ohm's law, J = −g Δη),
   // and enters the two nodes' carrier balances as outflow and inflow.
@@ -2856,7 +2916,7 @@ export class Solver {
       aLo += rx.nu[p] * uLo[b * M + 1 + rx.sp[p]];
     }
     const law = rx.srh?.[this.nodeMaterial[g]];
-    if (law) return this._srhRate(law, c[g * n + law.n.i], c[g * n + law.p.i], aHi + aLo).rate;
+    if (law) return this._srhRate(law, c[g * n + law.n.i], c[g * n + law.p.i], aHi + aLo, ...this._srhDegen(g, g, law)).rate;
     let P = rx.generation ? rx.kfNode[g] * this.generationScale : rx.kfNode[g];
     for (let p = 0; p < rx.sp.length; p++) if (rx.nu[p] > 0) P *= rx.nu[p] === 1 ? c[g * n + rx.sp[p]] : powi(c[g * n + rx.sp[p]], rx.nu[p]);
     return P * -Math.expm1(-(aHi + aLo));
@@ -2870,7 +2930,7 @@ export class Solver {
     if (law) {
       let a = rx.fixedA;
       for (let p = 0; p < rx.sp.length; p++) a += rx.nu[p] * (u[b * M + 1 + rx.sp[p]] + uLo[b * M + 1 + rx.sp[p]]);
-      return this._srhRate(law, c[g * n + law.n.i], c[g * n + law.p.i], a).forward;
+      return this._srhRate(law, c[g * n + law.n.i], c[g * n + law.p.i], a, ...this._srhDegen(g, g, law)).forward;
     }
     let P = rx.generation ? rx.kfNode[g] * this.generationScale : rx.kfNode[g];
     for (let p = 0; p < rx.sp.length; p++) if (rx.nu[p] > 0) P *= rx.nu[p] === 1 ? c[g * n + rx.sp[p]] : powi(c[g * n + rx.sp[p]], rx.nu[p]);
@@ -2884,7 +2944,7 @@ export class Solver {
     let a = rx.fixedA;
     for (let p = 0; p < rx.sp.length; p++) a += rx.nu[p] * (u[b * M + 1 + rx.sp[p]] + uLo[b * M + 1 + rx.sp[p]]);
     const law = rx.srh?.[this.nodeMaterial[g]];
-    if (law) return this._srhRate(law, c[g * n + law.n.i], c[g * n + law.p.i], a).oneWay;
+    if (law) return this._srhRate(law, c[g * n + law.n.i], c[g * n + law.p.i], a, ...this._srhDegen(g, g, law)).oneWay;
     let P = rx.generation ? rx.kfNode[g] * this.generationScale : rx.kfNode[g];
     for (let p = 0; p < rx.sp.length; p++) if (rx.nu[p] > 0) P *= rx.nu[p] === 1 ? c[g * n + rx.sp[p]] : powi(c[g * n + rx.sp[p]], rx.nu[p]);
     return P * Math.max(1, Math.exp(-a));
@@ -2892,21 +2952,46 @@ export class Solver {
 
   // SRH kinetics (see srhLaw in device.js): the rate, and its sensitivities to ln n, ln p and
   // a = A/RT. With no n₁ given, the trap is midgap: n₁ = p₁ = n_i = √(n p e^{−a}).
-  _srhRate(law, cn, cp, a) {
+  // SRH at electron and hole concentrations cn, cp and affinity a. n₁p₁ = n p e^{−a} (n_i² for
+  // Boltzmann carriers), and under degeneracy each carrier's emission scales with its own
+  // γ = e^{−ex} (its excess chemical potential ex, c/K = ∂ln c/∂ζ its slope): n₁ = γ_n n₁₀ and
+  // p₁ = γ_p p₁₀, n₁₀ the law's n1, or n_i at midgap. (γ_n γ_p split evenly onto both, as it was,
+  // put a degenerate n⁺ region's γ_n on its holes' emission too.) The rate's derivatives in ln n,
+  // ln p and a. For large negative a (strong extraction), np·(1 − e^{−a}) as −n p e^{−a}.
+  _srhRate(law, cn, cp, a, xn = 0, xp = 0, sn = 1, sp = 1) {
     const { tn, tp } = law, lnnp = Math.log(cn) + Math.log(cp);
-    let n1, kN = 0, kP = 0, kA = 0; // ln n₁ = kN ln n + kP ln p + kA a + const
+    let lnn1, kN = 0, kP = 0, kA = 0; // ln n₁ = kN ln n + kP ln p + kA a + const
     if (Number.isNaN(law.n1)) {
-      n1 = Math.exp((lnnp - a) / 2);
-      kN = kP = 0.5;
+      lnn1 = (lnnp - a - xn + xp) / 2; // γ_n n_i, with n_i² = n p e^{−a}/(γ_n γ_p)
+      kN = (2 - sn) / 2;
+      kP = sp / 2;
       kA = -0.5;
-    } else n1 = law.n1;
-    const p1 = Math.exp(lnnp - a - Math.log(n1)), np = cn * cp;
-    const den = tp * (cn + n1) + tn * (cp + p1), f = -Math.expm1(-a);
-    const rate = (np * f) / den;
+    } else {
+      lnn1 = Math.log(law.n1) - xn;
+      kN = 1 - sn;
+    }
+    const n1 = Math.exp(lnn1), p1 = Math.exp(lnnp - a - lnn1), np = cn * cp;
+    const den = tp * (cn + n1) + tn * (cp + p1);
+    // np(1 − e^{−a}), with e^{−a} folded into np where it would overflow
+    const f = -Math.expm1(-a), num = a > -700 ? np * f : np - Math.exp(lnnp - a);
+    const rate = num / den;
     const dDn = tp * cn + tp * n1 * kN + tn * p1 * (1 - kN);
     const dDp = tp * n1 * kP + tn * cp + tn * p1 * (1 - kP);
     const dDa = tp * n1 * kA + tn * p1 * (-1 - kA);
-    return { rate, forward: np / den, oneWay: (np / den) * Math.max(1, Math.exp(-a)), Cn: rate * (1 - dDn / den), Cp: rate * (1 - dDp / den), Ca: (np / den) * (1 - f) - (rate * dDa) / den };
+    return { rate, forward: np / den, oneWay: a > -700 ? (np / den) * Math.max(1, Math.exp(-a)) : Math.exp(lnnp - a) / den, Cn: rate * (1 - dDn / den), Cp: rate * (1 - dDp / den), Ca: (a > -700 ? (np / den) * (1 - f) : Math.exp(lnnp - a) / den) - (rate * dDa) / den };
+  }
+
+  // _srhRate's degeneracy arguments: the electrons' at node gn, the holes' at gq.
+  _srhDegen(gn, gq, law) {
+    const [xn, sn] = this._degen(gn, law.n.i), [xp, sp] = this._degen(gq, law.p.i);
+    return [xn, xp, sn, sp];
+  }
+
+  // A carrier's excess chemical potential at node g and ∂ln c/∂ζ there (0 and 1 if ideal).
+  _degen(g, i) {
+    if (this.nodeIdeal[g]) return [0, 1];
+    const n = this.n, c = this.c[g * n + i], K = this.K[g * n * n + i * n + i];
+    return [this.ex[g * n + i], c > 0 && K > 0 ? c / K : 1];
   }
 
   // A face reaction (see normalizeFaceReactions). Its rate r_k is an unknown of the face block,
@@ -2949,7 +3034,7 @@ export class Solver {
     } else if (rx.srh) {
       // SRH, with n and p each at its own side's edge node.
       const { n: pn, p: pp } = rx.srh, gn = pn.side ? gR : gL, gq = pp.side ? gR : gL;
-      const s = this._srhRate(rx.srh, c[gn * n + pn.i], c[gq * n + pp.i], aHi + aLo);
+      const s = this._srhRate(rx.srh, c[gn * n + pn.i], c[gq * n + pp.i], aHi + aLo, ...this._srhDegen(gn, gq, { n: pn, p: pp }));
       rate = s.rate;
       this._dlnc(gn, pn.i, s.Cn, pn.side ? dR : dL);
       this._dlnc(gq, pp.i, s.Cp, pp.side ? dR : dL);
@@ -3049,7 +3134,7 @@ export class Solver {
       const r = 1 + i, target = this.portEta(port, i), zF = z[i] * F;
       for (const g of port.nodes) {
         const b = this.blockOfNode[g], o = b * M + r, v = vol[g];
-        const deta = target - (u[o] + uLo[o]); // (μ̄_out − μ̄)/RT
+        const deta = target - u[o] - uLo[o]; // (μ̄_out − μ̄)/RT
         if (link.type === 'equilibrium') {
           // a device end node's level is its contact's business, where the contact links it
           if ((g === 0 && this.model.contacts.left.species[i].type !== 'blocked') || (g === this.nNodes - 1 && this.model.contacts.right.species[i].type !== 'blocked')) continue;
@@ -3294,7 +3379,7 @@ export class Solver {
       const link = ct.species[i];
       const o = b * M + 1 + i;
       if (link.type === 'exchange') {
-        res[R[o]] -= Ac * link.k * (link.mu / model.RT - (u[o] + uLo[o]));
+        res[R[o]] -= Ac * link.k * (link.mu / model.RT - u[o] - uLo[o]);
         this._j(b, 1 + i, b, 1 + i, Ac * link.k);
       } else if (link.type === 'conductance') {
         const Vi = (VT * (u[o] + uLo[o])) / z[i];
@@ -3303,7 +3388,7 @@ export class Solver {
         B[R[o]] += (-Ac * link.G) / (z[i] * F);
       } else if (link.type === 'velocity') {
         // N_in = v c (e^(η_out − η) − 1): v (c_eq − c), c_eq in equilibrium with the outside.
-        const ci = c[g * n + i], E = Math.exp(Math.min(this.contactEta(side, i) - (u[o] + uLo[o]), 700));
+        const ci = c[g * n + i], E = Math.exp(Math.min(this.contactEta(side, i) - u[o] - uLo[o], 700));
         const N = Ac * link.v * ci * (E - 1), d = this.dA;
         res[R[o]] -= N;
         d.fill(0);
@@ -3321,7 +3406,7 @@ export class Solver {
       const o = b * M + 1 + i;
       this._replaceRow(b, 1 + i);
       this._j(b, 1 + i, b, 1 + i, 1);
-      res[R[o]] = u[o] + uLo[o] - this.contactEta(side, i);
+      res[R[o]] = u[o] - this.contactEta(side, i) + uLo[o]; // (the big terms first: u + uLo rounds to u)
       if (z[i] !== 0) B[R[o]] += -z[i] / VT;
     }
 
@@ -3360,7 +3445,7 @@ export class Solver {
       if (link.type === 'pinned') {
         // φ_edge = V_t − zeroCharge (the C → ∞ limit).
         this._j(b, 0, b, 0, 1);
-        res[R[b * M]] = u[b * M] + uLo[b * M] - (Vt - link.zeroCharge) / VT;
+        res[R[b * M]] = u[b * M] - (Vt - link.zeroCharge) / VT + uLo[b * M];
         B[R[b * M]] += -1 / VT;
       } else {
         // Plain bulk: local neutrality.
@@ -3422,14 +3507,14 @@ export class Solver {
     const { M, u, uLo, res, z, VT, model } = this, R = this.rix;
     for (const st of this.flatStretches) {
       const i = st.species, open = st.leftOpen || st.rightOpen;
-      const { k, hi, lo } = this._flatLevel(st), level = hi + lo;
+      const { k, hi, lo } = this._flatLevel(st);
       for (let g = st.nodes[0]; g <= st.nodes[1]; g++) {
         const b = this.blockOfNode[g], o = b * M + 1 + i;
         if (this.loc[o] < 0) continue;
         this._replaceRow(b, 1 + i);
         for (const B of this.termB) B[R[o]] = 0; // (the row's old terminal terms: the end node's own link)
         this._j(b, 1 + i, b, 1 + i, 1);
-        res[R[o]] = u[o] + uLo[o] - level;
+        res[R[o]] = u[o] - hi + (uLo[o] - lo); // (the big terms first: hi + lo rounds to hi)
         if (open && z[i] !== 0) this.termB[k][R[o]] += -z[i] / VT;
       }
       // A face inside the stretch whose link holds the level continuous carries the species' flux
@@ -3482,7 +3567,8 @@ export class Solver {
     if (b < nB - 1) sys.C.fill(0, sys.offC[b] + l * sz[b + 1], sys.offC[b] + (l + 1) * sz[b + 1]);
   }
 
-  // Scale every row by its largest Jacobian entry (in place, residual too).
+  // Scale every row by its largest Jacobian entry (in place, residual too), dividing by it: its
+  // reciprocal overflows where it's subnormal (a co-ion crowded out of a double layer, ~1e-310).
   _equilibrate() {
     const { nB, sys, res, termB } = this, live = this._liveTerms();
     const { A, B, C, sizes, offA, offB, offC, offX } = sys;
@@ -3495,16 +3581,16 @@ export class Solver {
         for (let k = 0; k < m; k++) mx = Math.max(mx, Math.abs(B[ob + k]));
         for (let k = 0; k < mn; k++) mx = Math.max(mx, Math.abs(C[oc + k]));
         if (mx === 0) {
-          this.rowScale[offX[b] + r] = 1;
+          this.rowDiv[offX[b] + r] = 1;
           continue;
         }
-        const s = 1 / mx;
-        this.rowScale[offX[b] + r] = s;
-        for (let k = 0; k < mp; k++) A[oa + k] *= s;
-        for (let k = 0; k < m; k++) B[ob + k] *= s;
-        for (let k = 0; k < mn; k++) C[oc + k] *= s;
-        res[offX[b] + r] *= s;
-        for (const k of live) termB[k][offX[b] + r] *= s; // (each terminal's ∂/∂V)
+        const d = mx;
+        this.rowDiv[offX[b] + r] = d;
+        for (let k = 0; k < mp; k++) A[oa + k] /= d;
+        for (let k = 0; k < m; k++) B[ob + k] /= d;
+        for (let k = 0; k < mn; k++) C[oc + k] /= d;
+        res[offX[b] + r] /= d;
+        for (const k of live) termB[k][offX[b] + r] /= d; // (each terminal's ∂/∂V)
       }
     }
   }
@@ -3515,7 +3601,8 @@ export class Solver {
   _assembleDifference(dt) {
     const keep = this.sys;
     const rest = this.sysRest ?? (this.sysRest = new BlockTridiagonal(keep.n, keep.sizes));
-    const lin = this.diffTerms ?? (this.diffTerms = new DifferenceTerms(keep.size, this.nNodes * this.n, this.nNodes * this.n));
+    const n = this.n, nN = this.nNodes;
+    const lin = this.diffTerms ?? (this.diffTerms = new DifferenceTerms(keep.size, nN * n * n, nN * n, 2 * nN * n * n));
     this.sys = rest;
     this.lin = lin;
     try {
@@ -3536,7 +3623,7 @@ export class Solver {
   // solve's and leave refined (in the transformed unknowns, as _solveBordered gives them); false
   // if refining didn't help, leaving them as they came.
   _refine(dt, delta, deltaV) {
-    const { res, termRes, termB, termC, termDI, rowScale, floating: fl } = this;
+    const { res, termRes, termB, termC, termDI, rowDiv, floating: fl } = this;
     const N = this.sys.size, K = fl.length, pins = this.pins, R = this.rix;
     const save = { res: Float64Array.from(res), termRes: Float64Array.from(termRes), termB: termB.map((b) => Float64Array.from(b)), termC: termC.map((c) => Float64Array.from(c)), termDI: Float64Array.from(termDI), transformed: this.transformed, pinRes: this.pins.map((p) => p.res) };
     const restoreArrays = () => {
@@ -3568,7 +3655,7 @@ export class Solver {
       for (let j = 0; j < N; j++) {
         let t = jv[j];
         for (let a = 0; a < K; a++) t += Bk[a][j] * x[N + a];
-        out[j] = t * rowScale[j];
+        out[j] = t / rowDiv[j];
       }
       for (let a = 0; a < K; a++) {
         let t = Dk[a] * x[N + a];
@@ -4755,9 +4842,9 @@ export class Solver {
   }
 
   // The cuts where the impedance may read a small-signal current. Each is the linearised total
-  // current toward +x through one segment s of an ideal region, Σ (g + iω d)·δu over the
-  // unknowns idx: the Scharfetter–Gummel fluxes' derivatives (as in _segmentsDilute) and the
-  // displacement's. Without ports it's the same through every cut; with them, only between a
+  // current toward +x through one segment s of a region, Σ (g + iω d)·δu over the unknowns idx:
+  // the Scharfetter–Gummel fluxes' derivatives (as in _segmentsDilute, or _segmentConcentrated
+  // for non-ideal statistics) and the displacement's. Without ports it's the same through every cut; with them, only between a
   // contact and the nearest port's window (see _impedance).
   _currentCuts() {
     const { model, n, M, u, uLo, c, z } = this, F = FARADAY;
@@ -4765,7 +4852,7 @@ export class Solver {
     const cuts = [];
     for (let r = 0; r < regions.length; r++) {
       const reg = regions[r], mat = materials[reg.material];
-      if (mat.conductor || !mat.ideal || reg.mixing > 0) continue;
+      if (mat.conductor || reg.mixing > 0) continue;
       const vel = reg.velocity;
       for (let s = grid.regionStart[r]; s < grid.regionEnd[r]; s++) {
         const bL = s + r, bR = bL + 1, h = grid.segLength[s] / grid.segArea[s];
@@ -4779,6 +4866,15 @@ export class Solver {
         const phiL = u[bL * M], phiR = u[bR * M], hasPhi = !this.phiUndefined[s];
         for (let i = 0; i < n; i++) {
           if (z[i] === 0 || !mat.present[i] || mat.D[i] === 0) continue;
+          if (!mat.ideal) {
+            this._fluxConcentrated(s, bL, bR, mat, h, vel, i);
+            for (let k = 0; k < M; k++) {
+              if (k === 0 && !hasPhi) continue;
+              if (this.jL[k] !== 0) add(bL * M + k, z[i] * F * this.jL[k], 0);
+              if (this.jR[k] !== 0) add(bR * M + k, z[i] * F * this.jR[k], 0);
+            }
+            continue;
+          }
           const zi = z[i], r1 = 1 + i, cL = c[s * n + i], g = mat.D[i] / h;
           const pe = (vel * h) / mat.D[i];
           const d = zi * (phiR - phiL) - pe;

package/src/stack.js

@@ -4,7 +4,7 @@
 // that you didn't write: it only moves things to where the definition keeps them, and converts
 // the kit's doping shorthand (donors and acceptors).
 
-import { DeviceError, checkOptions } from './errors.js';
+import { DeviceError, checkOptions, shown } from './errors.js';
 import { FARADAY } from './constants.js';
 
 const fail = (message) => {
@@ -131,6 +131,7 @@ const STACK_FIELDS = ['T', 'library', 'species', 'materials', 'stack', 'bulkReac
 export function build(def) {
   if (!isObject(def)) fail('build: give { library, stack, … }');
   fields(def, 'build', STACK_FIELDS);
+  if (def.T !== undefined && !(typeof def.T === 'number' && Number.isFinite(def.T) && def.T > 0)) fail(`build.T must be the temperature in K, a positive number, got ${shown(def.T)}`);
   if (def.library !== undefined && !Array.isArray(def.library)) fail('build.library must be a list of { species, materials }');
   const { species, materials } = combine(...(def.library ?? []), { species: def.species ?? [], materials: def.materials ?? {} });
 

package/src/types.js

@@ -39,6 +39,8 @@
  * @property {{ species: string, conductivity: number }} [conductor] a metal or fast ion
  *   conductor: its one carrier and conductivity (S/m); its only level is the carrier's (a metal's
  *   Fermi level), and φ is undefined inside
+ * @property {number} [T] the temperature its data are for (K): a device at another temperature
+ *   warns (semiconductor() sets it)
  */
 
 /**

package/types/data.d.ts

@@ -1,6 +1,7 @@
 /**
  * Water with the named ions, as a library piece for `build()`: each ion as a species
- * (c_ref = 1 M) and the material `water` holding them, with D and μ° from `IONS`.
+ * (c_ref = 1 M) and the material `water` holding them, with D and μ° from `IONS`. The data are
+ * 25 °C's, and the material says so (T: 298.15): a device at another temperature warns.
  * @param {string[]} names ions from `IONS`
  * @param {{ epsr?: number, material?: string }} [opts] permittivity (default that of water;
  *   0 makes the solution strictly neutral, without double layers), and the material's name
@@ -15,19 +16,56 @@ export function aqueous(names: string[], { epsr, material }?: {
 };
 /**
  * A semiconductor from `SEMICONDUCTORS`, as a library piece: electrons `e-` and holes `h+`, with
- * c_ref = Nc and Nv, D from the mobilities by the Einstein relation at 300 K, and μ°_e⁻ = 0 (φ
- * anchored at the conduction band) and μ°_h⁺ = Eg·F. The data are for 300 K, so use `T: 300`.
+ * c_ref = Nc and Nv, D from the mobilities by the Einstein relation at T, and μ°_e⁻ = 0 (φ
+ * anchored at the conduction band) and μ°_h⁺ = Eg·F. The data are for 300 K; another T (150 to
+ * 500 K) moves them: the gap by Varshni's shift from 300 K, Nc and Nv as T^1.5, the mobilities by
+ * lattice-limited power laws (light doping). The material carries its `T`, and a device at
+ * another temperature warns: give the device the same T.
  * Statistics are ideal (Boltzmann); add Fermi–Dirac to the material for degenerate doping.
  * @param {string} name 'Si', 'Ge' or 'GaAs'
- * @param {{ material?: string }} [opts]
+ * @param {{ material?: string, T?: number }} [opts] the material's name, and the temperature
+ *   (K, default 300, the table's)
  * @returns {{ species: object[], materials: Record<string, object> }}
  */
-export function semiconductor(name: string, { material }?: {
+export function semiconductor(name: string, { material, T }?: {
     material?: string;
+    T?: number;
 }, ...args: any[]): {
     species: object[];
     materials: Record<string, object>;
 };
+/**
+ * A trap level in a semiconductor that holds charge: its two charge states as immobile species
+ * (D = 0), filled and emptied by capturing carriers, e⁻ + X⁰ = X⁻ and X⁻ + h⁺ = X⁰ (acceptor-like)
+ * or X⁺ + e⁻ = X⁰ and X⁰ + h⁺ = X⁺ (donor-like). In steady state it recombines at exactly the
+ * `srh` law's rate with the same τ_n, τ_p and n₁, and its charge is in Poisson's equation, which
+ * the `srh` law (the trap's occupancy eliminated) leaves out. Each node keeps its own total.
+ * @param {{ species: object[], materials: Record<string, object> }} lib a library entry with e⁻
+ *   and h⁺ (semiconductor()), returned with the trap's states added
+ * @param {{ density: number, tauN: number, tauP: number, n1?: number, charge?: 'acceptor' | 'donor',
+ *   name?: string, material?: string, T?: number }} opts density N_t (mol/m³); τ_n = 1/(c_n N_t)
+ *   and τ_p = 1/(c_p N_t) (s) at that density; n₁, the electron density that half-fills it
+ *   (mol/m³; default n_i, midgap); T (K, default the material's T, else 300)
+ * @returns {{ library: object, bulkReactions: object[], c0: Record<string, number> }} the library
+ *   for build(), the capture reactions, and c0 for each layer holding the trap (its total N_t)
+ */
+export function trap(lib: {
+    species: object[];
+    materials: Record<string, object>;
+}, { density, tauN, tauP, n1, charge, name, material, T }?: {
+    density: number;
+    tauN: number;
+    tauP: number;
+    n1?: number;
+    charge?: "acceptor" | "donor";
+    name?: string;
+    material?: string;
+    T?: number;
+}, ...args: any[]): {
+    library: object;
+    bulkReactions: object[];
+    c0: Record<string, number>;
+};
 /**
  * A metal from `METALS` as a conductor material, its carrier `e-`.
  * @param {string} name
@@ -57,7 +95,7 @@ export const H2O: -237.129e3;
 export const WATER_EPSR: 78.3;
 /**
  * Semiconductors at 300 K (Sze, Physics of Semiconductor Devices, 2nd ed., 1981, appendix):
- * relative permittivity, band gap Eg (eV), electron affinity chi (V), effective densities of
+ * relative permittivity, band gap Eg (eV), electron affinity chi (eV), effective densities of
  * states Nc and Nv (cm⁻³), and drift mobilities of lightly doped material mun and mup
  * (cm²/(V·s)).
  */

package/types/difference.d.ts

@@ -1,7 +1,8 @@
 export class DifferenceTerms {
-    constructor(N: any, nodes: any, segments: any);
+    constructor(N: any, nodes: any, segments: any, sides?: number);
     N: any;
     dead: Uint8Array<any>;
+    nR: Int32Array<any>;
     nI: Int32Array<any>;
     nP: Int32Array<any>;
     nZ: Float64Array<any>;
@@ -12,6 +13,9 @@ export class DifferenceTerms {
     sC: Float64Array<ArrayBuffer>;
     dI: Int32Array<ArrayBuffer>;
     dK: Float64Array<any>;
+    xI: Int32Array<ArrayBuffer>;
+    xZ: Float64Array<ArrayBuffer>;
+    xC: Float64Array<ArrayBuffer>;
     combos: any[];
     t: Float64Array<any>;
     x: Float64Array<any>;
@@ -20,8 +24,10 @@ export class DifferenceTerms {
     nn: number;
     ns: number;
     nd: number;
-    node(i: any, p: any, z: any, mass: any, charge: any): void;
+    nx: number;
+    node(i: any, p: any, z: any, mass: any, charge: any, r?: any): void;
     segment(iL: any, iR: any, pL: any, pR: any, z: any, a: any, b: any, d: any): void;
+    side(rL: any, rR: any, i: any, p: any, z: any, w: any): void;
     displacement(pL: any, pR: any, k: any): void;
     kill(row: any): void;
     combine(rk: any, ri: any, w: any): void;

package/types/errors.d.ts

@@ -6,6 +6,14 @@
  * @param {new (message: string) => Error} [Kind]
  */
 export function checkOptions(where: string, opts: unknown, allowed: string[], Kind?: new (message: string) => Error): void;
+/**
+ * A value as an error message shows it: a number as itself (NaN and Infinity too, which JSON
+ * would print as null), a string quoted and called one ("350", a string, where a number was
+ * wanted).
+ * @param {unknown} v
+ * @returns {string}
+ */
+export function shown(v: unknown): string;
 export class DeviceError extends Error {
     constructor(message: any);
 }

package/types/kit.d.ts

@@ -66,4 +66,4 @@ export { hodgkinHuxley, ghkCurrent } from "./channels.js";
 export { describe, unitWarnings } from "./describe.js";
 export { henderson, planck } from "./junction.js";
 export { perovskiteCell, PEROVSKITE_SCANS, hysteresis } from "./devices.js";
-export { IONS, H2O, WATER_EPSR, SEMICONDUCTORS, METALS, aqueous, semiconductor, metal } from "./data.js";
+export { IONS, H2O, WATER_EPSR, SEMICONDUCTORS, METALS, aqueous, semiconductor, metal, trap } from "./data.js";

package/types/solver.d.ts

@@ -131,7 +131,7 @@ export class Solver {
     fullOf: Int32Array<ArrayBuffer>;
     res: Float64Array<ArrayBuffer>;
     delta: Float64Array<ArrayBuffer>;
-    rowScale: Float64Array<ArrayBuffer>;
+    rowDiv: Float64Array<ArrayBuffer>;
     _factor(): void;
     _solveLinear(rhs: any, delta: any): void;
     _findStretches(): void;
@@ -139,6 +139,7 @@ export class Solver {
     stretchOf: Int32Array<ArrayBuffer>;
     moieties: Float64Array<any>[];
     flatStretches: any[];
+    _roughAmount(st: any): number;
     _moves(st: any): boolean;
     _still(st: any): boolean;
     _feeds(k: any, st: any): any;
@@ -226,6 +227,14 @@ export class Solver {
     _faceVoltage(f: any): number;
     _faceGates(f: any, bf: any, bL: any, bR: any): void;
     _segmentConcentrated(s: any, bL: any, bR: any, mat: any, h: any, vel: any): void;
+    _fluxConcentrated(s: any, bL: any, bR: any, mat: any, h: any, vel: any, i: any): {
+        N: number;
+        E: number;
+        gBc: number;
+        dNdd: number;
+        fL: number;
+        cR: number;
+    };
     _segmentConductor(s: any, bL: any, bR: any, mat: any, h: any): void;
     _segmentMixing(s: any, bL: any, bR: any, Dm: any, h: any, mat: any): void;
     mixWork: Float64Array<any>[];
@@ -233,7 +242,7 @@ export class Solver {
     bulkRate(rx: any, g: any): number;
     bulkForward(rx: any, g: any): any;
     bulkOneWay(rx: any, g: any): number;
-    _srhRate(law: any, cn: any, cp: any, a: any): {
+    _srhRate(law: any, cn: any, cp: any, a: any, xn?: number, xp?: number, sn?: number, sp?: number): {
         rate: number;
         forward: number;
         oneWay: number;
@@ -241,6 +250,8 @@ export class Solver {
         Cp: number;
         Ca: number;
     };
+    _srhDegen(gn: any, gq: any, law: any): number[];
+    _degen(g: any, i: any): number[];
     _faceReaction(rx: any, k: any, f: any, bf: any, bL: any, bR: any, Af: any): void;
     _liveTerms(): any;
     _allTerms: any;