driftlet 1.1.0 → 1.1.1

package/README.md

@@ -56,7 +56,7 @@ import { bandDiagram } from 'driftlet/plot';    // a level diagram as an SVG str
 ```
 
 Or straight from a CDN in a page, pinned to a version:
-`https://cdn.jsdelivr.net/npm/driftlet@1.1.0/src/index.js` (and `src/kit.js`, `src/plot.js`).
+`https://cdn.jsdelivr.net/npm/driftlet@1.1.1/src/index.js` (and `src/kit.js`, `src/plot.js`).
 TypeScript declarations ship in the package. Writing a demo with an LLM agent? Point it at
 [`llms.txt`](llms.txt).
 

package/docs/data.md

@@ -21,6 +21,12 @@ double layers. The data are in `IONS`, and $`\mu^\circ`$ of liquid water is `H2O
 1.011e-14 at 25 °C (pK_w 13.995): neutral water holds 1.0055e-4 mol/m³ of each, which a bath
 with that reaction should hold too.
 
+The data are 25 °C's, and the material says so (`T: 298.15`): a device at another temperature
+warns that they don't hold there. Its μ° (so equilibrium constants and electrode potentials),
+permittivity and diffusivities would all move: $`K_w`$ by ~6× between 6 and 25 °C. Scaling them
+(μ° by the standard entropies, ε, D by water's viscosity) is planned, not done. Where only
+transport between solutions of the same ions matters (a membrane's channels), μ° cancels.
+
 | Ion | z | D (10⁻⁹ m²/s) | $`\mu^\circ`$ (kJ/mol) |
 |---|---|---|---|
 | H+ | +1 | 9.311 | 0 |

package/docs/device.md

@@ -250,7 +250,9 @@ r = \frac{n\,p\,(1 - e^{-A/RT})}{(n + n_1)/v_p + (p + p_1)/v_n}, \qquad p_1 = \f
 with n and p each at its own side's edge node, the capture velocities $`v_n`$ and $`v_p`$ in m/s,
 and $`n_1`$ (mol/m³) the negative species' concentration with its level at the trap (default:
 $`n_1 = p_1 = n_i`$, a midgap trap). Taking $`p_1`$ from the state keeps equilibrium exact whatever
-lies between the two sides (a band offset, a $`\phi`$ jump). Where one carrier is plentiful the
+lies between the two sides (a band offset, a $`\phi`$ jump). With Fermi–Dirac carriers, each
+one's emission scales by its own $`\gamma = \mathcal{F}_{1/2}(\zeta)/e^\zeta`$, by detailed balance:
+$`n_1`$ becomes $`\gamma_n n_1`$, and $`p_1`$ keeps the product. Where one carrier is plentiful the
 rate saturates at the other's capture, $`r \to v_p\,p`$: holes reaching an electron-rich layer
 recombine at $`v_p`$ however many electrons wait there, which plain mass action can't do.
 

package/docs/numerics.md

@@ -450,8 +450,8 @@ The assembled matrix loses what a flux's two entries share. A Scharfetter–Gumm
 $`\eta`$ at its two ends through $`G`$ and $`-G(1 + E)`$, with $`E = \mathrm{expm1}(\Delta\eta)`$;
 for a nearly uniform $`v`$ they cancel, and $`J \cdot v`$ keeps only round-off of $`G|v|`$, which in
 an inversion layer's 0.1 nm cells ($`G`$ ~ 1e11) dwarfs the flux. Where a solve needs
-$`J \cdot v`$ itself (GMRES, in the impedance and in Newton's refined solves), the dilute kernels'
-terms are kept aside instead, each evaluated on differences first:
+$`J \cdot v`$ itself (GMRES, in the impedance and in Newton's refined solves), the kernels' terms
+are kept aside instead, each evaluated on differences first:
 
 ```math
 \delta N = a\,(\delta\eta_L - z\,\delta\hat\phi_L) + b\,(\delta\eta_R - \delta\eta_L) + d\,(\delta\hat\phi_R - \delta\hat\phi_L),
@@ -459,8 +459,13 @@ terms are kept aside instead, each evaluated on differences first:
 
 with $`a = -GE`$ (through $`c_L`$), $`b = -G(1 + E)`$ and $`d`$ the drift's. A node's storage and space
 charge depend on $`\delta\eta_i - z_i\,\delta\hat\phi`$ alone, the displacement on
