driftlet 1.3.0 → 1.3.3

package/src/start.js

@@ -27,18 +27,24 @@
 //      plus each face's dipole. In a region where a level-fixed charged species responds to φ̂,
 //      φ̂ is chosen for neutrality (a bisection; node by node where a profile varies);
 //      otherwise it's the running φ̂, or where a conductor on the left or an electrode spread
-//      through the region has a reaction that can balance, the φ̂ that balances it. Where
-//      neutrality is out of reach (c0's amounts leave a charge no held level balances), the
-//      running φ̂, and a strictly neutral region is noted in s.unbalanced (for a transient that
-//      fails from it to say why). A strictly
+//      through the region has a reaction that can balance, the φ̂ that balances it (by bisection;
+//      a trial a non-ideal model refuses counts its ideal charge, which has the sign there). Where
+//      neutrality is out of reach (c0's amounts leave a charge no held level balances): in a
+//      strictly neutral region the running φ̂, the region noted in s.unbalanced (for a transient
+//      that fails from it to say why); otherwise the φ̂ nearest the running one, toward less
+//      charge, where the charge is at most ε V_T/(F L²) (L the region's length: what it holds with
+//      a thermal voltage across it), or where it stops falling (a fixed charge). A strictly
 //      neutral region (ε = 0) with every charged species' amount given must have a neutral c0:
 //      an error otherwise. A non-ideal material's composition comes from its statistics
 //      (materialAt).
-//   2. A face between two strictly neutral ideal regions, its φ type neutral, whose links hold
-//      some charged species in equilibrium: its two nodes are set to that equilibrium (each
-//      passing species' μ̄ equal across it, the left node neutral, each passing species' amount
-//      over the two nodes kept; the jump in φ̂ between them the one unknown), everything else at
-//      them unchanged in concentration.
+//   2. Marks the state cold (s.coldStart). equilibrateFaces(s), which the first time step from it
+//      calls (src/timeSteps.js) and a steady solve doesn't: a face between two strictly neutral
+//      ideal regions, its φ type neutral, whose links hold some charged species in equilibrium,
+//      its two nodes set to that equilibrium, its t = 0⁺ (each passing species' μ̄ equal across
+//      it, the left node neutral, each passing species' amount over the two nodes kept; the jump
+//      in φ̂ between them the one unknown), everything else at them unchanged in concentration;
+//      s.coldStart false. A solve that converges, a warm start and a carried state set it as
+//      their state is.
 //   3. An insertion host (a φ-free material, not a conductor): its φ̂ and every η shifted by z·Δ so that its first
 //      charged species shared with a neighbour across a face starts at that neighbour's level.
 //   4. A floating contact facing a held one: V = the held V + the difference between the two
@@ -55,17 +61,18 @@
 //      pass the current it's driven at, or behind a resistance (V_src − V)/R, by bisection.
 //
 // Invariants (each says what a reviewer should be able to check here):
-//   1. A species given by its amount starts at c0 (or its profile) at every node, but for the
-//      two nodes of a face equilibrated in step 2, where its amount over the two is kept.
+//   1. A species given by its amount starts at c0 (or its profile) at every node; at a face
+//      equilibrated by step 2 (a transient's first step), its amount over the two nodes is kept.
 //   2. A species given by its level starts at the level of what feeds it, as step 1 orders them.
 //   3. Where a level-fixed charged species responds, each node starts neutral (Σ z c + the fixed
-//      charge = 0) to the bisection's tolerance, unless neutrality is out of reach (step 1); a
+//      charge = 0) to the bisection's tolerance, unless neutrality is out of reach (step 1: then
+//      its charge at most ε V_T/(F L²), or the least φ̂ gives, to the bisection's tolerance); a
 //      strictly neutral region given by amounts is neutral by its c0, checked.
 //   4. Steps 2 and 3 change no concentration but as they say: step 3 is a gauge (φ̂ and each η by
 //      z·Δ), step 2 moves the passing species between a face's two nodes only.
 //   5. Each floating terminal's V is set by the last of steps 4, 6, 7, 9 that applies to it;
 //      held terminals' V are untouched.
-//   6. Only u, uLo, termV, s.unbalanced and what computeConcentrations derives are written; the
+//   6. Only u, uLo, termV, s.unbalanced, s.coldStart and what computeConcentrations derives are written; the
 //      result depends on the model, every terminal's voltage and s.time, deterministically.
 // Known, and not an invariant (a cold review; see ROADMAP): the gauge (φ̂ and each η by z·Δ)
 // runs from the left, so behind a closed or floating left end the start sits away from a right
@@ -77,7 +84,7 @@
 // Tests: every test (each device starts here); test/transient.test.js on what a start must be.
 
 import { gateRate } from './boundaries.js';
