driftlet 0.7.0 → 0.9.0

package/src/solver.js

@@ -195,13 +195,16 @@ export class Solver {
     // Slots per block: φ̂ (or D, or a conductor's segment flux J), one per species, and at a face
     // one per face reaction (its rate), as many as the busiest face has.
     const nRx = model.interfaces.reduce((m, itf) => Math.max(m, itf.reactions.length), 0);
-    const M = n + 1 + nRx;
+    // (and at an electrode port's nodes, one per surface species: its coverage's η)
+    const nSurf = model.ports.reduce((m, port) => Math.max(m, port.surface.length), 0);
+    const M = n + 1 + Math.max(nRx, nSurf);
     const nNodes = grid.nNodes;
     const nFaces = regions.length - 1;
     const nB = nNodes + nFaces;
     this.n = n;
     this.M = M;
     this.nRx = nRx;
+    this.nSurf = nSurf;
     this.nNodes = nNodes;
     this.nFaces = nFaces;
     this.nB = nB;
@@ -214,6 +217,18 @@ export class Solver {
     this.blockOfFace = new Int32Array(nFaces);
     for (let f = 0; f < nFaces; f++) this.blockOfFace[f] = grid.regionEnd[f] + f + 1;
 
+    // Electrode ports' surfaces: each node's port (−1: none) and its index in the port's window;
+    // the coverages there, θ [g·nSurf + s], now and at the step's start.
+    this.surfPort = new Int32Array(nNodes).fill(-1);
+    this.surfW = new Int32Array(nNodes);
+    model.ports.forEach((port, k) => {
+      if (port.surface.length > 0) port.nodes.forEach((g, w) => ((this.surfPort[g] = k), (this.surfW[g] = w)));
+    });
+    this.th = new Float64Array(nNodes * nSurf);
+    this.thOld = new Float64Array(nNodes * nSurf);
+    this.th0 = new Float64Array(nNodes); // the bare fraction θ₀, directly (1 − Σθ cancels as θ → 1)
+    this.th0Old = new Float64Array(nNodes);
+
     // Per-node material data, flattened [g·n + i].
     this.present = new Uint8Array(nNodes * n);
     this.cRef = new Float64Array(nNodes * n);
@@ -327,6 +342,12 @@ export class Solver {
     this.contactFlux = { left: new Float64Array(n), right: new Float64Array(n) };
     this.portFlux = model.ports.map(() => new Float64Array(n)); // into the device, mol/(m²·s)
     this.contactD = { left: 0, right: 0 };
+    // A capacitive port's charge (its side's, Σ vol·a·σ over its window), as the contacts' D: now,
+    // at the step's start and at the previous step's end.
+    this.portQ = new Float64Array(model.ports.length);
+    this.portQStart = new Float64Array(model.ports.length);
+    this.portQOld = new Float64Array(model.ports.length);
+    this.portQEnd = null;
     this.contactDOld = { left: 0, right: 0 };
     this.contactDStart = { left: 0, right: 0 };
     // Terminals (the two contacts, then the ports): each one's voltage (V), held by its source or
@@ -374,6 +395,13 @@ export class Solver {
       nu: Float64Array.from([...rx.reactants.map((p) => p.nu), ...rx.products.map((p) => -p.nu)]),
     }));
 
+    // Each reacting port's electrode area per volume at its window's nodes (a profile's mean over
+    // each node's box, as for a rate constant), and its reactions' rates there, mol/(m²·s).
+    this.portArea = model.ports.map((port) =>
+      port.area === null ? null : Float64Array.from(port.nodes, (g) => port.area.value ?? profileMean(port.area, gx[g] - (g > 0 ? segLength[g - 1] : 0) / 2, gx[g] + (g < segLength.length ? segLength[g] : 0) / 2)),
+    );
+    this.portRates = model.ports.map((port) => port.reactions.map(() => new Float64Array(port.nodes.length)));
+
     // Whether any region is strictly neutral (ε = 0, not a conductor): see integrate().
     this.strictlyNeutral = model.regions.some((reg) => {
       const mat = materials[reg.material];
@@ -395,8 +423,14 @@ export class Solver {
     for (const port of model.ports) for (const g of port.nodes) need[g] = 1;
     // Nodes of strictly neutral (ε = 0) regions that stay neutral, where φ is defined: interior
     // ones, and edges at neutral faces (a capacitive or pinned face's edge node holds the face's
-    // charge), away from contacts and ports. On a transient step these are solved in better-
-    // conditioned terms (see _chargeRows).
+    // charge), away from the contacts and from ports that hold a level (which replaces a balance
+    // row). On a transient step these are solved in better-conditioned terms (see _chargeRows).
+    // A port that only exchanges (an O₂ supply, a leak) is solved there too: left out, its window
+    // fell back on the ill-conditioned terms, and a closed neutral electrolyte whose potential is
+    // set only by a face reaction couldn't take a step.
+    const held = new Uint8Array(nNodes);
+    held[0] = held[nNodes - 1] = 1;
+    for (const port of model.ports) if (port.species.some((l) => l.type === 'equilibrium')) for (const g of port.nodes) held[g] = 1;
     this.chargeNode = new Uint8Array(nNodes);
     const neutralFace = (f) => f >= 0 && f < model.interfaces.length && model.interfaces[f].phi.type === 'neutral';
     regions.forEach((reg, r) => {
@@ -405,7 +439,7 @@ export class Solver {
       const g0 = grid.regionStart[r], g1 = grid.regionEnd[r];
       for (let g = g0; g <= g1; g++) {
         const edgeOk = (g > g0 || neutralFace(r - 1)) && (g < g1 || neutralFace(r));
-        if (edgeOk && !need[g] && !this.phiUndefined[g]) this.chargeNode[g] = 1;
+        if (edgeOk && !held[g] && !this.phiUndefined[g]) this.chargeNode[g] = 1;
       }
     });
     this.chargeNodes = Int32Array.from([...this.chargeNode.keys()].filter((g) => this.chargeNode[g]));
@@ -440,6 +474,8 @@ export class Solver {
       }
       active[b * M] = this.phiUndefined[g] ? 0 : 1;
       for (let i = 0; i < n; i++) active[b * M + 1 + i] = this.present[g * n + i];
+      const k = this.surfPort[g];
+      if (k >= 0) for (let q = 0; q < model.ports[k].surface.length; q++) active[b * M + 1 + n + q] = 1;
     }
     model.interfaces.forEach((itf, f) => {
       const bf = this.blockOfFace[f];
@@ -502,10 +538,15 @@ export class Solver {
             if (rx.kf[m] > 0 && [...rx.reactants, ...rx.products].some((p) => p.i === i)) reactive = true;
           }
         }
-        const ports = model.ports.flatMap((port, k) => (port.region >= r0 && port.region <= r && port.species[i].type !== 'blocked' ? [k] : []));
-        const connected = leftOpen || rightOpen || ports.length > 0;
+        const inside = (port) => port.region >= r0 && port.region <= r;
+        const linked = model.ports.flatMap((port, k) => (inside(port) && port.species[i].type !== 'blocked' ? [k] : []));
+        // made or consumed by a port's reactions (an electrode spread through its window)
+        const reacting = model.ports.flatMap((port, k) => (inside(port) && port.reactions.some((rx) => rx.part.some((p) => p.side === 0 && p.i === i)) ? [k] : []));
+        if (reacting.length > 0) reactive = true;
+        const connected = leftOpen || rightOpen || linked.length > 0;
         this.stretches.push({
-          ports,
+          linked, // ports that hold or exchange it
+          ports: [...new Set([...linked, ...reacting])], // ports that bring any in
           species: i,
           regions: [r0, r],
           nodes: [grid.regionStart[r0], grid.regionEnd[r]],
@@ -635,6 +676,13 @@ export class Solver {
         rows.push(row);
       }
     });
+    for (const port of model.ports) {
+      for (const rx of port.reactions) {
+        const row = new Float64Array(S); // (the electrode's carrier is outside the device)
+        for (const p of rx.part) if (p.side === 0) row[this.stretchOf[port.region * n + p.i]] += p.nu;
+        rows.push(row);
+      }
+    }
     model.regions.forEach((reg, q) => {
       for (const rx of model.reactions) {
         if (!(rx.kf[reg.material] > 0)) continue;
@@ -820,11 +868,11 @@ export class Solver {
     });
   }
 
-  /** η_i (μ̄/RT) of a port's outside level for species i. */
+  /** η_i (μ̄/RT) of a port's outside level for species i (its electrode's carrier: at V itself). */
   portEta(port, i) {
     const link = port.species[i];
     const V = this.termV[2 + this.model.ports.indexOf(port)];
-    return this.z[i] === 0 ? link.mu / this.model.RT : (this.z[i] * (V + link.offset)) / this.VT;
+    return this.z[i] === 0 ? link.mu / this.model.RT : (this.z[i] * (V + (link.offset ?? 0))) / this.VT;
   }
 
   /** η_i/RT that a fixed contact link imposes (or NaN if the link isn't fixed). */
@@ -890,7 +938,7 @@ export class Solver {
         } else {
           const left = st.regions[0] === 0 ? this.contactEta('left', i) : NaN;
           eta[i] = Number.isFinite(left) ? left : this.contactEta('right', i);
-          if (!Number.isFinite(eta[i]) && st.ports.length > 0) eta[i] = this.portEta(model.ports[st.ports[0]], i);
+          if (!Number.isFinite(eta[i]) && st.linked.length > 0) eta[i] = this.portEta(model.ports[st.linked[0]], i);
           mode[i] = 1;
           if (!Number.isFinite(eta[i])) {
             // Fed only through reactions (no level held at a contact): start from c0.
@@ -961,6 +1009,25 @@ export class Solver {
           }
         }
       }
+      const electrode = model.ports.find((port) => port.region === r && port.reactions.length > 0);
+      if (!mat.phiFree && !responds && mat.ideal && electrode) {
+        // Nor here, but an electrode spread through it does: start with the port's first reaction
+        // that can be balanced at equilibrium with the port's level (the electrode at open circuit).
+        for (const rx of electrode.reactions) {
+          let a = rx.fixedA, s = 0;
+          for (const p of rx.part) {
+            if (p.side === 1) a -= p.nu * this.portEta(electrode, p.i);
+            else if (mode[p.i] === 2) {
+              a -= p.nu * (Math.log(cFix[p.i] / mat.cRef[p.i]) + mat.mu0[p.i] / model.RT);
+              s += p.nu * z[p.i];
+            } else s = NaN;
+          }
+          if (s !== 0 && Number.isFinite(s)) {
+            phiHat = a / s;
+            break;
+          }
+        }
+      }
       const neutralPhi = (ph) => {
         let lo = ph - 1, hi = ph + 1;
         while (charge(lo) < 0 && lo > -1e4) lo -= 2 * (hi - lo);
@@ -1011,7 +1078,60 @@ export class Solver {
       const shift = level(t.side) - level(this.terms[held].side);
       if (Number.isFinite(shift)) this.termV[k] = this.termV[held] + shift;
     }
+    // Electrode surfaces at their starting coverages: η = μ°/RT + ln(θ/θ₀).
+    for (let g = 0; g < this.nNodes; g++) {
+      const k = this.surfPort[g];
+      if (k < 0) continue;
+      const surf = model.ports[k].surface, b = this.blockOfNode[g], bare = 1 - surf.reduce((t, sp) => t + sp.theta0, 0);
+      surf.forEach((sp, q) => (u[b * M + 1 + n + q] = sp.mu0 / model.RT + Math.log(sp.theta0 / bare)));
+    }
     this.computeConcentrations();
+    // A floating electrode spread through a port starts where its reactions pass the current it's
+    // set (none, behind a resistance): at its mixed potential in the start's composition, not
+    // level with a held terminal, which can be volts away and pass an absurd current.
+    for (const k of this.floating) {
+      const t = this.terms[k], port = t.kind === 'port' ? model.ports[t.index] : null;
+      if (!port || port.reactions.length === 0) continue;
+      const want = t.drive.kind === 'I' ? sourceAt(t.drive.src, this.time) : 0;
+      const current = (V) => {
+        this.termV[k] = V;
+        let I = 0;
+        port.reactions.forEach((rx) => {
+          let q = 0;
+          for (const p of rx.part) if (p.side === 0) q += p.nu * z[p.i];
+          port.nodes.forEach((g, w) => (I += q * FARADAY * this.model.grid.vol[g] * this.portArea[t.index][w] * this._portRate(port, rx, g)));
+        });
+        return I;
+      };
+      // Current into the device rises with V (oxidation); bracket, then bisect.
+      let lo = this.termV[k] - 1, hi = this.termV[k] + 1;
+      while (current(lo) > want && lo > -1e3) lo -= 2 * (hi - lo);
+      while (current(hi) < want && hi < 1e3) hi += 2 * (hi - lo);
+      for (let it = 0; it < 200 && hi - lo > 1e-12; it++) {
+        const m = 0.5 * (lo + hi);
+        if (current(m) < want) lo = m;
+        else hi = m;
+      }
+      this.termV[k] = 0.5 * (lo + hi);
+    }
+  }
+
+  // A port reaction's rate per area at node g (mol/(m²·s), forward), at the present state.
+  _portRate(port, rx, g) {
+    const { n, M, u, uLo, c, nSurf, th } = this, b = this.blockOfNode[g], RT = this.model.RT;
+    let pref = rx.k0, a = rx.fixedA;
+    for (const p of rx.part) {
+      if (p.side === 1) {
+        a -= p.nu * this.portEta(port, p.i);
+        continue;
+      }
+      const o = b * M + (p.side === 2 ? 1 + n + p.s : 1 + p.i), e = p.nu < 0 ? -p.nu * (1 - rx.alpha) : p.nu * rx.alpha;
+      a -= p.nu * (u[o] + uLo[o]);
+      pref *= p.side === 2 ? Math.exp(e * (u[o] + uLo[o] - port.surface[p.s].mu0 / RT)) : powr(c[g * n + p.i] / this.cRef[g * n + p.i], e);
+    }
+    if (rx.bare) pref *= this.th0[g];
+    // (far from equilibrium, the plain difference: bvFactor's product would give 0·∞ there)
+    return pref * (Math.abs(a) > 50 ? Math.exp(rx.alpha * a) - Math.exp(-(1 - rx.alpha) * a) : bvFactor(a, rx.alpha).g);
   }
 
   // A non-ideal material's composition at φ̂ = ph: level-fixed species (mode 1) at their η,
@@ -1040,6 +1160,23 @@ export class Solver {
     }
   }
 
+  // Each electrode surface's coverages from its η: Langmuir on shared sites, θ_s = e^{ζ_s}/(1 + Σ e^{ζ}),
+  // ζ = η − μ°/RT (so θ_s/θ₀ = e^{ζ_s}), at every node of a surfaced window.
+  _coverages() {
+    const { n, M, u, uLo, nSurf, th } = this, RT = this.model.RT;
+    for (let g = 0; g < this.nNodes; g++) {
+      const k = this.surfPort[g];
+      if (k < 0) continue;
+      const surf = this.model.ports[k].surface, b = this.blockOfNode[g];
+      let m = 0;
+      for (let q = 0; q < surf.length; q++) m = Math.max(m, u[b * M + 1 + n + q] + uLo[b * M + 1 + n + q] - surf[q].mu0 / RT);
+      let sum = Math.exp(-m);
+      for (let q = 0; q < surf.length; q++) sum += (th[g * nSurf + q] = Math.exp(u[b * M + 1 + n + q] + uLo[b * M + 1 + n + q] - surf[q].mu0 / RT - m));
+      for (let q = 0; q < surf.length; q++) th[g * nSurf + q] /= sum;
+      this.th0[g] = Math.exp(-m) / sum;
+    }
+  }
+
   computeConcentrations() {
     const { n, M, u, uLo, c, z } = this;
     for (let g = 0; g < this.nNodes; g++) {
@@ -1054,7 +1191,7 @@ export class Solver {
         // Excess carriers: zero in the bulk, the surface sheet at a charged face.
         for (let i = 0; i < n; i++) c[g * n + i] = 0;
         const f = this.sheetFace[g];
-        if (f >= 0) c[g * n + im] = (this.sheetSign[g] * u[this.blockOfFace[f] * M]) / (z[im] * FARADAY * this.model.grid.vol[g]);
+        if (f >= 0) c[g * n + im] = (this.sheetSign[g] * u[this.blockOfFace[f] * M] * this.model.grid.area[g]) / (z[im] * FARADAY * this.model.grid.vol[g]);
         continue;
       }
       for (let i = 0; i < n; i++) {
@@ -1062,6 +1199,7 @@ export class Solver {
         c[k] = this.present[k] ? this.cRef[k] * Math.exp(u[b * M + 1 + i] + uLo[b * M + 1 + i] - this.mu0hat[k] - z[i] * phiHat) : 0;
       }
     }
+    this._coverages();
   }
 
   _work(md) {
@@ -1165,7 +1303,7 @@ export class Solver {
       const g0 = grid.regionStart[r], g1 = grid.regionEnd[r];
       if (mat.conductor) {
         for (let g = g0; g <= g1; g++) this._nodeConductor(g, dt);
-        for (let s = g0; s < g1; s++) this._segmentConductor(s, s + r, s + r + 1, mat, grid.segLength[s]);
+        for (let s = g0; s < g1; s++) this._segmentConductor(s, s + r, s + r + 1, mat, grid.segLength[s] / grid.segArea[s]);
         continue;
       }
       if (mat.ideal) this._nodesDilute(g0, g1, dt);
@@ -1173,7 +1311,7 @@ export class Solver {
       const rxs = this.rxsIn[reg.material];
       if (rxs.length > 0) for (let g = g0; g <= g1; g++) this._bulkReactions(g, rxs);
       for (let s = g0; s < g1; s++) {
-        const bL = s + r, bR = bL + 1, h = grid.segLength[s];
+        const bL = s + r, bR = bL + 1, h = grid.segLength[s] / grid.segArea[s]; // (a length over the cross-section: fluxes are totals)
         this._segmentDisplacement(s, bL, bR, mat, h);
         if (reg.mixing > 0) this._segmentMixing(s, bL, bR, reg.mixing, h, mat);
         if (!mat.ideal) this._segmentConcentrated(s, bL, bR, mat, h, reg.velocity);
@@ -1201,7 +1339,7 @@ export class Solver {
     const r = 1 + im, k = g * n + im;
     res[R[b * M + r]] += (v * (c[k] - cOld[k])) / dt;
     const f = this.sheetFace[g];
-    if (f >= 0) this._j(b, r, this.blockOfFace[f], 0, this.sheetSign[g] / (z[im] * FARADAY * dt));
+    if (f >= 0) this._j(b, r, this.blockOfFace[f], 0, (this.sheetSign[g] * this.model.grid.area[g]) / (z[im] * FARADAY * dt));
   }
 
   // Dilute nodes g0…g1 (ideal statistics, c = c_ref e^ζ): storage of each species and the space
@@ -1450,9 +1588,9 @@ export class Solver {
   _segmentsDilute(g0, g1, region, mat, vel) {
     const { n, M, u, uLo, res, c, z, sys, loc } = this, R = this.rix, F = FARADAY;
     const { A: JA, B: JB, C: JC, sizes, offA, offB, offC } = sys;
-    const segLength = this.model.grid.segLength;
+    const { segLength, segArea } = this.model.grid;
     for (let s = g0; s < g1; s++) {
-      const bL = s + region, bR = bL + 1, h = segLength[s];
+      const bL = s + region, bR = bL + 1, h = segLength[s] / segArea[s]; // (fluxes are totals through the cross-section)
       const mL = sizes[bL], mR = sizes[bR], pL = loc[bL * M], pR = loc[bR * M];
       const phiL = u[bL * M], phiR = u[bR * M];
       for (let i = 0; i < n; i++) {
@@ -1535,15 +1673,16 @@ export class Solver {
         this._j(bf, 0, bL, 0, -kC);
       }
     }
-    // D_f enters each side's Gauss row; a metal side holds it as surface carriers instead.
-    const gL = grid.regionEnd[f], gR = gL + 1;
+    // D_f enters each side's Gauss row; a metal side holds it as surface carriers instead. The
+    // flux node's unknowns are per area, so what they carry is that times the face's area.
+    const gL = grid.regionEnd[f], gR = gL + 1, Af = grid.area[gL];
     if (this.nodeConductor[gL] < 0) {
-      res[R[bL * M]] += u[bf * M];
-      this._j(bL, 0, bf, 0, 1);
+      res[R[bL * M]] += Af * u[bf * M];
+      this._j(bL, 0, bf, 0, Af);
     }
     if (this.nodeConductor[gR] < 0) {
-      res[R[bR * M]] -= u[bf * M] + itf.sheetCharge;
-      this._j(bR, 0, bf, 0, -1);
+      res[R[bR * M]] -= Af * (u[bf * M] + itf.sheetCharge);
+      this._j(bR, 0, bf, 0, -Af);
     }
     for (let i = 0; i < n; i++) {
       const r = 1 + i, o = bf * M + r;
@@ -1583,12 +1722,12 @@ export class Solver {
         this._j(bf, r, bL, r, -gG);
         this._j(bf, r, bR, r, gG);
       }
-      res[R[bL * M + r]] += u[o];
-      this._j(bL, r, bf, r, 1);
-      res[R[bR * M + r]] -= u[o];
-      this._j(bR, r, bf, r, -1);
+      res[R[bL * M + r]] += Af * u[o];
+      this._j(bL, r, bf, r, Af);
+      res[R[bR * M + r]] -= Af * u[o];
+      this._j(bR, r, bf, r, -Af);
     }
-    itf.reactions.forEach((rx, k) => this._faceReaction(rx, k, f, bf, bL, bR));
+    itf.reactions.forEach((rx, k) => this._faceReaction(rx, k, f, bf, bL, bR, Af));
   }
 
   // Scharfetter–Gummel with non-ideal statistics. The excess ex = ζ − ln(c/c_ref) acts as an
@@ -1805,7 +1944,7 @@ export class Solver {
   // with the row r_k − rate(u_L, u_R) = 0, and each participant's edge node takes ν·r_k (made
   // there when ν > 0). The rate couples the two edge nodes only through the face block between
   // them, which keeps the system block-tridiagonal.
-  _faceReaction(rx, k, f, bf, bL, bR) {
+  _faceReaction(rx, k, f, bf, bL, bR, Af) {
     const { n, M, u, uLo, c, res } = this;
     const R = this.rix;
     const grid = this.model.grid;
@@ -1865,8 +2004,8 @@ export class Solver {
     }
     for (const p of rx.part) {
       const b = p.side ? bR : bL;
-      res[R[b * M + 1 + p.i]] -= p.nu * u[o];
-      this._j(b, 1 + p.i, bf, slot, -p.nu);
+      res[R[b * M + 1 + p.i]] -= Af * p.nu * u[o];
+      this._j(b, 1 + p.i, bf, slot, -Af * p.nu);
     }
   }
 
@@ -1880,7 +2019,7 @@ export class Solver {
       this.termDI[k] = 0;
       this.termI[k] = 0;
     }
-    this.model.ports.forEach((port, k) => this._port(port, this.portFlux[k], 2 + k));
+    this.model.ports.forEach((port, k) => this._port(port, this.portFlux[k], 2 + k, dt));
     this._contact('left', dt);
     this._contact('right', dt);
     for (const k of this.floating) this._circuit(k);
@@ -1913,7 +2052,7 @@ export class Solver {
   // An internal port (terminal k): its exchange with each node of its window, as a source per
   // volume. A held ('equilibrium') level replaces the node's balance row; the source is then that
   // row's residual, read just before. Its current into the device is Σ z F × the sources.
-  _port(port, flux, k) {
+  _port(port, flux, k, dt) {
     const R = this.rix;
     const { n, M, u, uLo, res, z, VT } = this;
     const F = FARADAY, vol = this.model.grid.vol;
@@ -1948,9 +2087,122 @@ export class Solver {
         }
       }
     }
+    port.reactions.forEach((rx, x) => this._portReaction(port, rx, this.portArea[k - 2], this.portRates[k - 2][x], flux, k));
+    if (port.capacitance) this._portCapacitance(port, k, dt);
+    if (port.surface.length > 0 && Number.isFinite(dt)) this._surfaceStorage(port, dt);
     for (let i = 0; i < n; i++) this.termI[k] += z[i] * F * flux[i];
   }
 
+  // A port's reaction at each node of its window: Butler–Volmer per area, as at a face, against
+  // the electrode's carrier at the port's level (activity 1), times the electrode's area per
+  // volume. Each node's rate is explicit (no unknown of its own): it enters the balances of the
+  // species it makes and consumes, and the port's current.
+  _portReaction(port, rx, area, rates, flux, k) {
+    const { n, M, u, uLo, c, res, z, VT, nSurf, th } = this, R = this.rix, F = FARADAY, vol = this.model.grid.vol, RT = this.model.RT;
+    const B = this.termB[k], C = this.termC[k], al = rx.alpha, d = this.dA, surf = port.surface;
+    // The carrier's part of the affinity, and how it moves with the port's voltage.
+    let aV = rx.fixedA, daV = 0, q = 0; // q: charge the forward reaction brings into the device, per event
+    for (const p of rx.part) {
+      if (p.side === 1) {
+        aV -= p.nu * this.portEta(port, p.i);
+        daV -= (p.nu * z[p.i]) / VT;
+      } else if (p.side === 0) q += p.nu * z[p.i];
+    }
+    const slot = (p) => (p.side === 2 ? 1 + n + p.s : 1 + p.i);
+    port.nodes.forEach((g, w) => {
+      const b = this.blockOfNode[g], s = vol[g] * area[w];
+      d.fill(0);
+      let pref = rx.k0, aHi = aV, aLo = 0;
+      for (const p of rx.part) {
+        if (p.side === 1) continue;
+        const o = b * M + slot(p);
+        aHi -= p.nu * u[o];
+        aLo -= p.nu * uLo[o];
+        const e = p.nu < 0 ? -p.nu * (1 - al) : p.nu * al;
+        if (p.side === 2) {
+          // a surface species at activity θ/θ₀ = e^ζ
+          pref *= Math.exp(e * (u[o] + uLo[o] - surf[p.s].mu0 / RT));
+          d[1 + n + p.s] += e;
+        } else {
+          pref *= powr(c[g * n + p.i] / this.cRef[g * n + p.i], e);
+          this._dlnc(g, p.i, e, d);
+        }
+      }
+      if (rx.bare) {
+        // on bare metal only: the free fraction θ₀ = 1 − Σθ, with ∂ln θ₀/∂η_s = −θ_s
+        for (let x = 0; x < surf.length; x++) d[1 + n + x] -= th[g * nSurf + x];
+        pref *= this.th0[g];
+      }
+      const { g: bv, gp } = bvFactor(aHi + aLo, al);
+      const rate = pref * bv;
+      rates[w] = rate;
+      // ∂rate/∂slot = rate·∂ln(prefactor) + pref·g′·∂a, with ∂a/∂η = −ν
+      for (let t = 0; t < M; t++) d[t] *= rate;
+      for (const p of rx.part) if (p.side !== 1) d[slot(p)] -= pref * gp * p.nu;
+      const dV = pref * gp * daV;
+      for (const p of rx.part) {
+        if (p.side === 1) continue;
+        // the region's species per volume of the window; a surface's per area of electrode
+        const row = slot(p), o = b * M + row, f = p.side === 2 ? 1 : s;
+        res[R[o]] -= f * p.nu * rate;
+        if (p.side === 0) flux[p.i] += s * p.nu * rate;
+        for (let t = 0; t < M; t++) if (d[t] !== 0) this._j(b, row, b, t, -f * p.nu * d[t]);
+        B[R[o]] -= f * p.nu * dV;
+      }
+      for (let t = 0; t < M; t++) if (d[t] !== 0) C[R[b * M + t]] += q * F * s * d[t];
+      this.termDI[k] += q * F * s * dV;
+    });
+  }
+
+  // A capacitance spread through a port's window: per area of electrode, σ = C (V − zeroCharge − φ)
+  // on the port's side, so each node's charge balance (its φ row) gains vol·a·σ, and the port
+  // passes the charging current d(Σ vol·a·σ)/dt (none in a steady state). An end node whose φ its
+  // contact sets is left to the contact.
+  _portCapacitance(port, k, dt) {
+    const { M, u, uLo, res, VT } = this, R = this.rix, vol = this.model.grid.vol, area = this.portArea[k - 2];
+    const { C: Cs, zeroCharge } = port.capacitance, V = this.termV[k], B = this.termB[k], Ct = this.termC[k];
+    const sets = (side) => ['pinned', 'bulk'].includes(this.model.contacts[side].phi.type);
+    let Q = 0, dQdV = 0;
+    port.nodes.forEach((g, w) => {
+      if ((g === 0 && sets('left')) || (g === this.nNodes - 1 && sets('right')) || this.phiUndefined[g]) return;
+      const b = this.blockOfNode[g], s = vol[g] * area[w] * Cs;
+      const q = s * (V - zeroCharge - VT * (u[b * M] + uLo[b * M]));
+      Q += q;
+      dQdV += s;
+      res[R[b * M]] -= q;
+      this._j(b, 0, b, 0, s * VT);
+      B[R[b * M]] -= s;
+      if (Number.isFinite(dt)) Ct[R[b * M]] += (-s * VT) / dt;
+    });
+    this.portQ[k - 2] = Q;
+    if (Number.isFinite(dt)) {
+      this.termI[k] += (Q - this.portQStart[k - 2]) / dt;
+      this.termDI[k] += dQdV / dt;
+    }
+  }
+
+  // An electrode surface's storage, per area of electrode: Γ (θ_s − θ_s,old)/dt in each surface
+  // species' row, with ∂θ_s/∂η_x = θ_s (δ_sx − θ_x).
+  _surfaceStorage(port, dt) {
+    const { n, M, res, nSurf, th, thOld } = this, R = this.rix, surf = port.surface, G = surf[0].capacity;
+    for (const g of port.nodes) {
+      const b = this.blockOfNode[g];
+      // Near full coverage θ − θ_old cancels (both ~1, the change ~θ₀): the dominant species'
+      // change comes from the small ones instead, Δθ = −Δθ₀ − Σ_others Δθ.
+      let top = 0;
+      for (let q = 1; q < surf.length; q++) if (th[g * nSurf + q] > th[g * nSurf + top]) top = q;
+      for (let q = 0; q < surf.length; q++) {
+        const tq = th[g * nSurf + q];
+        let change = tq - thOld[g * nSurf + q];
+        if (q === top && tq > 0.5) {
+          change = -(this.th0[g] - this.th0Old[g]);
+          for (let x = 0; x < surf.length; x++) if (x !== q) change -= th[g * nSurf + x] - thOld[g * nSurf + x];
+        }
+        res[R[b * M + 1 + n + q]] += (G * change) / dt;
+        for (let x = 0; x < surf.length; x++) this._j(b, 1 + n + q, b, 1 + n + x, ((G * tq) / dt) * ((q === x ? 1 : 0) - th[g * nSurf + x]));
+      }
+    }
+  }
 
   // One contact (terminal 0 or 1): record the flux through its outer face and the current into
   // the device (read from the end box before anything here is added: whatever the box needs
@@ -1966,6 +2218,7 @@ export class Solver {
     const b = this.blockOfNode[g];
     const sgn = side === 'left' ? 1 : -1;
     const flux = this.contactFlux[side];
+    const Ac = model.grid.area[g]; // the links' laws are per area: what they pass is that times A here
     const dyn = Number.isFinite(dt);
 
     // Before anything is added, each balance residual is the flux into the device here.
@@ -1986,13 +2239,13 @@ export class Solver {
       const link = ct.species[i];
       const o = b * M + 1 + i;
       if (link.type === 'exchange') {
-        res[R[o]] -= link.k * (link.mu / model.RT - (u[o] + uLo[o]));
-        this._j(b, 1 + i, b, 1 + i, link.k);
+        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];
-        res[R[o]] -= (link.G * (Vt + link.offset - Vi)) / (z[i] * F);
-        this._j(b, 1 + i, b, 1 + i, (link.G * VT) / (z[i] * z[i] * F));
-        B[R[o]] += -link.G / (z[i] * F);
+        res[R[o]] -= (Ac * link.G * (Vt + link.offset - Vi)) / (z[i] * F);
+        this._j(b, 1 + i, b, 1 + i, (Ac * link.G * VT) / (z[i] * z[i] * F));
+        B[R[o]] += (-Ac * link.G) / (z[i] * F);
       }
     }
 
@@ -2014,15 +2267,15 @@ export class Solver {
       this.contactD[side] = 0;
     } else if (link.type === 'capacitive') {
       // Gate, or metal across a Stern layer, at φ_g = V_t − zeroCharge. D toward +x.
-      const Din = link.C * (Vt - link.zeroCharge - VT * u[b * M]);
+      const Din = Ac * link.C * (Vt - link.zeroCharge - VT * u[b * M]);
       res[R[b * M]] -= Din;
-      this._j(b, 0, b, 0, link.C * VT);
-      B[R[b * M]] += -link.C;
+      this._j(b, 0, b, 0, Ac * link.C * VT);
+      B[R[b * M]] += -Ac * link.C;
       this.contactD[side] = sgn * Din;
       if (dyn) {
         I += (Din - Dstart) / dt;
-        C[R[b * M]] += (-link.C * VT) / dt;
-        this.termDI[k] += link.C / dt;
+        C[R[b * M]] += (-Ac * link.C * VT) / dt;
+        this.termDI[k] += (Ac * link.C) / dt;
       }
     } else if (link.type === 'pinned' || link.type === 'bulk') {
       // The Poisson residual is the outside's charge, D_in.
@@ -2106,6 +2359,8 @@ export class Solver {
       for (let i = 0; i < n; i++) {
         if (this.present[g * n + i]) mx = Math.max(mx, Math.abs(delta[R[b * M + 1 + i]]));
       }
+      const k = this.surfPort[g]; // an electrode surface's coverages, as η
+      if (k >= 0) for (let q = 0; q < this.model.ports[k].surface.length; q++) mx = Math.max(mx, Math.abs(delta[R[b * M + 1 + n + q]]));
     }
     return mx;
   }
@@ -2262,14 +2517,15 @@ export class Solver {
     this.uPrevLo.set(this.uLo);
     this.termVPrev.set(this.termV);
     this.computeConcentrations();
-    const cN = Float64Array.from(this.c);
+    const cN = Float64Array.from(this.c), thN = Float64Array.from(this.th), th0N = Float64Array.from(this.th0);
     // Contact displacement before the step: as it was at the end of the previous step (under
     // the parameters then), so a gate-voltage change shows up as displacement current.
-    if (!this.contactDEnd) {
+    if (!this.contactDEnd || !this.portQEnd) {
       this._assembleBookkeeping(dt);
       this.contactDEnd = { ...this.contactD };
+      this.portQEnd = Float64Array.from(this.portQ);
     }
-    const DN = { ...this.contactDEnd };
+    const DN = { ...this.contactDEnd }, QN = Float64Array.from(this.portQEnd);
     if (opts.guess) {
       // Start Newton from a predicted state (e.g. extrapolated from the history).
       this.u.set(opts.guess);
@@ -2280,11 +2536,17 @@ export class Solver {
       const a0 = (1 + 2 * w) / (1 + w), b1 = (1 + w) / a0, b2 = (w * w) / (1 + w) / a0;
       const { cOld } = this;
       for (let k = 0; k < cOld.length; k++) cOld[k] = b1 * cN[k] - b2 * prev.c[k];
+      for (let k = 0; k < thN.length; k++) this.thOld[k] = b1 * thN[k] - b2 * prev.th[k];
+      for (let k = 0; k < th0N.length; k++) this.th0Old[k] = b1 * th0N[k] - b2 * prev.th0[k];
       this.contactDStart = { left: b1 * DN.left - b2 * prev.D.left, right: b1 * DN.right - b2 * prev.D.right };
+      this.portQStart = QN.map((q, k) => b1 * q - b2 * prev.Q[k]);
       dtEff = dt / a0;
     } else {
       this.cOld.set(cN);
+      this.thOld.set(thN);
+      this.th0Old.set(th0N);
       this.contactDStart = DN;
+      this.portQStart = QN;
     }
     // Implicit: sources at the step's end, as seen from within the step (before any jump there).
     // A step landing on a breakpoint ends on it exactly.
@@ -2300,11 +2562,12 @@ export class Solver {
     }
     result.bdf = bdf;
     if (result.converged) {
-      this.history.unshift({ t: this.time, dt, u: Float64Array.from(this.uPrev), c: cN, D: DN });
+      this.history.unshift({ t: this.time, dt, u: Float64Array.from(this.uPrev), c: cN, th: thN, th0: th0N, D: DN, Q: QN });
       if (this.history.length > 3) this.history.length = 3;
       this.time = tEnd;
       this.lastDt = dtEff;
       this.contactDOld = this.contactDStart;
+      this.portQOld = this.portQStart;
       this._accumulateBoundaryIntake(dtEff, cN);
     } else {
       this.u.set(this.uPrev);
@@ -2588,12 +2851,17 @@ export class Solver {
       u: Float64Array.from(this.u),
       uLo: Float64Array.from(this.uLo),
       cOld: Float64Array.from(this.cOld),
+      thOld: Float64Array.from(this.thOld),
+      th0Old: Float64Array.from(this.th0Old),
       time: this.time,
       lastDt: this.lastDt,
       atSteady: this.atSteady,
       contactDStart: this.contactDStart,
       contactDOld: this.contactDOld,
       contactDEnd: this.contactDEnd,
+      portQStart: this.portQStart,
+      portQOld: this.portQOld,
+      portQEnd: this.portQEnd,
       boundaryIntake: Float64Array.from(this.boundaryIntake),
       history: this.history.slice(),
       termV: Float64Array.from(this.termV),
@@ -2605,12 +2873,17 @@ export class Solver {
     this.u.set(s.u);
     this.uLo.set(s.uLo);
     this.cOld.set(s.cOld);
+    this.thOld.set(s.thOld);
+    this.th0Old.set(s.th0Old);
     this.time = s.time;
     this.lastDt = s.lastDt;
     this.atSteady = s.atSteady;
     this.contactDStart = s.contactDStart;
     this.contactDOld = s.contactDOld;
     this.contactDEnd = s.contactDEnd;
+    this.portQStart = s.portQStart;
+    this.portQOld = s.portQOld;
+    this.portQEnd = s.portQEnd;
     this.boundaryIntake.set(s.boundaryIntake);
     this.history = s.history.slice();
     this.termV.set(s.termV);
@@ -2647,8 +2920,11 @@ export class Solver {
     this.sourceTime = this.time;
     this.computeConcentrations();
     this.cOld.set(this.c);
+    this.thOld.set(this.th);
+    this.th0Old.set(this.th0);
     this.assemble(Infinity);
     this.contactDStart = { ...this.contactD };
+    this.portQStart = Float64Array.from(this.portQ);
     this.assemble(Infinity);
     // The steady parts, then the storage parts from an assembly at a tiny dt.
     const J = { A: sys.A.slice(), B: sys.B.slice(), C: sys.C.slice() };
@@ -2910,7 +3186,7 @@ export class Solver {
       const reg = regions[r], mat = materials[reg.material];
       if (mat.conductor) {
         for (const g of nodes) this._nodeConductor(g, dt);
-        for (const s of segs) this._segmentConductor(s, s + r, s + r + 1, mat, grid.segLength[s]);
+        for (const s of segs) this._segmentConductor(s, s + r, s + r + 1, mat, grid.segLength[s] / grid.segArea[s]);
         continue;
       }
       for (const g of nodes) {
@@ -2920,7 +3196,7 @@ export class Solver {
       const rxs = this.rxsIn[reg.material];
       if (rxs.length > 0) for (const g of nodes) this._bulkReactions(g, rxs);
       for (const s of segs) {
-        const bL = s + r, bR = bL + 1, h = grid.segLength[s];
+        const bL = s + r, bR = bL + 1, h = grid.segLength[s] / grid.segArea[s]; // (a length over the cross-section: fluxes are totals)
         this._segmentDisplacement(s, bL, bR, mat, h);
         if (reg.mixing > 0) this._segmentMixing(s, bL, bR, reg.mixing, h, mat);
         if (!mat.ideal) this._segmentConcentrated(s, bL, bR, mat, h, reg.velocity);
@@ -2936,6 +3212,7 @@ export class Solver {
   _accumulateBoundaryIntake(dt, cN) {
     this._assembleBookkeeping(dt);
     this.contactDEnd = { ...this.contactD };
+    this.portQEnd = Float64Array.from(this.portQ);
     if (!Number.isFinite(dt)) return;
     const last = this.model.regions.length - 1;
     const { n, cOld } = this, vol = this.model.grid.vol;