-$`\delta\hat\phi_R - \delta\hat\phi_L`$. Everything else (faces, contacts, ports, reactions,
-concentrated and metal regions) is assembled into a matrix of its own. Rows that a contact or a
+$`\delta\hat\phi_R - \delta\hat\phi_L`$. Non-ideal statistics couple the species ($`c_i`$
+depends on every $`\zeta_j`$), so there a node's storage of $`i`$ has a term in each
+$`\delta\eta_j - z_j\,\delta\hat\phi`$, through $`K_{ij}`$, and a flux has side terms in those at
+either end (through $`c_L`$ and the excess potentials in its drift); each is in the same
+differences. (Until 1.1.1 they were assembled directly, and a Fermi–Dirac MOS capacitor in
+inversion, barely degenerate, came out with a negative resistance.) Everything else (faces,
+contacts, ports, reactions, metal regions) is assembled into a matrix of its own. Rows that a contact or a
 steady solve replaces drop the kept terms; the transformed rows of strictly neutral nodes combine
 them as they combine the matrix's. A region's uniform shift ($`z_i s`$ on each $`\eta_i`$, $`s`$ on
 $`\hat\phi`$) then gives exactly zero inside it, as it must. It replaced a central difference of
@@ -649,7 +654,7 @@ majority conductances times a $`\delta\eta`$ cancelling its neighbours' to 1e-17
 round-off reads as a constant conductance of order 1 S/m², a silicon p⁺n⁺ junction's capacitance
 9× off at 100 Hz. Between the two contacts of a device without ports, the total current
 (conduction plus displacement, $`i\omega\,\delta D`$) is the same through every cut, so it is also
-read across each segment of an ideal region, linearised as the Scharfetter–Gummel flux is, and
+read across each segment of a region (with any statistics), linearised as its flux is, and
 the reading with the least estimated error is taken: in that junction, the depletion region's;
 in a MOS capacitor, the oxide's displacement. A reading's error is its terms' round-off, and the
 solves' error in $`\delta x`$ (their residual, relative to its largest entry) through its

package/docs/reliability.md

@@ -173,9 +173,6 @@ so a change that makes one worse shows.
 - **A surface covered to a bare fraction below ~1e-10** barely affects anything any more, and
   the solver struggles with it (the hard corpus's passivating drop without a double layer stops
   partway through its hour); the solution warns, and suggests a less stable film.
-- **A double layer across more than ~350 thermal voltages** (between 9 and 9.25 V at 25 °C, in a
-  crowded lattice-gas electrolyte) doesn't solve, from a cold start or warm, and its warning
-  doesn't say why. Ionic-liquid windows (a few volts) are well inside it.
 - **Currents below ~0.1 nA/m²** (a GaAs junction's leakage without recombination) aren't resolved
   between solves; such a current is zero for any practical purpose.
 - **A failed solve says so:** `converged: false`, with a warning naming where the system lost

package/llms.txt

@@ -30,9 +30,9 @@ materials, insertion hosts), data.md and reliability.md (what's validated, and t
 From a CDN, pin the version you tested against:
 
 ```js nocheck
-import { Device, units } from 'https://cdn.jsdelivr.net/npm/driftlet@1.1.0/src/index.js';
-import { build, layer, ohmic, semiconductor, live } from 'https://cdn.jsdelivr.net/npm/driftlet@1.1.0/src/kit.js';
-import { bandDiagram } from 'https://cdn.jsdelivr.net/npm/driftlet@1.1.0/src/plot.js';
+import { Device, units } from 'https://cdn.jsdelivr.net/npm/driftlet@1.1.1/src/index.js';
+import { build, layer, ohmic, semiconductor, live } from 'https://cdn.jsdelivr.net/npm/driftlet@1.1.1/src/kit.js';
+import { bandDiagram } from 'https://cdn.jsdelivr.net/npm/driftlet@1.1.1/src/plot.js';
 ```
 
 From npm: `driftlet`, `driftlet/kit`, `driftlet/plot`. Every export is listed at the end.
@@ -219,9 +219,9 @@ a CDN needs a long virtual-time budget, 30 s.)
 <span id="readout"></span>
 <div id="figure"></div>
 <script type="module">