-import { FARADAY } from './constants.js';
+import { EPS0, FARADAY } from './constants.js';
 import { sourceAt } from './device.js';
 import { profileAt, SolverError } from './solver.js';
 
@@ -163,10 +170,22 @@ export function initFromComposition(s) {
     const zeta = new Float64Array(n), cc = new Float64Array(n);
     const charge = (ph) => {
       if (!mat.ideal) {
-        materialAt(s, mat, reg.background, eta, mode, cFix, ph, zeta, cc);
-        let q = reg.fixedCharge / FARADAY;
-        for (let i = 0; i < n; i++) if (mat.present[i]) q += z[i] * cc[i];
-        return q;
+        // A model can refuse a trial φ̂ far out, where one ion is many orders denser than the rest
+        // (Debye–Hückel's limiting law threw out of the start, for KCl at 10 mM, its neutral φ̂
+        // 57 units from where the search began): there the ideal charge has the sign, and the
+        // search goes on by it.
+        let refused = false;
+        try {
+          materialAt(s, mat, reg.background, eta, mode, cFix, ph, zeta, cc);
+        } catch (err) {
+          if (!(err instanceof SolverError)) throw err;
+          refused = true;
+        }
+        if (!refused) {
+          let q = reg.fixedCharge / FARADAY;
+          for (let i = 0; i < n; i++) if (mat.present[i]) q += z[i] * cc[i];
+          return q;
+        }
       }
       let q = reg.fixedCharge / FARADAY;
       for (let i = 0; i < n; i++) {
@@ -244,13 +263,39 @@ export function initFromComposition(s) {
       while (charge(lo) < 0 && lo > -1e4) lo -= 2 * (hi - lo);
       while (charge(hi) > 0 && hi < 1e4) hi += 2 * (hi - lo);
       // Out of reach (every responding carrier has one sign and nothing balances it, as in an
-      // undoped layer that holds only holes): keep the running φ̂ rather than run it to ±∞.
+      // undoped layer that holds only holes): not run to ±∞, but where the charge is no more than
+      // the region holds with a thermal voltage across it, ε V_T/(F L²), or as little as it gets
+      // (a fixed charge left). Kept at the running φ̂ (a contact's level), a hole-only layer 100
+      // nm thick started full of the anode's 1e27 m⁻³ holes, 7 kV of space charge: with traps in
+      // it, every step failed from there.
       if (charge(lo) < 0 || charge(hi) > 0) {
         // In a strictly neutral region that's a start that can't be: the amounts c0 gives leave
         // a charge no level-held species can balance. Noted, for a transient that fails from it
         // to say so (a steady solve, its levels from the contacts, can still find the state).
-        if (mat.epsr === 0) s.unbalanced.push(r);
-        return ph;
+        if (mat.epsr === 0) {
+          s.unbalanced.push(r);
+          return ph;
+        }
+        const L = grid.x[grid.regionEnd[r]] - grid.x[grid.regionStart[r]];
+        const most = (mat.epsr * EPS0 * model.RT) / (FARADAY * FARADAY * L * L);
+        const q0 = charge(ph), dir = q0 > 0 ? 1 : -1; // (the charge falls as φ̂ rises)
+        if (!(Math.abs(q0) > most)) return ph;
+        let a = ph, qa = Math.abs(q0);
+        for (let step = 1; step < 1e4; step *= 2) {
+          let b = a + dir * step;
+          const qb = Math.abs(charge(b));
+          if (qb <= most) {
+            for (let it = 0; it < 100 && Math.abs(b - a) > 1e-9; it++) {
+              const m = 0.5 * (a + b);
+              if (Math.abs(charge(m)) > most) a = m;
+              else b = m;
+            }
+            return b;
+          }
+          if (!(qb < qa * (1 - 1e-9))) return a; // (a fixed charge: as little as it gets)
+          [a, qa] = [b, qb];
+        }
+        return a;
       }
       for (let it = 0; it < 200 && hi - lo > 1e-12; it++) {
         const m = 0.5 * (lo + hi);
@@ -279,53 +324,6 @@ export function initFromComposition(s) {
       }
     }
   }
-  // Two strictly neutral regions meeting at a face whose links hold ions in equilibrium: where
-  // c0 leaves the two sides out of it (a different fixed charge or immobile ion on each, so
-  // c₊c₋ differs across it), the face reaches it at t = 0⁺, before anything diffuses, and a
-  // first step made to take that jump met an exactly singular pivot. Start there: the ions the
-  // face passes shared between its two nodes in equilibrium (μ̄ equal across it), each one's
-  // amount over the two nodes kept, everything else as c0 has it. The one unknown is the jump
-  // in φ̂ across it (a Donnan potential), set by neutrality on one side; the other's follows,
-  // the two nodes' charge summing to what it was, zero.
-  for (let f = 0; f < interfaces.length; f++) {
-    const itf = interfaces[f], mL = materials[regions[f].material], mR = materials[regions[f + 1].material];
-    const strict = (m) => m.epsr === 0 && !m.conductor && !m.phiFree && m.ideal;
-    if (itf.phi.type !== 'neutral' || !strict(mL) || !strict(mR)) continue;
-    const gL = grid.regionEnd[f], gR = grid.regionStart[f + 1], bL = s.blockOfNode[gL] * M, bR = s.blockOfNode[gR] * M;
-    const pass = [];
-    for (let i = 0; i < n; i++) if (itf.links[i].type === 'equilibrium' && mL.present[i] && mR.present[i]) pass.push(i);
-    if (!pass.some((i) => z[i] !== 0)) continue;
-    const RT = model.RT, vL = grid.vol[gL], vR = grid.vol[gR];
-    const conc = (m, b, i) => m.cRef[i] * Math.exp(u[b + 1 + i] - m.mu0[i] / RT - z[i] * u[b]);
-    const amount = pass.map((i) => vL * conc(mL, bL, i) + vR * conc(mR, bR, i));
-    let qOther = regions[f].fixedCharge / FARADAY; // (the left node's charge from all it doesn't share)
-    for (let i = 0; i < n; i++) if (mL.present[i] && !pass.includes(i) && z[i] !== 0) qOther += z[i] * conc(mL, bL, i);
-    // At a jump D = φ̂_R − φ̂_L: c_L/c_R = (cRef_L/cRef_R)·exp((μ°_R − μ°_L)/RT + z D), the amount fixing both.
-    const split = (D) =>
-      pass.map((i, j) => {
-        const K = (mL.cRef[i] / mR.cRef[i]) * Math.exp((mR.mu0[i] - mL.mu0[i]) / RT + z[i] * D), cR = amount[j] / (vL * K + vR);
-        return [K * cR, cR];
-      });
-    const qL = (D) => split(D).reduce((q, [cL], j) => q + z[pass[j]] * cL, qOther); // (increasing in D)
-    const D0 = u[bR] - u[bL];
-    let lo = D0 - 1, hi = D0 + 1;
-    while (qL(lo) > 0 && lo > D0 - 1e3) lo -= 2 * (hi - lo);
-    while (qL(hi) < 0 && hi < D0 + 1e3) hi += 2 * (hi - lo);
-    if (!(qL(lo) <= 0 && qL(hi) >= 0)) continue; // (nothing the face shares can balance it: leave c0)
-    for (let it = 0; it < 200 && hi - lo > 1e-13 * Math.max(1, Math.abs(D0)); it++) {
-      const m = 0.5 * (lo + hi);
-      if (qL(m) < 0) lo = m;
-      else hi = m;
-    }
-    const D = 0.5 * (lo + hi), cs = split(D);
-    const keep = Float64Array.from({ length: n }, (_, i) => (mR.present[i] ? conc(mR, bR, i) : 0)); // (the right node's, before φ̂ moves)
-    u[bR] = u[bL] + D;
-    for (let i = 0; i < n; i++) if (mR.present[i] && !pass.includes(i)) u[bR + 1 + i] = Math.log(keep[i] / mR.cRef[i]) + mR.mu0[i] / RT + z[i] * u[bR];
-    pass.forEach((i, j) => {
-      u[bL + 1 + i] = Math.log(cs[j][0] / mL.cRef[i]) + mL.mu0[i] / RT + z[i] * u[bL];
-      u[bR + 1 + i] = Math.log(cs[j][1] / mR.cRef[i]) + mR.mu0[i] / RT + z[i] * u[bR];
-    });
-  }
   // An insertion host's φ is a gauge: c0 sets only its neutral combination's level, not how that
   // splits between its ion and its electrons. Start its ion level with the same ion's beside it
   // across a face (the equilibrium a link or a transfer reaction heads for), so its electrons,
@@ -447,6 +445,69 @@ export function initFromComposition(s) {
     }
     s.termV[k] = 0.5 * (lo + hi);
   }
+  s.coldStart = true; // (until a solve or a step moves it: see equilibrateFaces)
+}
+
+/**
+ * The t = 0⁺ state at the faces between strictly neutral regions, taken by the first time step
+ * from a cold start (src/timeSteps.js) and not by a steady solve, which needs no t = 0⁺: there it
+ * was the worse start, its face nodes moved while the rest of a region stayed (a stack whose
+ * middle region started 2.2 V from its neighbour's level failed every steady solve, where the
+ * cold start converged in one).
+ */
+export function equilibrateFaces(s) {
+  const { model, n, M, u, z } = s;
+  const { regions, interfaces, materials } = model;
+  const grid = model.grid;
+  s.coldStart = false;
+  // Two strictly neutral regions meeting at a face whose links hold ions in equilibrium: where
+  // c0 leaves the two sides out of it (a different fixed charge or immobile ion on each, so
+  // c₊c₋ differs across it), the face reaches it at t = 0⁺, before anything diffuses, and a
+  // first step made to take that jump met an exactly singular pivot. Start there: the ions the
+  // face passes shared between its two nodes in equilibrium (μ̄ equal across it), each one's
+  // amount over the two nodes kept, everything else as c0 has it. The one unknown is the jump
+  // in φ̂ across it (a Donnan potential), set by neutrality on one side; the other's follows,
+  // the two nodes' charge summing to what it was, zero.
+  for (let f = 0; f < interfaces.length; f++) {
+    const itf = interfaces[f], mL = materials[regions[f].material], mR = materials[regions[f + 1].material];
+    const strict = (m) => m.epsr === 0 && !m.conductor && !m.phiFree && m.ideal;
+    if (itf.phi.type !== 'neutral' || !strict(mL) || !strict(mR)) continue;
+    const gL = grid.regionEnd[f], gR = grid.regionStart[f + 1], bL = s.blockOfNode[gL] * M, bR = s.blockOfNode[gR] * M;
+    const pass = [];
+    for (let i = 0; i < n; i++) if (itf.links[i].type === 'equilibrium' && mL.present[i] && mR.present[i]) pass.push(i);
+    if (!pass.some((i) => z[i] !== 0)) continue;
+    const RT = model.RT, vL = grid.vol[gL], vR = grid.vol[gR];
+    const conc = (m, b, i) => m.cRef[i] * Math.exp(u[b + 1 + i] - m.mu0[i] / RT - z[i] * u[b]);
+    const amount = pass.map((i) => vL * conc(mL, bL, i) + vR * conc(mR, bR, i));
+    let qOther = regions[f].fixedCharge / FARADAY; // (the left node's charge from all it doesn't share)
+    for (let i = 0; i < n; i++) if (mL.present[i] && !pass.includes(i) && z[i] !== 0) qOther += z[i] * conc(mL, bL, i);
+    // At a jump D = φ̂_R − φ̂_L: c_L/c_R = (cRef_L/cRef_R)·exp((μ°_R − μ°_L)/RT + z D), the amount fixing both.
+    const split = (D) =>
+      pass.map((i, j) => {
+        const K = (mL.cRef[i] / mR.cRef[i]) * Math.exp((mR.mu0[i] - mL.mu0[i]) / RT + z[i] * D), cR = amount[j] / (vL * K + vR);
+        return [K * cR, cR];
+      });
+    const qL = (D) => split(D).reduce((q, [cL], j) => q + z[pass[j]] * cL, qOther); // (increasing in D)
+    const D0 = u[bR] - u[bL];
+    let lo = D0 - 1, hi = D0 + 1;
+    while (qL(lo) > 0 && lo > D0 - 1e3) lo -= 2 * (hi - lo);
+    while (qL(hi) < 0 && hi < D0 + 1e3) hi += 2 * (hi - lo);
+    if (!(qL(lo) <= 0 && qL(hi) >= 0)) continue; // (nothing the face shares can balance it: leave c0)
+    for (let it = 0; it < 200 && hi - lo > 1e-13 * Math.max(1, Math.abs(D0)); it++) {
+      const m = 0.5 * (lo + hi);
+      if (qL(m) < 0) lo = m;
+      else hi = m;
+    }
+    const D = 0.5 * (lo + hi), cs = split(D);
+    const keep = Float64Array.from({ length: n }, (_, i) => (mR.present[i] ? conc(mR, bR, i) : 0)); // (the right node's, before φ̂ moves)
+    u[bR] = u[bL] + D;
+    for (let i = 0; i < n; i++) if (mR.present[i] && !pass.includes(i)) u[bR + 1 + i] = Math.log(keep[i] / mR.cRef[i]) + mR.mu0[i] / RT + z[i] * u[bR];
+    pass.forEach((i, j) => {
+      u[bL + 1 + i] = Math.log(cs[j][0] / mL.cRef[i]) + mL.mu0[i] / RT + z[i] * u[bL];
+      u[bR + 1 + i] = Math.log(cs[j][1] / mR.cRef[i]) + mR.mu0[i] / RT + z[i] * u[bR];
+    });
+  }
+  s.computeConcentrations();
 }
 
 // A non-ideal material's composition at φ̂ = ph: level-fixed species (mode 1) at their η,

package/src/steady.js

@@ -49,8 +49,14 @@
 //      (this.stepped), on a direct device with continuation not off, the same again from a cold
 //      start (initFromComposition), whose u and uLo become the stages' start (termV stays the
 //      start's: a floating terminal keeps the voltage the transient left it at).
-//   2. Continuation: generation ramped up (_generationContinuation); a terminal driven by a
-//      current, not bound (_bound), held at voltages instead (_floatingContinuation); with
+//   2. Continuation: generation ramped up (_generationContinuation); terminals behind a
+//      resistance (_resistanceContinuation): one whose current Kirchhoff doesn't give, held at
+//      voltages marched to its load line's crossing (_floatingContinuation with a line); else, or
+//      where that fails, each held (at its source voltage, or where every other terminal is
+//      driven by a current at V_src − I R, Kirchhoff's I), then the resistances put back and the
+//      steady system solved from there (and where that fails for one terminal held by
+//      Kirchhoff, its load line); a terminal driven by a current, not bound (_bound), held at
+//      voltages instead (_floatingContinuation); with
 //      canContinue, the right contact's voltage ramped to its target (_continuation): from the
 //      voltages of the last converged solve (this.solvedV), the left contact's first where it
 //      moved, else from level contacts, a cold start.
@@ -190,6 +196,7 @@ export class SteadySolves {
     this.steady = true; // (the steady system's rows; sources at the present time)
     this.steadyAt = this.time; // (which a pseudo-transient's steps don't move on)
     this.drifted = null; // (an amount no row keeps, lost by a giant step: see _steadySteps)
+    this.modelError = null; // (a statistics model's refusal, for the failure: see newton)
     // A solve that fails leaves where the state was solved, and whether it was stepped, as they
     // were (Device.solve restores the state): a floating continuation's held solves had set them,
     // and the next held solve ramped warm from a voltage the state was never at, and failed.
@@ -252,6 +259,7 @@ export class SteadySolves {
       if (q.converged) {
         this.solvedV = [this.termV[0], this.termV[1]]; // (a contact's own: driven by a current, not the current)
         this.stepped = false;
+        this.coldStart = false; // (solved: no t = 0⁺ left for a transient to start from)
       }
       return q;
     };
@@ -289,6 +297,15 @@ export class SteadySolves {
       if (g.converged) return solved(g);
       r = g;
     }
+    // A terminal behind a resistance, cold: held at its source voltage first (with that its own
+    // continuations), then the resistance put back and solved from there (a diode behind 7 Ω·m²
+    // failed cold, and converged so; round 14's fuzzer, 4 of 9 such re-solves).
+    if (allowed && this.floating.some((k) => this.terms[k].drive.kind === 'V' && this.terms[k].drive.R > 0)) {
+      restart();
+      const q = this._resistanceContinuation(opts, r);
+      if (q.converged) return solved(q);
+      r = q;
+    }
     // A terminal driven by a current (open circuit, say): hold it at a voltage instead, march the
     // voltage until the current crosses its target, and float it from there.
     if (allowed && this.floating.some((k) => this.terms[k].drive.kind === 'I' && !this._bound(k))) {
@@ -342,9 +359,10 @@ export class SteadySolves {
   // voltage instead, whose steady solves have their own continuation, the voltage marched from
   // the start's until the current crosses its target, the crossing narrowed by bisection, and
   // the terminal floated again from beside it.
-  _floatingContinuation(opts, r) {
-    const k = this.floating.find((j) => this.terms[j].drive.kind === 'I' && !this._bound(j));
-    const drive = this.terms[k].drive, target = sourceAt(drive.src, this.time);
+  // (With `line`, terminal k behind a resistance: the current its load line passes at V,
+  // (V_src − V)/R, the target, the march from the first held terminal's level.)
+  _floatingContinuation(opts, r, k = this.floating.find((j) => this.terms[j].drive.kind === 'I' && !this._bound(j)), line = null) {
+    const drive = this.terms[k].drive, target = line ? NaN : sourceAt(drive.src, this.time), want = (V) => (line ? line(V) : target);
     // Its drive put back: redrive() finds the laws again for it, with the local constraints'
     // references at zero, so they're taken from the state again (an immobile species held at 0
     // at every node: the floated solve failed, 80 steps, and the regula falsi rescued it at 6×).
@@ -363,11 +381,12 @@ export class SteadySolves {
       iterations += q.iterations ?? 0;
       history.push({ held: V, converged: q.converged });
       if (q.converged) seen.push([V, this.termI[k]]);
-      return q.converged ? this.termI[k] - target : NaN;
+      return q.converged ? this.termI[k] - want(V) : NaN;
     };
     const fail = () => ({ converged: false, steps, iterations, history });
     const seen = []; // [V, I] of each held solve that converged
-    let Va = this.termV[k], fa, Vb, fb;
+    const heldK = this.terms.findIndex((t) => t.drive.kind === 'V' && !(t.drive.R > 0));
+    let Va = line ? (heldK >= 0 ? this.termV[heldK] : 0) : this.termV[k], fa, Vb, fb;
     try {
       fa = hold(Va);
       if (!Number.isFinite(fa)) {
@@ -396,7 +415,7 @@ export class SteadySolves {
       }
       if (!Number.isFinite(fb) || (Math.sign(fb) === Math.sign(fa) && fa !== 0)) {
         // What the held voltages passed, at the two extremes reached.
-        if (seen.length > 1) {
+        if (seen.length > 1 && !line) {
           seen.sort((a, b) => a[0] - b[0]);
           this.unreached = { terminal: this.terms[k].name, target, low: seen[0], high: seen.at(-1) };
         }
@@ -423,7 +442,7 @@ export class SteadySolves {
     // one at the voltage that passes the target: found by held solves, by regula falsi
     // (Illinois) within the bracket, to 1e-10 of the target, or at open circuit of the largest
     // current the march saw (a target of 0 is never met exactly).
-    const scale = Math.max(Math.abs(target), ...seen.map(([, I]) => Math.abs(I)));
+    const scale = Math.max(line ? 0 : Math.abs(target), ...seen.map(([, I]) => Math.abs(I)));
     try {
       let side = 0;
       for (let it = 0; it < 60; it++) {
@@ -446,6 +465,70 @@ export class SteadySolves {
     }
   }
 
+  // One terminal behind a resistance: its load line's crossing by held solves. Otherwise (or where
+  // that fails), each terminal behind a resistance held at its source voltage (R taken off; at
+  // V_src − I R where Kirchhoff gives I), solved, then the resistances put back and the steady
+  // system solved from that state.
+  _resistanceContinuation(opts, r) {
+    const ks = this.floating.filter((k) => this.terms[k].drive.kind === 'V' && this.terms[k].drive.R > 0);
+    const drives = ks.map((k) => this.terms[k].drive);
+    let steps = r.steps ?? 0, iterations = r.iterations ?? 0;
+    const history = (r.history ?? []).slice();
+    // Where every other terminal is driven by a current, Kirchhoff gives the one behind R its
+    // current, and so the voltage it ends at, V_src − I R: held there, putting R back moves
+    // nothing (held at V_src, it had to slide the whole device by IR, and failed past volts).
+    const others = this.terms.every((t, j) => ks.includes(j) || t.drive.kind === 'I');
+    const at = (k) => {
+      const d = this.terms[k].drive, V = sourceAt(d.src, this.time);
+      if (!(others && ks.length === 1)) return V;
+      const I = -this.terms.reduce((t, tm, j) => (j === k ? t : t + sourceAt(tm.drive.src, this.time)), 0);
+      return V - I * d.R;
+    };
+    const start = [Float64Array.from(this.u), Float64Array.from(this.uLo), Float64Array.from(this.termV)];
+    const restore = () => {
+      this.u.set(start[0]);
+      this.uLo.set(start[1]);
+      this.termV.set(start[2]);
+      this.computeConcentrations();
+    };
+    // One terminal behind R, the rest not all driven by currents (so its current isn't known):
+    // its crossing with the load line, (V_src − V)/R, by held solves, as an open circuit's is
+    // with its target, first. Held at its source instead, the state is I R from the answer and
+    // the pseudo-transient relaxes it over R C at Newton's pace through that swing (a lit Schottky
+    // diode passing 0.9 A/m²: 0.05 s at 1 Ω·m², 10 s at 1e4, 105 s at 1e5, steps ∝ R).
+    const d = drives[0], Vs = sourceAt(d.src, this.time), line = (V) => (Vs - V) / d.R;
+    const byLine = ks.length === 1 && !others;
+    if (byLine) {
+      const q = this._floatingContinuation(opts, r, ks[0], line);
+      if (q.converged) return q;
+      restore(); // (from where this stage began, not where the failed one left it)
+      steps = q.steps ?? steps;
+      iterations = q.iterations ?? iterations;
+      history.splice(0, history.length, ...(q.history ?? []));
+    }
+    let heldOk = false;
+    try {
+      const held = ks.map(at);
+      ks.forEach((k, j) => (this.terms[k].drive = { ...this.terms[k].drive, src: { value: held[j] }, R: 0 }));
+      this.redrive();
+      const q = this._steadyFromHere(opts);
+      steps += q.steps ?? 0;
+      iterations += q.iterations ?? 0;
+      history.push({ resistancesOff: true, converged: q.converged });
+      heldOk = q.converged;
+    } finally {
+      ks.forEach((k, j) => (this.terms[k].drive = drives[j]));
+      this.redrive();
+      captureLocal(this);
+    }
+    const q = heldOk ? this._steadySteps(opts) : { converged: false, steps: 0, iterations: 0, history: [] };
+    const done = { ...q, steps: steps + q.steps, iterations: iterations + q.iterations, history: [...history, ...q.history] };
+    if (q.converged || ks.length !== 1 || byLine) return done;
+    // Where Kirchhoff's hold failed too, the load line.
+    restore();
+    return this._floatingContinuation(opts, done, ks[0], line);
+  }
+
   // Steady solves with the generation reactions' rates scaled from 1e-30 up to 1, ×100 a step
   // while they converge, smaller steps where they don't.
   _generationContinuation(opts, r) {

package/src/timeSteps.js

@@ -21,6 +21,8 @@
 // (ports' charges) }: what BDF2 and the predictor need.
 //
 // step(s, dt, opts) → newton's result (+ bdf)
+//   From a cold start (s.coldStart, outside a steady solve), the faces between strictly neutral
+//   regions first set to their t = 0⁺ equilibrium (equilibrateFaces, src/start.js).
 //   One step from s.time to tEnd = s.time + dt (or s.landing exactly, where it's within 1e-9·dt
 //   of that). Backward Euler; BDF2 when opts.method is 'bdf2', a previous step exists and the
 //   ratio ω = dt/dt_prev ≤ 2: then c* = b1·c_n − b2·c_{n−1} (b1 = (1+ω)/a0, b2 = ω²/((1+ω)a0),
@@ -85,6 +87,7 @@
 
 import { nextBreakpoint } from './device.js';
 import { SolverError } from './solver.js';
+import { equilibrateFaces } from './start.js';
 
 // Lagrange weights at x through the points s0, s1, s2.
 function lagrange3(x, s0, s1, s2) {
@@ -120,6 +123,8 @@ export function advance(s, dt, opts, depth = 0) {
  * the start-of-step values, and dt/a0 replaces dt.
  */
 export function step(s, dt, opts = {}) {
+  // A transient's first step from a cold start begins at its t = 0⁺ (see equilibrateFaces).
+  if (s.coldStart && !s.steady) equilibrateFaces(s);
   // What the step overwrites before Newton runs, for a failed one to put back: the Solution read
   // after it takes its contacts' fluxes against the start-of-step values (a host emptied by its
   // current read its contact's Li⁺ flux 8× off at the same state).
@@ -262,6 +267,7 @@ export function integrate(s, tEnd, opts = {}) {
   const sample = s._probes(opts.probes);
   const trace = { t: [], current: [], voltage: [], ...(sample ? { probes: sample.out } : {}) };
   let steps = 0, rejected = 0, iterations = 0, failed = false;
+  s.modelError = null; // (a statistics model's refusal, for the failure: see newton)
   // Already there (an animation frame with no time to add): nothing to do, and the step size
   // carried to the next call stays as it was. A time already passed, or reached again outside
   // an animation, is most likely advance(dt) read as a duration: say so.
@@ -269,7 +275,7 @@ export function integrate(s, tEnd, opts = {}) {
     const relative = tEnd < s.time || (s.time > 0 && opts.budgetMs === undefined);
     return { converged: true, done: true, steps: 0, rejected: 0, iterations: 0, trace, ...(relative ? { stopped: `advance(${tEnd}) did nothing: ${absolute}. To run for a further dt, advance(sol.time + dt)` } : {}) };
   }
-  const t0 = s.time;
+  const t0 = s.time, fromLayout = s.history.length === 0 && !s.stepped && !s.atSteady; // (c0's layout, not a solution)
   // A cold start whose floating double layers start uncharged far from the equilibrium of an ion
   // link beside them (a capacitive contact or port passing K⁺, its outside level set for the
   // charged steady state): the link closes the gap in the first instant, which can be far below
@@ -395,6 +401,12 @@ export function integrate(s, tEnd, opts = {}) {
     stopped = `${at}: the start can't be neutral in ${unbalanced.join(', ')}, strictly neutral (ε = 0): the amounts its c0 gives leave a net charge that no species held at a contact's level can balance, and a step can't move a stored amount at once. Give c0 that balances (with any fixed charge), or leave out of c0 the species a contact feeds, so that they start at its level.`;
   else if (failed && violent.length > 0)
     stopped = `${at}: a step did not converge even when shortened to ${dt.toExponential(1)} s. The start is violent: ${violent.join('; ')}. A double layer starts uncharged, and what passes beside it closes such a gap in the first instant, faster than any step can follow. For a start in equilibrium, solve() first (the steady state at the starting drives), then change what the experiment changes, then advance(). Where solve() fails from there too, hold that terminal at a voltage, solve(), then let it float (set its I: 0): it keeps the state the held one gave it.`;
+  else if (failed && s.modelError)
+    stopped = `${at}: a step did not converge even when shortened to ${dt.toExponential(1)} s, the state it reached refused by a statistics model: ${s.modelError}. The model doesn't hold there: a smaller concentration or drive, or a model for it (lattice for crowding).`;
+  else if (failed && fromLayout && steps === 0)
+    // (round 15's fuzzer: the pn template advanced from its c0, a step of 3e-24 s failing, 23 of 62
+    // plain diodes; nothing said to solve first)
+    stopped = `${at}: the first step did not converge even when shortened to ${dt.toExponential(1)} s, from the starting state, which is c0's layout rather than a solution (a junction's depletion not yet formed, say). For a transient from equilibrium, solve() first at the starting drives, then change what the experiment changes, then advance().`;
   else if (failed) stopped = `${at}: a step did not converge even when shortened to ${dt.toExponential(1)} s. Look for: a host or surface driven to its limit (emptied or filled at its surface by a current it can no longer pass); an electrode at open circuit held only by a slow reaction, with no double-layer capacitance to keep its level (give its face one: phi capacitive); a drive's jump too big for one step (ramp it); a driven current the device cannot keep passing (a diode's reverse recovery past its storage time: stop there); or a device the steady solves also find hard.`;
   else if (s.time < tEnd && steps + rejected >= maxSteps) stopped = `${at}: maxSteps (${maxSteps}) used up (${rejected} of them rejected). Call again to go on, or loosen tol.`;
   return { converged: !failed, done: s.time >= tEnd, steps, rejected, iterations, trace, ...(stopped ? { stopped } : {}) };

package/types/impedance.d.ts

@@ -4,8 +4,8 @@ export class SmallSignal {
      * gives (J + iωM)·δx + Σ B_k δV_k = rhs for the grid's rows, and (C_k + iωC′_k)·δx +
      * (∂I_k/∂V_k)·δV_k = δI_set,k for each floating terminal's circuit row, with J the steady
      * Jacobian and M the storage part (from J(dt) = J + M/dt), B_k = ∂res/∂V_k and C_k = ∂I_k/∂x.
-     * At the measured terminal, a held voltage is perturbed (rhs = −B δV) and its current read
-     * from C, or a driven current is perturbed and its voltage solved for. The other terminals
+     * At the measured terminal, its voltage is perturbed (rhs = −B δV) and its current read, held
+     * or driven by a current alike (one input impedance; see the contract). The other terminals
      * keep their drives: held ones at AC ground, driven ones at AC open circuit.
      * Z = δV/δI with I into the device (positive real part for a passive device).
      * @param {ArrayLike<number>} frequencies Hz

package/types/solver.d.ts

@@ -273,6 +273,7 @@ export class Solver {
     };
     _warmFrom(src: any): void;
     solvedV: any;
+    coldStart: any;
     _snapshot(): {
         u: Float64Array<ArrayBuffer>;
         uLo: Float64Array<ArrayBuffer>;
@@ -299,6 +300,7 @@ export class Solver {
         history: any[];
         termV: Float64Array<ArrayBuffer>;
         sourceTime: number;
+        coldStart: any;
     };
     _restore(s: any): void;
     contactDEnd: any;

package/types/start.d.ts

@@ -4,3 +4,11 @@
  * profile varies), or continued across the interface dipole if nothing there responds.
  */
 export function initFromComposition(s: any): void;
+/**
+ * The t = 0⁺ state at the faces between strictly neutral regions, taken by the first time step
+ * from a cold start (src/timeSteps.js) and not by a steady solve, which needs no t = 0⁺: there it
+ * was the worse start, its face nodes moved while the rest of a region stayed (a stack whose
+ * middle region started 2.2 V from its neighbour's level failed every steady solve, where the
+ * cold start converged in one).
+ */
+export function equilibrateFaces(s: any): void;

package/types/steady.d.ts

@@ -29,6 +29,7 @@ export class SteadySolves {
     steady: boolean;
     steadyAt: any;
     drifted: any;
+    modelError: any;
     _solveSteadyAll(opts: any): any;
     atSteady: any;
     _steadyFromHere(opts: any): any;
@@ -36,9 +37,11 @@ export class SteadySolves {
     sourceTime: any;
     solvedV: any[];
     stepped: boolean;
+    coldStart: boolean;
     dimmer: boolean;
     _bound(k: any): any;
-    _floatingContinuation(opts: any, r: any): any;
+    _floatingContinuation(opts: any, r: any, k?: any, line?: any): any;
+    _resistanceContinuation(opts: any, r: any): any;
     _generationContinuation(opts: any, r: any): {
         converged: boolean;
         steps: any;