driftlet 1.1.0 → 1.2.1

package/src/solver.js

@@ -503,6 +503,9 @@ export class Solver {
     this.termB = this.terms.map(() => new Float64Array(this.sys.size + 1));
     this.termC = this.terms.map(() => new Float64Array(this.sys.size + 1));
     this.termDI = new Float64Array(this.terms.length);
+    // (and a circuit row's derivatives by other terminals' voltages: a law in one's row that counts
+    // another electrode's charge)
+    this.termDX = this.terms.map(() => new Float64Array(this.terms.length));
     this.termRes = new Float64Array(this.terms.length);
     this._refreshSources();
     // A floating terminal starts level with the first held one (no current).
@@ -661,7 +664,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() {
@@ -783,7 +786,7 @@ export class Solver {
         const ks = rx.part.map((p) => this.stretchOf[(f + p.side) * n + p.i]);
         if (ks.some((k) => k < 0)) continue;
         join(ks);
-        rxns.push([ks, (side) => rx.part.reduce((a, p) => a + p.nu * this.contactEta(side, p.i), rx.fixedA)]);
+        rxns.push([ks, (side) => rx.part.reduce((a, p) => a - p.nu * this.contactEta(side, p.i), rx.fixedA)]); // (a face's ν: products +, so − Σ ν η)
       }
     });
     const groups = new Map();
