driftlet 1.3.3 → 1.4.0

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.3.3/src/index.js` (and `src/kit.js`, `src/plot.js`).
+`https://cdn.jsdelivr.net/npm/driftlet@1.4.0/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/device.md

@@ -156,7 +156,8 @@ interfaces: [
   {
     step: { species: 'e-', value: units.eV(0.25) }, // alignment: or { dipole: volts }
     phi: 'pinned', // 'pinned' | 'neutral' | { type: 'capacitive', C }
-    sheetCharge: 0, // C/m²
+    sheetCharge: 0, // C/m², on the face's right plate
+    diffuse: { epsr: 78.4 }, // a Gouy–Chapman layer below the grid, beside a strictly neutral side
     species: { 'Cl-': 'blocked', 'Li+': { type: 'conductance', G: 50 }, 'Na+': 'blocked' },
     reactions: [{ left: { 'Na+': -1 }, right: { 'Na+': 1 }, k0: 1e-3, alpha: 0.5 }], // Na⁺ crosses only by this
   },
@@ -187,10 +188,77 @@ defaults to no dipole.
   in series with C. So keep that cell coarse rather than fine (a warning says when it costs C more
   than 2%, and how coarse is enough). A face reaction there sees that cell's composition, which
   holding the charge shifts by about $`z\sigma F/(C_{\mathrm{cell}} RT)`$ for an ion of charge $`z`$: a
-  Frumkin effect set by the mesh, growing without limit as the cell shrinks (an electrode's DC
-  resistance in ferri/ferrocyanide fell from 56.6 to 47.5 Ω·cm² between 300 nm and 1 nm). A
-  warning says past 1%; a `zeroCharge` near the face's rest potential, so it holds little charge,
-  avoids it on any grid. A sub-grid Gouy–Chapman law is on the [roadmap](../ROADMAP.md).
+  Frumkin effect set by the mesh, which doesn't settle as the cell shrinks (an electrode's DC
+  resistance in ferri/ferrocyanide went from 56.6 to 47.4 Ω·cm² between 300 nm and 1 nm, the
+  real one being 46.4). A warning says past 1%. A diffuse layer (next) puts that charge where it
+  belongs, on any grid; a `zeroCharge` near the face's rest potential, so it holds little charge,
+  avoids the question.
+
+**Diffuse layer** `diffuse: { epsr }`: on each strictly neutral side of a charged (pinned or
+capacitive) face, a Gouy–Chapman layer below the grid, of relative permittivity `epsr` (the bulk's
+is 0, so it's given here: 78.4 for water at 25 °C). Its ions are in Boltzmann equilibrium with the
+edge node's concentrations $`c_i`$ across a drop $`\psi = \phi_{\mathrm{plane}} - \phi_{\mathrm{edge}}`$
+($`s = F\psi/RT`$), and it holds that side's share of the face's charge,
+
+```math
+q_d = -\operatorname{sign}(s)\sqrt{2\varepsilon RT \sum_i c_i \left(e^{-z_i s} - 1 + z_i s\right)}, \qquad
+\Gamma_i = \int (c_i(x) - c_i)\,dx,\quad F \sum_i z_i \Gamma_i = q_d
+```
+
+as each ion's surface excess $`\Gamma_i`$ (by quadrature of the same first integral; exact for any
+mixture, a uniform fixed charge included). The face's law then runs to the plane: the Stern drop
+is $`V_F - \mathtt{zeroCharge} - \phi_{\mathrm{plane}}`$, or between two materials
+$`\phi_{R,\mathrm{plane}} - \phi_{L,\mathrm{plane}} - \mathtt{dipole}`$. The edge box holds what the
+layer holds, $`A\,\Gamma_i`$ of each ion, in every amount, conservation law and transient (so its
+bulk stays neutral, and the salt a charging layer takes comes out of the solution), and a face
+reaction's participant on that side reacts at the plane, at $`c_i e^{-z_i s}`$ with its $`\bar\mu`$
+unchanged: Butler–Volmer then depends on the Stern drop alone, the Frumkin correction, and the
+mesh no longer enters (the ferri/ferrocyanide electrode: 46.399 Ω·cm² on cells from 1 nm to 300 nm,
+the limit of the same electrode resolved at ε = 78.4 as its cells shrink to 0.0125 nm). Each
+solution reports it as `interfaces[f].diffuse.left`/`.right`: `psi` (V), `charge` (C/m²), `excess`
+(mol/m²) and `plane` (each ion's concentration there). With ideal ions it's a dilute layer, so a
+warning says where its plane passes 5 M (a Stern C so large, or a zeroCharge so far from where the
+face works, that its counter-ions would have no room there). Where the side's ions are on a
+[lattice](statistics.md) instead, the layer crowds on the same sites (Bikerman): $`c_i e^{-z_i s}`$
+over $`1 + \sum_j \theta_j (e^{-z_j s} - 1)`$, $`\theta_j = c_j/c_{\mathrm{max}}`$, and
+$`\sum_i c_i (e^{-z_i s} - 1 + z_i s)`$ above becomes $`c_{\mathrm{max}}\ln(1 + \sum_j \theta_j (e^{-z_j s} - 1)) + s\sum_j c_j z_j`$, so the plane fills to $`c_{\mathrm{max}}`$
+and no further, and a neutral species on the lattice is pushed out of it. Its ions must otherwise be
+ideal (all of them on the one lattice, or none) and mobile, and SRH kinetics beside a layer isn't
+supported.
+
+What a face reaction takes or makes at the plane crosses the layer, against the layer's
+resistance to it, $`K_i = \int (c_i/c_i(x) - 1)\,dx`$ (a length, by the same quadrature): its level
+at the plane is below the edge node's by what its flux $`N_i`$ toward the plane needs,
+$`a_{\mathrm{plane}} = a_{\mathrm{edge}}\,(1 - N_i K_i/(D_i c_i))`$, one more unknown per such species
+(the `plane` it reports includes it). That's exact for a species too dilute to shape the layer,
+which is the case that matters: a reactant the face's charge repels, for which $`K_i`$ grows as
+$`c_i/c_{i,\mathrm{plane}}`$, so the plane can run out of it. Its current then rises and falls as the
+electrode is driven harder, Frumkin's dip (ferricyanide reduced at a negatively charged electrode
+in 0.1 M KCl, as peroxodisulfate is): within 1.5e-6 of the same electrode resolved, where leaving
+the resistance out had it 68% high; and a plane 99.7% full of ferrocyanide, which its other ions
+cross only through it, puts the electrode's R_dc within 1e-8 of the resolved one's (6% off
+without it). Where the layer gathers a species, $`K_i < 0`$, bounded by about the layer's width: a
+correction of order $`\lambda_D/L`$. What the layer doesn't cover:
+- a salt run out at the electrode, toward and past an unsupported electrolyte's limiting current:
+  the layer spreads into the solution there (an extended space charge), and where the resolved
+  electrode's current climbs past the limit, the law's stays at it (silver deposited from 10 mM
+  AgNO₃ across 100 µm: 8e-4 high at 96% of the limiting current, 1% low at −1.5 V, well past it);
+- a solution beside it only a few Debye lengths wide (a nanopore, overlapping layers): the layer is
+  taken whole, as if the solution went on;
+- a permeability link's ions crossing it: at a membrane they're at the planes in equilibrium with
+  the edges (the membrane, many orders less permeable than the layer, sets their flux);
+- ions of different sizes, and the field's lowering of ε near the plane: one site for every ion
+  (Bikerman), and one permittivity.
+
+At a membrane between two solutions, a layer on each side: a
+permeability link runs between the planes (Goldman–Hodgkin–Katz on the planes' concentrations,
+across the drop between them), and gates follow the voltage between the planes, the one the
+membrane itself has across it (`interfaces[f].V`), so a surface charge (`sheetCharge`) and the
+ions that screen it shift a channel's gating and permeation, as divalent cations do. A face's
+`sheetCharge` sits on its right plate: beside a layer on the right, at that layer's plane (ions
+adsorbed at the outer Helmholtz plane, the Stern layer between them and the left side). For a
+charge on the left plate (an oxide's surface groups, its Stern layer on the solution's side),
+build the stack the other way round.
 
 **Species laws** `species` (default: local equilibrium, $`\bar\mu`$ continuous, where the species is
 present on both sides and can move on one at least; blocked otherwise, so trap states with

package/docs/internals.md

@@ -20,7 +20,8 @@ them is wrong: fix both, with a test, in the same commit.
 | `src/newton.js` | yes: Newton's iteration, its scaled rows, GMRES-refined solves and the islands' round |
 | `src/assemble.js` | yes: the equations assembled, the conventions of every row, and the order of the terms |
 | `src/regions.js` | yes: statistics, storage, fluxes along segments, bulk reactions, the neutral nodes' charge rows |
-| `src/boundaries.js` | yes: faces (φ laws, links, reactions, gates), ports, contacts, circuit rows |
+| `src/boundaries.js` | yes: faces (φ laws, links, reactions, gates, diffuse layers), ports, contacts, circuit rows |
+| `src/diffuse.js` | yes: a Gouy–Chapman layer's charge, surface excesses, resistances and their derivatives |
 | `src/steady.js` | yes: steady solves, their stages and continuations, the pseudo-transient ramp |
 | `src/impedance.js` | yes: the small-signal impedance, its readouts and profiles |
 | `src/difference.js` | header: the dilute kernels in difference form |
@@ -47,7 +48,9 @@ them is wrong: fix both, with a test, in the same commit.
   `blockOfNode[g]`, face f's flux block is `blockOfFace[f]`, in order along x.
 - **Slots.** Each block has `M = 1 + n + extra` slots: slot 0 is φ̂ (at a face its
   displacement D, at a metal's node its carriers' segment flux J), slots `1 … n` the species'
-  η = μ̄/RT, then a face's reaction rates and gates' fractions, or at an electrode port's nodes
+  η = μ̄/RT, then a face's reaction rates, gates' fractions, diffuse layers' drops (`diffList`,
+  each layer's excesses in `gam`) and the levels at their planes of the species its reactions
+  take or make there (each layer's `drawSlot`, as η), or at an electrode port's nodes
   its surface's coverages (as η) and a membrane port's gates. Row and unknown `o = b·M + slot`.
 - **Compact indices.** Only active slots enter the linear system: `loc[o]` is a slot's place in
   its block (−1: inactive), `rix[o]` its index in compact vectors, with `rix = N` (the sink) for

package/docs/statistics.md

@@ -69,7 +69,8 @@ The listed species share $`c_{\mathrm{max}}`$ sites per volume and each occupies
 concentration can exceed $`c_{\mathrm{max}}`$. With both ions of an electrolyte on one lattice, this
 is the Bikerman / Kilic–Bazant–Ajdari model of a crowded double layer. At large potentials the
 counter-ion saturates at $`c_{\mathrm{max}}`$, and the diffuse charge grows as $`\sqrt{\psi}`$ instead
-of exponentially. With one species it's Langmuir filling of sites. The dilute reference
+of exponentially: resolved by the grid (ε > 0), or below it, a face's `diffuse` layer beside a
+strictly neutral solution on a lattice crowds on the same sites ([faces](device.md)). With one species it's Langmuir filling of sites. The dilute reference
 $`c_{\mathrm{ref}}`$ is kept. To use the half-filling convention of site models
 ($`e^\zeta = x/(1-x)`$), set `cRef` equal to `cMax`.
 

package/docs/templates.md

@@ -4,9 +4,13 @@ Templates for devices outside [llms.txt](../llms.txt)'s core set, written the sa
 block runs in the test suite and prints its closed-form check. Read llms.txt first; these build
 on it.
 
-- semiconductors: [a Schottky diode](#a-schottky-diode), [a thin-film transistor](#a-thin-film-transistor-a-capacitance-along-a-channel);
+- semiconductors: [a Schottky diode](#a-schottky-diode), [a thin-film transistor](#a-thin-film-transistor-a-capacitance-along-a-channel),
+  [traps in a layer of holes alone](#traps-in-a-layer-of-holes-alone-a-space-charge-limited-diode);
 - electrochemistry: [corrosion under a drop](#corrosion-under-a-drop-an-electrode-spread-through-a-film)
-  (an electrode spread through a film, and a cross-section that varies);
+  (an electrode spread through a film, and a cross-section that varies),
+  [an electrode's double-layer capacitance](#an-electrodes-double-layer-capacitance-gouychapmanstern),
+  [a semiconductor electrode's Mott–Schottky plot](#a-semiconductor-electrodes-mottschottky-plot),
+  [a concentration cell with transference](#a-concentration-cell-with-transference);
 - physiology: [a voltage clamp](#a-voltage-clamp), [an action potential](#an-action-potential),
   [one travelling along an axon](#an-action-potential-travelling-along-an-axon).
 
@@ -77,6 +81,45 @@ To sweep the gate on one device instead, patch the port: `dev.set({ ports: { gat
 An organic electrochemical transistor is the same with a volumetric capacitance C*:
 `area: 1 / t, capacitance: { C: Cstar * t }`.
 
+## traps in a layer of holes alone (a space-charge-limited diode)
+
+An organic layer with holes and no dopant can't be neutral anywhere, so `ohmic()`'s `'bulk'` law
+can't hold at its contacts: **pinned contacts** set the hole density at each edge instead
+(`zeroCharge` = −barrier for holes of $`\mu^\circ = 0`$, density $`N_v e^{-\mathrm{barrier}/kT}`$). A **trap**
+is two immobile species, empty and filled, and a reaction between them; its depth is the filled
+one's $`\mu^\circ`$. In a steady state immobile traps sit at their reaction's equilibrium at every
+node, under current too, so their filling is exactly $`p/(p + p_1)`$; past the trap-filled limit
+the current climbs toward the trap-free space-charge-limited one.
+
+```js
+import { Device, units, FARADAY, GAS_CONSTANT } from 'driftlet';
+import { build, layer } from 'driftlet/kit';
+
+const T = 300, VT = (GAS_CONSTANT * T) / FARADAY, Nv = units.perCm3(1e21), Nt = units.perCm3(1e17), Et = 0.45;
+// Holes alone (an organic semiconductor's), and a trap level Et above the valence band: empty T0,
+// filled T+, h⁺ + T0 = T+. The filled one's μ° below the empty's sets the depth.
+const lib = {
+  species: [{ name: 'h+', z: 1, cRef: Nv }, { name: 'T0', z: 0, cRef: 1 }, { name: 'T+', z: 1, cRef: 1 }],
+  materials: { org: { epsr: 3, T, species: { 'h+': { D: 1e-8 * VT, mu0: 0 }, T0: { D: 0, mu0: 0 }, 'T+': { D: 0, mu0: -units.eV(Et) } } } },
+};
+// Pinned contacts set the hole density at each edge: Nv at the anode, Nv·e^(−0.5 eV/kT) at the cathode.
+const contact = (V, barrier) => ({ V, terminal: 'h+', species: { 'h+': 'equilibrium' }, phi: 'pinned', zeroCharge: -barrier });
+const diode = (V, traps) => build({
+  T, library: [lib],
+  stack: [contact(V, 0), layer('org', 100e-9, { c0: { T0: Nt / 2, 'T+': Nt / 2 } }), contact(0, 0.5)],
+  bulkReactions: traps ? [{ equation: 'h+ + T0 = T+', kf: { org: 1e6 } }] : [],
+  grid: { hmin: 0.01e-9, hmax: 1e-9, ratio: 1.15 },
+});
+const p1 = Nv * Math.exp(-Et / VT); // the hole density at which a trap is half full
+for (const V of [1, 3, 10]) {
+  const s = new Device(diode(V, true)).solve(), free = new Device(diode(V, false)).solve();
+  // Immobile traps in a steady state sit at their reaction's equilibrium at every node: T+/Nt = p/(p + p1).
+  const off = Math.max(...Array.from(s.c['h+'], (p, g) => Math.abs(s.c['T+'][g] / Nt - p / (p + p1))));
+  const mid = s.x.length >> 1;
+  console.log(`${V} V: J ${s.current.toExponential(3)} A/m², ${(s.current / free.current).toFixed(3)} of the trap-free; traps ${(100 * s.c['T+'][mid] / Nt).toFixed(1)}% full mid-layer; occupancy off p/(p + p1) by ${off.toExponential(1)}`);
+}
+```
+
 ## corrosion under a drop (an electrode spread through a film)
 
 A **port with reactions** is an electrode spread through a strictly neutral region: a metal under
@@ -137,6 +180,118 @@ for (const rx of evans.reactions) console.log(`${rx.equation}: ${Array.from(rx.c
 Species can take an electrode's surface sites (`surface`, Langmuir coverages), and a reaction
 with `bare: true` runs only on bare metal: a passive film (docs/device.md).
 
+## an electrode's double-layer capacitance (Gouy–Chapman–Stern)
+
+A blocking metal in dilute KCl, the solution strictly neutral (`epsr: 0`) and the face's double
+layer below the grid: a Stern layer (`phi: { type: 'capacitive', C }`) and its diffuse layer
+(`diffuse: { epsr }`). The capacitance from `impedance()` at a low frequency has the classic
+minimum at the potential of zero charge, where the diffuse layer is thickest, and follows Stern and
+Gouy–Chapman in series, $`1/C = 1/C_H + 1/(\varepsilon\kappa\cosh(F\psi/2RT))`$, with the drop ψ
+the solution reports. (The salt the layer takes in or gives up comes from the bath by diffusion:
+at 0.1 Hz across this 100 µm it shows, 2e-5 at ±0.2 V.)
+
+```js
+import { Device, EPS0, FARADAY, GAS_CONSTANT } from 'driftlet';
+import { build, layer, ohmic, bath, aqueous, metal } from 'driftlet/kit';
+
+const T = 298.15, VT = (GAS_CONSTANT * T) / FARADAY, CH = 0.2, epsr = 78.4; // a Stern layer of 20 µF/cm²
+const salt = { 'K+': 10, 'Cl-': 10 }; // 10 mM KCl
+const cell = (V) => build({
+  T, library: [aqueous(['K+', 'Cl-'], { epsr: 0 }), metal('Pt')],
+  stack: [ohmic(V, ['e-']), layer('Pt', 1e-6), { phi: { type: 'capacitive', C: CH }, zeroCharge: 0, diffuse: { epsr } }, layer('water', 100e-6, { c0: salt }), bath(salt, 'Cl-')],
+  grid: { hmin: 1e-6, hmax: 10e-6 },
+});
+// The potential of zero charge: the solution's φ at the face (zeroCharge 0: V_F − φ_plane there).
+const first = new Device(cell(0)).solve(), pzc = first.phi[first.region.indexOf(1)];
+const kappa = Math.sqrt((2 * FARADAY ** 2 * 10) / (epsr * EPS0 * GAS_CONSTANT * T)); // 1/Debye length
+for (const E of [-0.2, -0.1, 0, 0.1, 0.2]) {
+  const dev = new Device(cell(pzc + E));
+  const psi = dev.solve().interfaces[0].diffuse.right.psi; // the diffuse layer's drop
+  const f = 1e-3, { Z } = dev.impedance([f]), C = -1 / (2 * Math.PI * f * Z.im[0]);
+  const gcs = 1 / (1 / CH + 1 / (epsr * EPS0 * kappa * Math.cosh(psi / (2 * VT))));
+  console.log(`${E.toFixed(1)} V from the pzc: C ${(100 * C).toFixed(3)} µF/cm², Gouy–Chapman–Stern ${(100 * gcs).toFixed(3)}`);
+}
+```
+
+## a semiconductor electrode's Mott–Schottky plot
+
+A semiconductor dipped in an electrolyte, the face between them **blocking** (no reactions), with
+its **alignment** given (a `dipole`: what puts silicon's levels against the solution's is a
+choice, here Si's electron affinity against an absolute SHE, not a datum). Its capacitance from
+`impedance()` at a frequency where the space charge is what's measured, $`1/C^2`$ against the
+voltage across the depletion range, gives back the doping from the slope and the flat band from
+the intercept less kT/q. Past about $`2\phi_F`$ of depletion, holes gather at the face (inversion):
+keep the fit below it.
+
+```js
+import { Device, units, EPS0, FARADAY, GAS_CONSTANT } from 'driftlet';
+import { build, layer, ohmic, bath, semiconductor, aqueous } from 'driftlet/kit';
+
+const T = 298.15, VT = (GAS_CONSTANT * T) / FARADAY, ND = units.perCm3(1e16);
+const water = { 'K+': 100, 'Cl-': 100 }; // 0.1 M KCl
+const lib = [semiconductor('Si', { T }), aqueous(['K+', 'Cl-'])];
+// n-Si | a blocking face | 40 nm of the solution, resolved | the bath, read against an electrode reversible to Cl⁻.
+// The face's dipole aligns the two (here Si's electron affinity against the solution: an assumption, not data).
+const cell = (V) => build({
+  T, library: lib,
+  stack: [ohmic(V), layer('Si', units.um(2), { donors: ND }), { dipole: 0.39 }, layer('water', 40e-9, { c0: water }), bath(water, 'Cl-')],
+  grid: { hmin: 0.1e-9, hmax: 5e-9, ratio: 1.1 },
+});
+const pts = [];
+for (const V of [-1.3, -1.2, -1.1, -1.0]) { // the silicon positive: its electrons pushed back, a depletion layer
+  const dev = new Device(cell(V));
+  dev.solve();
+  const { f, Z } = dev.impedance([1e5]); // 100 kHz: the space charge, the double layer in series negligible
+  const w = 2 * Math.PI * f[0], C = -Z.im[0] / (w * (Z.re[0] ** 2 + Z.im[0] ** 2));
+  pts.push([V, 1 / C ** 2]);
+}
+// 1/C² = 2/(F ε N_D) (V − V_fb − kT/q) in depletion (N_D in mol/m³, as driftlet's are)
+const slope = (pts.at(-1)[1] - pts[0][1]) / (pts.at(-1)[0] - pts[0][0]), V0 = pts[0][0] - pts[0][1] / slope;
+console.log(`N_D from the slope: ${units.toPerCm3(2 / (FARADAY * 11.9 * EPS0 * slope)).toPrecision(5)} cm⁻³ (1e16 put in)`);
+// The model's own flat band: where the silicon holds no charge at the face (interfaces[0].D = 0).
+let lo = -2, hi = -1.3;
+for (let k = 0; k < 40; k++) {
+  const m = (lo + hi) / 2, D = new Device(cell(m)).solve().interfaces[0].D;
+  if (D < 0) lo = m;
+  else hi = m;
+}
+console.log(`flat band: ${(V0 - VT).toFixed(4)} V from the intercept less kT/q, ${hi.toFixed(4)} V where the face holds no charge`);
+```
+
+## a concentration cell with transference
+
+Two electrodes reversible to Cl⁻ (`bath(c, 'Cl-')`), one held and one at open circuit, with
+two strengths of HCl between them meeting at a **liquid junction**. For one salt the voltage
+doesn't depend on the junction's profile, so baths at both ends holding it stationary give
+the free-diffusion junction's value: $`E = -2t_+ (RT/F)\ln(a_{\pm,2}/a_{\pm,1})`$, the junction's
+share $`(2t_+ - 1)/(2t_+)`$. Activity coefficients go on the water's `statistics`.
+
+```js
+import { Device, FARADAY, GAS_CONSTANT, EPS0, AVOGADRO } from 'driftlet';
+import { build, layer, bath, aqueous, IONS } from 'driftlet/kit';
+
+const T = 298.15, VT = (GAS_CONSTANT * T) / FARADAY;
+const dilute = { 'H+': 1, 'Cl-': 1 }, strong = { 'H+': 10, 'Cl-': 10 }; // mol/m³: 1 and 10 mM HCl
+const tPlus = IONS['H+'].D / (IONS['H+'].D + IONS['Cl-'].D);
+// Ag|AgCl at each end: a bath read against an electrode reversible to Cl⁻. The left one held, the
+// right at open circuit; between them a junction held stationary by the two baths (strictly
+// neutral water, ε = 0: the junction is 2 mm wide, its double layers nothing to it).
+for (const activity of [null, { type: 'debye-huckel', species: ['H+', 'Cl-'], epsr: 78.4, a: 0 }]) {
+  const lib = aqueous(['H+', 'Cl-'], { epsr: 0 });
+  if (activity) lib.materials.water.statistics = [activity];
+  const s = new Device(build({
+    T, library: [lib],
+    stack: [bath(dilute, 'Cl-'), layer('water', 2e-3, { c0: dilute }), { phi: 'neutral' }, layer('water', 2e-3, { c0: strong }), bath(strong, 'Cl-', { I: 0 })],
+    grid: { hmin: 1e-7, hmax: 2e-5 },
+  })).solve();
+  // E = −2 t₊ (RT/F) ln(a±₂/a±₁), the limiting law's ln γ± = −ℓ_B κ/2 (Bjerrum length, Debye κ)
+  const eps = EPS0 * (activity?.epsr ?? 1), lB = FARADAY ** 2 / (4 * Math.PI * eps * GAS_CONSTANT * T * AVOGADRO);
+  const lnGamma = (c) => (activity ? (-lB * Math.sqrt((2 * FARADAY ** 2 * c) / (eps * GAS_CONSTANT * T))) / 2 : 0);
+  const E = s.terminals.right.V - s.terminals.left.V, theory = -2 * tPlus * VT * (Math.log(10) + lnGamma(10) - lnGamma(1));
+  console.log(`${activity ? 'Debye–Hückel' : 'ideal'}: ${(E * 1e3).toFixed(3)} mV, theory ${(theory * 1e3).toFixed(3)}; the junction's share ${(2 * tPlus - 1) / (2 * tPlus)}`);
+}
+```
+
 ## a voltage clamp
 
 A face's `gates` (each a fraction open, $`dx/dt = \alpha(V)(1 - x) - \beta(V)x`$ with $`V = \phi_{\mathrm{right}} - \phi_{\mathrm{left}}`$)

package/llms.txt

@@ -17,9 +17,11 @@ two sections, then go to the template nearest your device:
   voltammogram), a battery particle discharging;
 - physiology: a cell membrane (a resting potential).
 
-More in docs/templates.md: a Schottky diode, a thin-film transistor, corrosion under a drop (an
-electrode spread through a film), a voltage clamp, an action potential, one travelling along an
-axon.
+More in docs/templates.md: a Schottky diode, a thin-film transistor, traps in a layer of holes
+alone (pinned contacts that set a carrier's density), corrosion under a drop (an electrode spread
+through a film), an electrode's double-layer capacitance (Gouy–Chapman–Stern, the diffuse layer
+below the grid), a semiconductor electrode's Mott–Schottky plot, a concentration cell with
+transference, a voltage clamp, an action potential, one travelling along an axon.
 
 The references are in docs/: device.md (the definition), kit.md (the helpers), conventions.md
 (signs and levels), visualization.md, alignment.md (band offsets), statistics.md (non-ideal
@@ -30,9 +32,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.3.3/src/index.js';
-import { build, layer, ohmic, semiconductor, live } from 'https://cdn.jsdelivr.net/npm/driftlet@1.3.3/src/kit.js';
-import { bandDiagram } from 'https://cdn.jsdelivr.net/npm/driftlet@1.3.3/src/plot.js';
+import { Device, units } from 'https://cdn.jsdelivr.net/npm/driftlet@1.4.0/src/index.js';
+import { build, layer, ohmic, semiconductor, live } from 'https://cdn.jsdelivr.net/npm/driftlet@1.4.0/src/kit.js';
+import { bandDiagram } from 'https://cdn.jsdelivr.net/npm/driftlet@1.4.0/src/plot.js';
 ```
 
 From npm: `driftlet`, `driftlet/kit`, `driftlet/plot`. Every export is listed at the end.
@@ -95,7 +97,10 @@ From npm: `driftlet`, `driftlet/kit`, `driftlet/plot`. Every export is listed at
   to a metal, a face takes no alignment, but needs a φ law if the other side has ε > 0: `{ phi: {
   type: 'capacitive', C }, zeroCharge }` or `phi: 'neutral'`, where `zeroCharge` is the metal's V −
   φ at its edge when the face holds no charge (a work-function difference, a potential of zero
-  charge, a Schottky barrier). A face's reactions label sides: `'Li+(left) = Li+(right)'`.
+  charge, a Schottky barrier). A face's reactions label sides: `'Li+(left) = Li+(right)'`. Beside a
+  strictly neutral solution, `diffuse: { epsr }` adds its Gouy–Chapman layer below the grid (the
+  Frumkin effect on any grid, a reactant's way across the layer included;
+  `sol.interfaces[f].diffuse`).
 - **Ports** are terminals attached sideways to a window inside a region (`from`, `to`, m from its
   left end): a source or drain, an injector, a reference electrode (`I: 0`), an electrode spread
   through a film (`reactions`, `area`), a gate along a channel or a membrane along an axon
@@ -219,9 +224,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.3.3/src/index.js';
-import { build, layer, ohmic, semiconductor, live } from 'https://cdn.jsdelivr.net/npm/driftlet@1.3.3/src/kit.js';
-import { bandDiagram } from 'https://cdn.jsdelivr.net/npm/driftlet@1.3.3/src/plot.js';
+import { units } from 'https://cdn.jsdelivr.net/npm/driftlet@1.4.0/src/index.js';
+import { build, layer, ohmic, semiconductor, live } from 'https://cdn.jsdelivr.net/npm/driftlet@1.4.0/src/kit.js';
+import { bandDiagram } from 'https://cdn.jsdelivr.net/npm/driftlet@1.4.0/src/plot.js';
 
 const def = build({
   T: 300,
@@ -668,9 +673,8 @@ those:
   grade it over a few thin layers, as at a frit.
 - **Changing `c0` with `set()`.** A carried state keeps what it holds: make a new `Device`.
 - **A charged electrode face beside a strictly neutral solution** (`epsr: 0`, a capacitive face
-  with reactions): refining the grid there makes the kinetics worse, not better, since the edge
-  cell holds the double layer's charge. Read `sol.warnings`; a `zeroCharge` near the rest
-  potential avoids it.
+  with reactions): give the face its diffuse layer, `diffuse: { epsr: 78.4 }`. Without it the edge
+  cell holds the double layer's charge, and the kinetics depend on the grid (a warning says so).
 - **An unresolved double layer.** If `sol.warnings` says so, refine the grid (`hmin` below the
   Debye length) or use a neutral model (`epsr: 0`, `phi: 'neutral'`).
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "driftlet",
-  "version": "1.3.3",
+  "version": "1.4.0",
   "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": {