-import { units } from 'https://cdn.jsdelivr.net/npm/driftlet@1.1.0/src/index.js';
-import { build, layer, ohmic, semiconductor, live } from 'https://cdn.jsdelivr.net/npm/driftlet@1.1.0/src/kit.js';
-import { bandDiagram } from 'https://cdn.jsdelivr.net/npm/driftlet@1.1.0/src/plot.js';
+import { units } from 'https://cdn.jsdelivr.net/npm/driftlet@1.1.1/src/index.js';
+import { build, layer, ohmic, semiconductor, live } from 'https://cdn.jsdelivr.net/npm/driftlet@1.1.1/src/kit.js';
+import { bandDiagram } from 'https://cdn.jsdelivr.net/npm/driftlet@1.1.1/src/plot.js';
 
 const def = build({
   T: 300,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "driftlet",
-  "version": "1.1.0",
+  "version": "1.1.1",
   "description": "Dependency-free 1D drift–diffusion–reaction (Poisson–Nernst–Planck) solver for semiconductors, electrochemistry and nerves, fast enough for live web demos",
   "type": "module",
   "exports": {

package/src/data.js

@@ -66,7 +66,8 @@ export const METALS = freeze(
 
 /**
  * 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
@@ -82,7 +83,8 @@ export function aqueous(names, { epsr = WATER_EPSR, material = 'water' } = {}) {
     species.push({ name, z: ion.z, cRef: 1000 });
     entries[name] = { D: ion.D, mu0: ion.mu0 };
   }
-  return { species, materials: { [material]: { epsr, species: entries } } };
+  // (25 °C data: a device at another temperature warns)
+  return { species, materials: { [material]: { epsr, species: entries, T: 298.15 } } };
 }
 
 // How the semiconductors' data move with temperature, for semiconductor(name, { T }):

package/src/device.js

@@ -308,14 +308,20 @@ export function normalizeDevice(def) {
     };
   });
 
-  // A material whose data are for another temperature than the device's gives the wrong n_i, gap
-  // and mobilities, silently: say so (for each material a region uses).
+  // A material whose data are for another temperature than the device's is silently wrong there
+  // (a semiconductor's n_i, gap and mobilities; water's μ°, ε and D): say so (for each material a
+  // region uses).
   materials.forEach((m, k) => {
     if (m.dataT === undefined || Math.abs(m.dataT - T) <= 0.01 || !regions.some((reg) => reg.material === k)) return;
+    const own = Object.keys(def.materials[m.name].species ?? {}), semi = own.includes('e-') && own.includes('h+');
     warnings.push(
       `materials.${m.name}: its data are for ${m.dataT} K, but the device is at ${T} K${def.T === undefined ? ' (the default, as it gives no T)' : ''}, ` +
-        `so they don't hold there (a semiconductor's n_i, gap and mobilities are ${m.dataT} K's): give the device T: ${m.dataT}, ` +
-        `or remake the material for ${T} K (semiconductor(name, { T: ${T} }))`,
+        (semi
+          ? `so they don't hold there (a semiconductor's n_i, gap and mobilities are ${m.dataT} K's): give the device T: ${m.dataT}, ` +
+            `or remake the material for ${T} K (semiconductor(name, { T: ${T} }))`
+          : `so they don't hold there: its μ° (so equilibrium constants and electrode potentials, Kw's by ~6× between 6 and 25 °C), ` +
+            `permittivity and diffusivities are ${m.dataT} K's. Give the device T: ${m.dataT}, or give the material data for ${T} K ` +
+            `and its T (aqueous() has none at other temperatures yet)`),
     );
   });
 

package/src/difference.js

@@ -8,13 +8,19 @@
 // storage and space charge depend on δη_i − z_i δφ̂ alone; the displacement on δφ̂_R − δφ̂_L. A
 // uniform shift of a region (z_i s on each η_i, s on φ̂) then gives exactly zero, as it must.
 //
+// Non-ideal statistics couple the species: c_i depends on every ζ_j, so a node's storage of i
+// has a term in each δη_j − z_j δφ̂ (K_ij), and a flux has side terms in those at either end (its
+// c_L and the excess potentials in its drift). Each is a term in the same differences, so the
+// shift still gives exactly zero.
+//
 // Indices are compact (the solver's rix), with the sink (index N) for an unknown that isn't one:
 // vectors passed in are read there as zero.
 export class DifferenceTerms {
-  constructor(N, nodes, segments) {
+  constructor(N, nodes, segments, sides = 0) {
     this.N = N;
     this.dead = new Uint8Array(N + 1); // rows replaced since (a contact's level, a held stretch)
-    this.nI = new Int32Array(nodes); // node term: η column (= its balance row), φ̂ column (= Gauss row)
+    this.nR = new Int32Array(nodes); // node term: its balance row, η column, φ̂ column (= Gauss row)
+    this.nI = new Int32Array(nodes);
     this.nP = new Int32Array(nodes);
     this.nZ = new Float64Array(nodes);
     this.nMass = new Float64Array(nodes); // storage per unit (δη − z δφ̂), times 1/dt (or iω)
@@ -24,6 +30,9 @@ export class DifferenceTerms {
     this.sC = new Float64Array(3 * segments); // a, b, d
     this.dI = new Int32Array(2 * segments); // displacement: φ̂_L, φ̂_R
     this.dK = new Float64Array(segments);
+    this.xI = new Int32Array(4 * sides); // a flux's side term: its two rows, an η column, its φ̂ column
+    this.xZ = new Float64Array(sides);
+    this.xC = new Float64Array(sides);
     this.combos = []; // [rk, ri, w]: row rk += w × row ri (strictly neutral nodes' charge rows)
     this.t = new Float64Array(N + 1);
     this.x = new Float64Array(N + 1);
@@ -33,13 +42,16 @@ export class DifferenceTerms {
   // Afresh for an assembly; `rate` multiplies storage in captured rows (1/dt).
   reset(rate = 0) {
     this.rate = rate;
-    this.nn = this.ns = this.nd = 0;
+    this.nn = this.ns = this.nd = this.nx = 0;
     this.dead.fill(0);
     this.combos.length = 0;
   }
 
-  node(i, p, z, mass, charge) {
+  // Storage in row r (mass) and charge in Gauss row p, per unit δη_i − z δφ̂ (row r = i, unless
+  // non-ideal statistics couple the species).
+  node(i, p, z, mass, charge, r = i) {
     const k = this.nn++;
+    this.nR[k] = r;
     this.nI[k] = i;
     this.nP[k] = p;
     this.nZ[k] = z;
@@ -59,6 +71,17 @@ export class DifferenceTerms {
     this.sC[3 * k + 2] = d;
   }
 
+  // A flux from row rL to row rR, per unit δη_i − z δφ̂ at one end.
+  side(rL, rR, i, p, z, w) {
+    const k = this.nx++;
+    this.xI[4 * k] = rL;
+    this.xI[4 * k + 1] = rR;
+    this.xI[4 * k + 2] = i;
+    this.xI[4 * k + 3] = p;
+    this.xZ[k] = z;
+    this.xC[k] = w;
+  }
+
   displacement(pL, pR, k) {
     const q = this.nd++;
     this.dI[2 * q] = pL;
@@ -83,7 +106,7 @@ export class DifferenceTerms {
     for (let k = 0; k < this.nn; k++) {
       const i = this.nI[k], p = this.nP[k], z = this.nZ[k];
       let f = 0;
-      if (row === i) f += mass * this.nMass[k];
+      if (row === this.nR[k]) f += mass * this.nMass[k];
       if (row === p) f += this.nCharge[k];
       if (f === 0) continue;
       add(i, f);
@@ -99,6 +122,12 @@ export class DifferenceTerms {
       add(this.sI[4 * k + 2], s * (-z * a - d));
       add(this.sI[4 * k + 3], s * d);
     }
+    for (let k = 0; k < this.nx; k++) {
+      const s = row === this.xI[4 * k] ? 1 : row === this.xI[4 * k + 1] ? -1 : 0;
+      if (s === 0) continue;
+      add(this.xI[4 * k + 2], s * this.xC[k]);
+      add(this.xI[4 * k + 3], -s * this.xZ[k] * this.xC[k]);
+    }
     for (let q = 0; q < this.nd; q++) {
       const pL = this.dI[2 * q], pR = this.dI[2 * q + 1], s = row === pL ? 1 : row === pR ? -1 : 0;
       if (s === 0) continue;
@@ -114,10 +143,10 @@ export class DifferenceTerms {
     for (let j = 0; j < N; j++) x[j] = v[j];
     x[N] = 0;
     t.fill(0);
-    const { nI, nP, nZ, nMass, nCharge } = this;
+    const { nR, nI, nP, nZ, nMass, nCharge } = this;
     for (let k = 0; k < this.nn; k++) {
       const i = nI[k], p = nP[k], w = x[i] - nZ[k] * x[p];
-      t[i] += mass * nMass[k] * w;
+      t[nR[k]] += mass * nMass[k] * w;
       t[p] += steady * nCharge[k] * w;
     }
     if (steady !== 0) {
@@ -128,6 +157,12 @@ export class DifferenceTerms {
         t[iL] += dN;
         t[iR] -= dN;
       }
+      const { xI, xZ, xC } = this;
+      for (let k = 0; k < this.nx; k++) {
+        const dN = steady * xC[k] * (x[xI[4 * k + 2]] - xZ[k] * x[xI[4 * k + 3]]);
+        t[xI[4 * k]] += dN;
+        t[xI[4 * k + 1]] -= dN;
+      }
       for (let q = 0; q < this.nd; q++) {
         const pL = dI[2 * q], pR = dI[2 * q + 1], dD = -steady * dK[q] * (x[pR] - x[pL]);
         t[pL] += dD;

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/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

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/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;