@@ -801,6 +804,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) {
@@ -821,6 +837,20 @@ export class Solver {
     return true;
   }
 
+  // The charge number an electrode's carrier column counts its charge in, Q/(zF): its terminal
+  // species', or 1 for a port with none (a membrane's capacitance: Q/F).
+  _carrierZ(k) {
+    const t = this.model.ports[k - 2].terminal;
+    return t === null || t === undefined ? 1 : this.z[t];
+  }
+
+  // Whether contact k (0, 1) holds a charge its current counts, D_in on its φ law (capacitive,
+  // pinned or bulk, where φ is defined at its end node).
+  _contactCharges(k) {
+    const g = k === 0 ? 0 : this.nNodes - 1;
+    return ['capacitive', 'pinned', 'bulk'].includes(this.model.contacts[k === 0 ? 'left' : 'right'].phi.type) && !this.phiUndefined[g];
+  }
+
   // Whether terminal k (a contact, or port k − 2) feeds stretch st: links its species there.
   _feeds(k, st) {
     return k === 0 ? st.leftOpen : k === 1 ? st.rightOpen : st.linked.includes(k - 2);
@@ -848,6 +878,19 @@ export class Solver {
     const driven = (st) => this.terms.flatMap((t, k) => (t.drive.kind === 'I' && this._feeds(k, st) ? [k] : []));
     const add = (parts, rowStretch, surface = [], circuit = -1, carriers = []) => {
       const st = this.stretches[rowStretch];
+      // (the terminal's weight in it, w/z on what that feeds: the amount changes by λ I/F)
+      const own = carriers.find((p) => p.k === circuit);
+      const lambda = circuit < 0 ? 0 : ((own && own.w / this._carrierZ(circuit)) || parts.map((p) => (driven(this.stretches[p.stretch]).includes(circuit) ? p.w / this.z[this.stretches[p.stretch].species] : 0)).find((x) => x !== 0));
+      // In a circuit row, what passes through that terminal's capacitance is kept too, λ Q/F, as
+      // its current counts dQ/dt: a port or contact at no current that passes K⁺ and charges keeps
+      // n_K + Q/F. (Its K⁺ alone held, a membrane port's voltage settled 7 mV from the transient's.)
+      // A port's charge, as an electrode's carrier; a contact's, its displacement D_in, below.
+      if (circuit >= 2 && model.ports[circuit - 2].capacitance && !carriers.some((p) => p.k === circuit)) carriers = [...carriers, { k: circuit, w: lambda * this._carrierZ(circuit) }];
+      // Every contact driven by a current that feeds it and holds a charge, D_in, kept beside the
+      // ions it passes at its own λ (two contacts at no current passing K⁺, one a capacitor: its
+      // charge was left out where the law took the other's row).
+      const lam = (t) => parts.map((p) => (driven(this.stretches[p.stretch]).includes(t) && this.z[this.stretches[p.stretch].species] !== 0 ? p.w / this.z[this.stretches[p.stretch].species] : 0)).find((x) => x !== 0);
+      const contacts = circuit < 0 ? [] : [0, 1].filter((t) => lam(t) && this._contactCharges(t)).map((t) => ({ t, lambda: lam(t) }));
       let nNodes = parts.reduce((m, p) => m + this.stretches[p.stretch].nodes[1] - this.stretches[p.stretch].nodes[0] + 1, 0);
       for (const p of surface) nNodes += model.ports[this.surfCols[p.col][0]].nodes.length * model.ports[this.surfCols[p.col][0]].surface.length;
       for (const p of carriers) nNodes += model.ports[p.k - 2].nodes.length;
@@ -856,11 +899,11 @@ export class Solver {
         parts,
         surface,
         carriers, // (what a port's electrode holds, Q/(zF) at weight w: see _conservedMoieties)
+        contacts, // (contacts whose charges it keeps, λ D_in/F each)
         terminals: [...new Set([...parts.flatMap((p) => driven(this.stretches[p.stretch])), ...carriers.map((p) => p.k)])],
         key: parts.map((p) => `${p.stretch}:${p.w}`).join() + surface.map((p) => `|${p.col}:${p.w}`).join() + carriers.map((p) => `|T${p.k}:${p.w}`).join(),
         circuit, // (the terminal whose circuit row it stands in for, or −1 for a balance row's, `row`)
-        // (and the terminal's weight in it, w/z on what that feeds: the amount changes by λ I/F)
-        lambda: circuit < 0 ? 0 : (carriers.find((p) => p.k === circuit)?.w / this.z[model.ports[circuit - 2]?.terminal] || parts.map((p) => (driven(this.stretches[p.stretch]).includes(circuit) ? p.w / this.z[this.stretches[p.stretch].species] : 0)).find((x) => x !== 0)),
+        lambda,
         row: circuit >= 0 ? -1 : this.blockOfNode[st.nodes[0]] * this.M + 1 + st.species,
         idx: new Int32Array(nNodes * this.M),
         w: new Float64Array(nNodes * this.M),
@@ -877,7 +920,12 @@ export class Solver {
       if (this.flatStretches.includes(st)) this.constraints.at(-1).col = Array.from({ length: st.nodes[1] - st.nodes[0] + 1 }, (_, j) => this.blockOfNode[st.nodes[0] + j] * this.M + 1 + st.species);
     });
     const S = this.stretches.length, T = this.terms.length, X = S + this.surfCols.length;
-    const zc = (k) => this.z[model.ports[k - 2].terminal];
+    // Two column spaces. A law's weights w: stretches [0, S), electrode surfaces' species [S, X)
+    // (surface column k − S), electrodes' charges [X, …) (carrier k − X). The rows a law can take,
+    // v: stretches' balance rows [0, S), then terminals' circuit rows (terminal j − S).
+    const isStretch = (k) => k < S, isSurface = (k) => k >= S && k < X, isCarrier = (k) => k >= X;
+    const circuitOf = (j) => (j >= S ? j - S : -1);
+    const zc = (k) => this._carrierZ(k);
     // The rows replaced: a moving stretch's balance (one of still stretches alone is kept node by
     // node, below), or the circuit row of a terminal driven at no current, which says nothing the
     // combination's balance rows don't (their weighted sum is that terminal's current, weighted
@@ -927,11 +975,16 @@ export class Solver {
       // A current held at zero passes nothing: an electrode at open circuit feeding a closed
       // pool of Ag⁺ beside a slow Fe³⁺/Fe²⁺ couple settled 78 mV off, its iron not stationary.)
       const passes = (k) => !this._noCurrent(this.terms[k]);
-      const fed = (w) => w.some((x, k) => x !== 0 && ((k >= X && passes(this.carriers[k - X])) || (k < S && driven(this.stretches[k]).some(passes))));
+      const fed = (w) => w.some((x, k) => x !== 0 && ((isCarrier(k) && passes(this.carriers[k - X])) || (isStretch(k) && driven(this.stretches[k]).some(passes))));
       // Any of the combinations it alone changes will do, with any conserved amount added (whose
       // summed balance is zero too): one of them needs a row of its own left to take. (Silver's,
       // e⁻ − Fe³⁺ beside a closed iron couple that had Fe³⁺'s, is e⁻ + Fe²⁺ with the iron added.)
       const news = this._conservedMoieties(true, [], rx).filter((w) => Math.abs(nu.reduce((t, x, k) => t + x * w[k], 0)) > 1e-9 && !fed(w));
+      // (One it changes only through immobile species has its rate alone in their balance at the
+      // face's node already, a row with no diffusion beside it to lose it to: left as it is. Stood
+      // in for by a mobile partner, Ag⁺ + Cl⁻ = S(immobile) beside a floating Ag electrode said its
+      // rate twice and lost the electrode's I = 0.)
+      if (news.some((w) => [...w.keys()].every((k) => !isStretch(k) || w[k] === 0 || this._still(this.stretches[k])))) continue;
       const kept = laws.filter((l) => !fed(l));
       const tries = [...news, ...news.flatMap((w) => kept.flatMap((l) => [1, -1].map((sg) => w.map((x, m) => x + sg * l[m]))))];
       for (const w of tries) {
@@ -963,6 +1016,7 @@ export class Solver {
         break;
       }
     }
+    this.contactQ = [null, null];
     for (let w of [...laws.filter(through), ...laws.filter((w) => !through(w))]) {
       for (const [j, k] of this.carriers.entries()) {
         const c = held.get(k);
@@ -971,10 +1025,13 @@ export class Solver {
         w = w.map((x, m) => (Math.abs(x - f * c[m]) < 1e-9 ? 0 : x - f * c[m]));
         w.own = own;
       }
-      const parts = [...w.keys()].filter((k) => k < S && w[k] !== 0).map((k) => ({ stretch: k, w: w[k] }));
-      const surface = [...w.keys()].filter((k) => k >= S && k < X && w[k] !== 0).map((k) => ({ col: k - S, w: w[k] }));
+      const parts = [...w.keys()].filter((k) => isStretch(k) && w[k] !== 0).map((k) => ({ stretch: k, w: w[k] }));
+      const surface = [...w.keys()].filter((k) => isSurface(k) && w[k] !== 0).map((k) => ({ col: k - S, w: w[k] }));
       const carriers = this.carriers.flatMap((k, j) => (w[X + j] !== 0 ? [{ k, w: w[X + j] }] : []));
-      if (parts.length === 0) continue; // (a surface's own: node by node, below)
+      // (A surface's own is kept node by node, below; one with an electrode's charge in it too is
+      // the circuit's, here: below skips it, and a floating electrode whose adsorbates gave it
+      // electrons settled 15 mV from where the transient ends.)
+      if (parts.length === 0 && carriers.length === 0) continue;
       if (parts.length === 1 && surface.length === 0 && this.stretches[parts[0].stretch].spectator) continue; // (above)
       if (parts.some((p) => !this._moves(this.stretches[p.stretch]) && !this._still(this.stretches[p.stretch]))) continue;
       const v = new Float64Array(S + T);
@@ -992,11 +1049,14 @@ export class Solver {
       if (!(scale > 1e-9)) continue;
       const ok = (j) => j !== undefined && Math.abs(v[j]) > 1e-9 * scale;
       const col = [...Array(T).keys()].map((t) => S + t).find(ok) ?? [parts.find((p) => w[p.stretch] === 1)?.stretch, w.own].find(ok) ?? v.findIndex((x) => Math.abs(x) === scale);
-      if (carriers.some((p) => p.k !== col - S)) continue; // (an electrode's charge in a circuit row not its own: never, as they're chosen)
+      // (Other electrodes' charges in a circuit row not their own: their voltages enter it through
+      // termDX. Two floating electrodes sharing a closed Fe³⁺, their law dropped, settled at 1.3 V
+      // for −0.65.)
       chosen.push([col, v.map((x) => x / v[col])]);
-      if (col >= S) held.set(col - S, w);
-      add(parts, col < S ? col : parts[0].stretch, surface, col < S ? -1 : col - S, carriers);
+      if (circuitOf(col) >= 0) held.set(circuitOf(col), w);
+      add(parts, circuitOf(col) < 0 ? col : parts[0]?.stretch, surface, circuitOf(col), carriers);
     }
+    this.contactLaw = [0, 1].map((k) => this.constraints.some((cs) => cs.contacts.some((c) => c.t === k)));
     // A combination that nothing carries anywhere is conserved node by node: of still stretches
     // (trap states: X⁰ + X⁻ under e⁻ + X⁰ = X⁻), or of an electrode's surface species (adsorbates
     // that only turn into each other). At each node its weighted sum stays what it was, a row local
@@ -1005,18 +1065,47 @@ export class Solver {
     const span = ([g0, g1]) => Array.from({ length: g1 - g0 + 1 }, (_, j) => g0 + j);
     for (const w of laws) {
       const parts = [...w.keys()].filter((k) => w[k] !== 0);
-      if (parts.some((k) => k >= X)) continue; // (through an electrode: above)
-      const sets = parts.map((k) => (k >= S ? model.ports[this.surfCols[k - S][0]].nodes : this._still(this.stretches[k]) ? span(this.stretches[k].nodes) : null));
-      if (sets.some((set) => set === null || set.length !== sets[0].length || set.some((g, j) => g !== sets[0][j]))) continue; // (side by side only)
-      for (const k of parts) if (k < S) this.stretches[k].conserved = true;
-      const slot = (k) => (k < S ? 1 + this.stretches[k].species : 1 + this.n + this.surfCols[k - S][1]);
+      if (parts.some(isCarrier)) continue; // (through an electrode: above)
+      const sets = parts.map((k) => (isSurface(k) ? model.ports[this.surfCols[k - S][0]].nodes : this._still(this.stretches[k]) ? span(this.stretches[k].nodes) : null));
+      if (sets.includes(null)) continue;
+      // Its nodes: the immobile stretches', side by side, with any surface's window among them (a
+      // surface's term only where it is: an immobile S that adsorbs on an electrode spread over
+      // part of its region keeps S + Γaθ there and S alone elsewhere; required to match, that law
+      // was lost, and a floating electrode's coverage drifted). Or a surface's alone.
+      const own = parts.filter(isStretch), base = own.length > 0 ? sets[parts.indexOf(own[0])] : sets[0];
+      const same = (set) => set.length === base.length && set.every((g, j) => g === base[j]);
+      if (!parts.every((k, j) => (isStretch(k) ? same(sets[j]) : sets[j].every((g) => base.includes(g))))) continue;
+      for (const k of own) this.stretches[k].conserved = true;
+      const slot = (k) => (isStretch(k) ? 1 + this.stretches[k].species : 1 + this.n + this.surfCols[k - S][1]);
+      // (its row a stretch's where it has one, present at every node; else the surface's)
+      const rowPart = own.length > 0 ? (own.includes(w.own) ? w.own : own[0]) : parts.includes(w.own) ? w.own : parts[0];
       this.localConstraints.push({
-        parts: parts.map((k) => (k < S ? { i: this.stretches[k].species, w: w[k] } : { q: this.surfCols[k - S][1], w: w[k] })),
-        row: slot(parts.includes(w.own) ? w.own : parts[0]),
-        nodes: sets[0],
+        parts: parts.map((k) => (isStretch(k) ? { i: this.stretches[k].species, w: w[k] } : { q: this.surfCols[k - S][1], k: this.surfCols[k - S][0], w: w[k] })),
+        row: slot(rowPart),
+        nodes: base,
         reference: new Float64Array(sets[0].length),
       });
     }
+    // An immobile stretch at a node where nothing touches it (no reaction there, no port or contact
+    // linking it) keeps its concentration: its balance there is 0 = 0 in a steady state, which
+    // holds nothing, and a charged one's level stayed where it was while φ moved (S⁺ beside a face
+    // that makes it, the bath moved 0.2 V: S⁺ fell to e^{−0.2/V_T} of itself away from the face).
+    for (const st of this.stretches) {
+      if (!this._still(st)) continue;
+      const i = st.species, touched = new Set();
+      for (let g = st.nodes[0]; g <= st.nodes[1]; g++) if (this.rxsIn[this.nodeMaterial[g]].some((rx) => rx.sp.includes(i))) touched.add(g);
+      model.interfaces.forEach((itf, f) => {
+        for (const rx of itf.reactions) for (const p of rx.part) if (p.i === i) touched.add(p.side === 0 ? grid.regionEnd[f] : grid.regionStart[f + 1]);
+      });
+      for (const port of model.ports) {
+        if (port.species[i].type !== 'blocked' || port.reactions.some((rx) => rx.part.some((p) => p.side === 0 && p.i === i))) for (const g of port.nodes) touched.add(g);
+      }
+      if (st.leftOpen) touched.add(0);
+      if (st.rightOpen) touched.add(this.nNodes - 1);
+      for (const lc of this.localConstraints) if (lc.row === 1 + i) for (const g of lc.nodes) touched.add(g);
+      const free = span(st.nodes).filter((g) => !touched.has(g));
+      if (free.length > 0) this.localConstraints.push({ parts: [{ i, w: 1 }], row: 1 + i, nodes: free, reference: new Float64Array(free.length) });
+    }
     // Islands: the pieces of a stretch between its faces. One that nothing else feeds (no
     // contact, port or reaction) holds its level only through its faces' fluxes, which can be
     // ~1e-24 of its own conduction (a tiny conductance at the face, or a neighbour that barely
@@ -1095,7 +1184,7 @@ export class Solver {
         if (fedBy.size !== 1) continue;
         const [k] = fedBy;
         if (!behind.includes(k) || this.timeLaws.some((cs) => cs.circuit === k)) continue;
-        const zc = k >= 2 ? this.z[model.ports[k - 2].terminal] : 0;
+        const zc = k >= 2 ? this._carrierZ(k) : 0;
         const lambda = carriers.find((p) => p.k === k)?.w / zc || parts.map((p) => (this._feeds(k, this.stretches[p.stretch]) && this.z[this.stretches[p.stretch].species] !== 0 ? p.w / this.z[this.stretches[p.stretch].species] : 0)).find((x) => x !== 0);
         if (!lambda) continue;
         let nNodes = parts.reduce((m, p) => m + this.stretches[p.stretch].nodes[1] - this.stretches[p.stretch].nodes[0] + 1, 0);
@@ -1118,13 +1207,14 @@ export class Solver {
       for (const k of charged) this.chargeRefs.set(k, k >= 2 ? this.portQ[k - 2] : k === 0 ? this.contactD.left : -this.contactD.right);
     }
     this.lawRefs.clear();
-    if (this.constraints.some((cs) => cs.carriers.some(({ k }) => this.model.ports[k - 2].capacitance)) && charged.length === 0) this._assembleBookkeeping(Infinity);
+    if (this.constraints.some((cs) => cs.contacts.length > 0 || cs.carriers.some(({ k }) => this.model.ports[k - 2].capacitance)) && charged.length === 0) this._assembleBookkeeping(Infinity);
     for (const cs of this.constraints) {
       if (cs.terminals.length === 0) continue;
       let a = 0;
       for (const { stretch, w } of cs.parts) a += w * this.amount(this.stretches[stretch]);
       for (const { col, w } of cs.surface) a += w * this.surfaceAmount(col);
-      for (const { k, w } of cs.carriers) if (this.model.ports[k - 2].capacitance) a += (w * this.portQ[k - 2]) / (this.z[this.model.ports[k - 2].terminal] * FARADAY);
+      for (const { k, w } of cs.carriers) if (this.model.ports[k - 2].capacitance) a += (w * this.portQ[k - 2]) / (this._carrierZ(k) * FARADAY);
+      for (const { t, lambda } of cs.contacts) a += (lambda * (t === 0 ? this.contactD.left : -this.contactD.right)) / FARADAY;
       this.lawRefs.set(cs.key, a);
     }
   }
@@ -1136,7 +1226,10 @@ export class Solver {
     for (const lc of this.localConstraints) {
       lc.nodes.forEach((g, j) => {
         let t = 0;
-        for (const { i, q, w } of lc.parts) t += w * (i !== undefined ? c[g * n + i] : th[g * nSurf + q]);
+        for (const { i, q, k, w } of lc.parts) {
+          if (i !== undefined) t += w * c[g * n + i];
+          else if (this.surfPort[g] === k) t += w * this._sites(g) * th[g * nSurf + q];
+        }
         lc.reference[j] = t;
       });
     }
@@ -1207,6 +1300,14 @@ export class Solver {
     }
   }
 
+  // An electrode surface's sites per volume at node g, Γ a (mol/m³): what a coverage of 1 holds,
+  // beside the concentrations of a local constraint. (Summed as θ alone, an immobile S that adsorbs
+  // as A(ads) kept S + θ_A, mol/m³ and a fraction.)
+  _sites(g) {
+    const k = this.surfPort[g];
+    return this.model.ports[k].surface[0].capacity * this.portArea[k][this.surfW[g]];
+  }
+
   // The local constraints' rows (steady solves only): Σ w c_i − reference at each node.
   _applyLocalConstraints() {
     const { n, M, c, th, nSurf, res, dA: d } = this;
@@ -1216,17 +1317,18 @@ export class Solver {
         if (this.loc[b * M + lc.row] < 0) return;
         this._replaceRow(b, lc.row);
         let t = 0;
-        for (const { i, q, w } of lc.parts) {
+        for (const { i, q, k, w } of lc.parts) {
           if (i !== undefined) {
             t += w * c[g * n + i];
             this._dc(g, i, d);
             for (let s = 0; s < M; s++) if (d[s] !== 0) this._j(b, lc.row, b, s, w * d[s]);
             continue;
           }
-          // A coverage, with ∂θ_q/∂η_x = θ_q (δ_qx − θ_x) over its surface's species.
-          const tq = th[g * nSurf + q], ns = this.model.ports[this.surfPort[g]].surface.length;
-          t += w * tq;
-          for (let x = 0; x < ns; x++) this._j(b, lc.row, b, 1 + n + x, w * tq * ((q === x ? 1 : 0) - th[g * nSurf + x]));
+          // A coverage, with ∂θ_q/∂η_x = θ_q (δ_qx − θ_x) over its surface's species (where it is).
+          if (this.surfPort[g] !== k) continue;
+          const tq = th[g * nSurf + q], ns = this.model.ports[this.surfPort[g]].surface.length, ws = w * this._sites(g);
+          t += ws * tq;
+          for (let x = 0; x < ns; x++) this._j(b, lc.row, b, 1 + n + x, ws * tq * ((q === x ? 1 : 0) - th[g * nSurf + x]));
         }
         res[this.rix[b * M + lc.row]] = t - lc.reference[j];
       });
@@ -1248,8 +1350,12 @@ export class Solver {
     // which the current feeds and the reactions draw on (a port at no current with M⁺ + e⁻ = M(s)
     // keeps M⁺ + Q/F, or with no capacitance, Q = 0, the M⁺ alone).
     const byCurrent = (t, k) => t.drive.kind === 'I' || alsoCurrent.includes(k); // (with `alsoCurrent`, terminals counted as such)
-    this.carriers = drives ? this.terms.flatMap((t, k) => (byCurrent(t, k) && k >= 2 && model.ports[k - 2].reactions.length > 0 ? [k] : [])) : [];
+    // (Or a port with a capacitance that passes ions, a membrane's: what it holds is Q/F. One that
+    // only charges keeps its charge alone, see _captureLaws.)
+    this.carriers = drives ? this.terms.flatMap((t, k) => (byCurrent(t, k) && k >= 2 && (model.ports[k - 2].reactions.length > 0 || (model.ports[k - 2].capacitance && !this._chargeOnly(k))) ? [k] : [])) : [];
     const X = S + this.surfCols.length, C = X + this.carriers.length;
+    // (columns: stretches [0, S), surfaces' species [S, X), electrodes' charges [X, C), as in _laws)
+    const isStretch = (k) => k < S, isSurface = (k) => k >= S && k < X;
     // (With `skip`, a reaction left out: the combinations that it alone changes come out too, and
     // its own rows, over the columns, are handed back as `basis.skipped`.)
     const rows = [], skipped = [];
@@ -1293,7 +1399,7 @@ export class Solver {
       const fed = this.stretches.flatMap((st, j) => (this._feeds(k, st) ? [j] : []));
       if (!(drives && byCurrent(t, k))) return fed.forEach(unit);
       const charged = fed.filter((j) => z[this.stretches[j].species] !== 0).map((j) => [j, z[this.stretches[j].species]]);
-      if (this.carriers.includes(k)) charged.push([X + this.carriers.indexOf(k), z[model.ports[k - 2].terminal]]);
+      if (this.carriers.includes(k)) charged.push([X + this.carriers.indexOf(k), this._carrierZ(k)]);
       fed.filter((j) => z[this.stretches[j].species] === 0).forEach(unit);
       for (let a = 1; a < charged.length; a++) {
         const row = new Float64Array(C);
@@ -1303,9 +1409,22 @@ 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])));
+    // go first, and electrode surfaces' (as local), so that a combination of them alone (trap
+    // states, X⁰ + X⁻; adsorbates, A(ads) + B(ads)) comes out on its own, to be kept node by node,
+    // apart from any that moves (e⁻ − X⁰, the electrons the traps hold). (Pivoted after a closed
+    // Cl⁻ in A(ads) + Cl⁻ = B(ads) + e⁻, the surface's own came out mixed with it, and was lost.)
+    // 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) => ((isStretch(k) && this._still(this.stretches[k])) || isSurface(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 (!isStretch(a) || !isStretch(b)) 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) {
@@ -1362,8 +1481,16 @@ export class Solver {
         const C = this.termC[cs.circuit];
         C.fill(0);
         for (let j = 0; j < cs.len; j++) C[cs.idx[j]] += cs.w[j];
+        for (const { t, lambda } of cs.contacts) {
+          // A contact's charge, D_in, as _contact had it, with its derivatives.
+          const q = this.contactQ[t], f = lambda / FARADAY;
+          cs.res += f * q.D;
+          for (let j = 0; j < C.length; j++) C[j] += f * q.row[j];
+          dV[t] += f * q.dV;
+        }
         this.termRes[cs.circuit] = cs.res;
-        this.termDI[cs.circuit] = dV;
+        this.termDI[cs.circuit] = dV[cs.circuit];
+        dV.forEach((x, k) => k !== cs.circuit && (this.termDX[cs.circuit][k] = x));
         continue;
       }
       const b0 = Math.floor(cs.row / M), r0 = cs.row % M;
@@ -1421,24 +1548,25 @@ export class Solver {
     }
     // What an electrode holds, its charge Q/(zF) on the port's capacitance (none without one),
     // Q = Σ vol·a·C (V − zeroCharge − φ) over its nodes (as _portCapacitance has it).
-    let dV = 0;
+    const dV = cs.dV ?? (cs.dV = new Float64Array(this.terms.length));
+    dV.fill(0);
     for (const { k, w } of cs.carriers) {
       const port = this.model.ports[k - 2];
       if (!port.capacitance) continue;
-      const f = w / (this.z[port.terminal] * FARADAY), { C: Cs, zeroCharge } = port.capacitance, V = this.termV[k];
+      const f = w / (this._carrierZ(k) * FARADAY), { C: Cs, zeroCharge } = port.capacitance, V = this.termV[k];
       const sets = (side) => ['pinned', 'bulk'].includes(this.model.contacts[side].phi.type);
       port.nodes.forEach((g, j) => {
         if ((g === 0 && sets('left')) || (g === this.nNodes - 1 && sets('right')) || this.phiUndefined[g]) return;
         const b = this.blockOfNode[g], s = vol[g] * this.portArea[k - 2][j] * Cs;
         amount += f * s * (V - zeroCharge - this.VT * (this.u[b * M] + this.uLo[b * M]));
         gross += Math.abs(f * s * (V - zeroCharge - this.VT * (this.u[b * M] + this.uLo[b * M])));
-        dV += f * s;
+        dV[k] += f * s;
         cs.idx[len] = this.rix[b * M];
         cs.w[len++] = -f * s * this.VT;
       });
     }
     cs.len = len;
-    return { amount, reference, dV, gross };
+    return { amount, reference, dV, gross }; // (dV by terminal)
   }
 
   // The same amount at the step's start, as the storage terms have it (BDF2's c* included).
@@ -1453,7 +1581,7 @@ export class Solver {
       const [k, q] = this.surfCols[col], port = this.model.ports[k], G = port.surface[0].capacity;
       port.nodes.forEach((g, j) => (a += w * G * vol[g] * this.portArea[k][j] * this.thOld[g * nSurf + q]));
     }
-    for (const { k, w } of cs.carriers) if (this.model.ports[k - 2].capacitance) a += (w * this.portQStart[k - 2]) / (this.z[this.model.ports[k - 2].terminal] * FARADAY);
+    for (const { k, w } of cs.carriers) if (this.model.ports[k - 2].capacitance) a += (w * this.portQStart[k - 2]) / (this._carrierZ(k) * FARADAY);
     return a;
   }
 
@@ -1473,7 +1601,7 @@ export class Solver {
   _circuitLaws(dt) {
     for (const cs of [...this.constraints, ...this.timeLaws]) {
       const k = cs.circuit;
-      if (k < 0 || !this.floating.includes(k)) continue;
+      if (k < 0 || !this.floating.includes(k) || cs.contacts?.length > 0) continue; // (a contact's charge: its own rows)
       const { amount, dV, gross } = this._lawAmount(cs), f = FARADAY / (cs.lambda * dt), C = this.termC[k];
       if (!this.lawForm.has(cs)) {
         let G = 0;
@@ -1485,7 +1613,8 @@ export class Solver {
       for (let j = 0; j < cs.len; j++) C[cs.idx[j]] += f * cs.w[j];
       const d = this.terms[k].drive, src = sourceAt(d.src, this.sourceTime, this.sourceBefore);
       this.termRes[k] = f * (amount - this._lawStart(cs)) - (d.kind === 'I' ? src : (src - this.termV[k]) / d.R);
-      this.termDI[k] = f * dV + (d.kind === 'I' ? 0 : 1 / d.R);
+      this.termDI[k] = f * dV[k] + (d.kind === 'I' ? 0 : 1 / d.R);
+      dV.forEach((x, j) => j !== k && (this.termDX[k][j] = f * x));
     }
   }
 
@@ -1529,7 +1658,10 @@ export class Solver {
     const A = Array.from({ length: S }, () => new Float64Array(S + 1));
     for (let a = 0; a < S; a++) {
       for (let b = 0; b < S; b++) A[a][b] = (b < P ? 1 : -1) * dot(a, cols[b]);
-      if (a >= P) A[a][a] += this.termDI[fl[a - P]];
+      if (a >= P) {
+        A[a][a] += this.termDI[fl[a - P]];
+        for (let b = P; b < S; b++) if (b !== a) A[a][b] += this.termDX[fl[a - P]][fl[b - P]];
+      }
       A[a][S] = (a < P ? pins[a].res : this.termRes[fl[a - P]]) - dot(a, delta);
       let mx = 0;
       for (let b = 0; b < S; b++) mx = Math.max(mx, Math.abs(A[a][b]));
@@ -2270,10 +2402,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 +2427,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 +2565,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 +2835,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 +2870,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 +3024,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 +3038,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 +3052,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 +3060,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 +3142,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);
@@ -2997,6 +3190,7 @@ export class Solver {
       this.termC[k].fill(0);
     }
     this.termDI.fill(0);
+    for (const x of this.termDX) x.fill(0);
     this.termI.fill(0);
     this.qg.fill(0);
     this.qgSlope.fill(0);
@@ -3049,7 +3243,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 +3488,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 +3497,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,13 +3515,20 @@ 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;
     }
 
     // φ law (none where φ is undefined: nothing at the end node responds to it). The displacement
     // into the device, D_in = sgn·D, adds (D_in − D_in at the step's start)/dt to the current.
     const link = ct.phi, Dstart = sgn * this.contactDStart[side];
+    // (In a steady solve, what a law in this circuit row counts of D_in: see _applyConstraints.)
+    const q = !dyn && this.steady && this.contactLaw[k] ? (this.contactQ[k] ??= { row: new Float64Array(this.sys.size + 1), D: 0, dV: 0 }) : null;
+    if (q) {
+      q.row.fill(0);
+      q.D = 0;
+      q.dV = 0;
+    }
     if (this.phiUndefined[g]) {
       this.contactD[side] = 0;
     } else if (link.type === 'capacitive') {
@@ -3337,6 +3538,7 @@ export class Solver {
       this._j(b, 0, b, 0, Ac * link.C * VT);
       B[R[b * M]] += -Ac * link.C;
       this.contactD[side] = sgn * Din;
+      if (q && this.loc[b * M] >= 0) [q.D, q.row[R[b * M]], q.dV] = [Din, -Ac * link.C * VT, Ac * link.C];
       // Its current, the charging (D_in − D_in at the step's start)/dt; or, steady at no current,
       // the charge it keeps in place of that (see _captureLaws).
       const rate = dyn ? 1 / dt : this.steady && this.chargeRefs.has(k) ? 1 : 0;
@@ -3349,6 +3551,10 @@ export class Solver {
       // The Poisson residual is the outside's charge, D_in.
       const Din = res[R[b * M]];
       this.contactD[side] = sgn * Din;
+      if (q) {
+        q.D = Din;
+        this._captureRow(b, 0, 1, q.row);
+      }
       if (dyn && !(this.combining && this.lateStorage[g] === 1)) {
         I += (Din - Dstart) / dt;
         this._captureRow(b, 0, 1 / dt, C);
@@ -3360,7 +3566,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 +3628,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 +3688,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 +3702,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 +3722,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,15 +3744,16 @@ 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 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), termDX: this.termDX.map((x) => Float64Array.from(x)), transformed: this.transformed, pinRes: this.pins.map((p) => p.res) };
     const restoreArrays = () => {
       res.set(save.res);
       termRes.set(save.termRes);
       save.termB.forEach((b, k) => termB[k].set(b));
       save.termC.forEach((c, k) => termC[k].set(c));
       termDI.set(save.termDI);
+      save.termDX.forEach((x, k) => this.termDX[k].set(x));
       this.transformed = save.transformed;
       this.pins.forEach((p, a) => (p.res = save.pinRes[a]));
     };
@@ -3568,10 +3777,11 @@ 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];
+        for (let b = 0; b < K; b++) if (b !== a) t += this.termDX[fl[a]][fl[b]] * x[N + b];
         for (let j = 0; j < N; j++) t += Ck[a][j] * x[j];
         out[N + a] = t;
       }
@@ -4755,9 +4965,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 +4975,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 +4989,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;