driftlet 1.2.3 → 1.3.0

package/types/regions.d.ts

@@ -0,0 +1,61 @@
+export class RegionTerms {
+    _coverages(): void;
+    computeConcentrations(): void;
+    _work(md: any): any;
+    _nodeStatistics(g: any, b: any, phiHat: any): void;
+    _statSlopes(g: any, mat: any): void;
+    _Kz(g: any, i: any): number;
+    /** zᵀKz at node g (per RT): the charge response that sets the screening length. */
+    screening(g: any): number;
+    _dlnc(g: any, i: any, w: any, d: any): void;
+    _nodeConductor(g: any, dt: any): void;
+    _portHeldAt(g: any, i: any): boolean;
+    _nodesDilute(g0: any, g1: any, dt: any): void;
+    _nodeConcentrated(g: any, dt: any): void;
+    _storage(g: any, i: any, dt: any, Kz?: number): void;
+    _chargeRows(dt: any): void;
+    _untransform(delta: any): void;
+    _bulkReactions(g: any, rxs: any): void;
+    _segmentDisplacement(s: any, bL: any, bR: any, mat: any, h: any): any;
+    _segmentsDilute(g0: any, g1: any, region: any, mat: any, vel: any): void;
+    _segmentConcentrated(s: any, bL: any, bR: any, mat: any, h: any, vel: any): void;
+    _fluxConcentrated(s: any, bL: any, bR: any, mat: any, h: any, vel: any, i: any): {
+        N: any;
+        gBcE1: any;
+        dNdd: any;
+        fL: any;
+        cR: any;
+    };
+    _segmentConductor(s: any, bL: any, bR: any, mat: any, h: any): void;
+    _segmentMixing(s: any, bL: any, bR: any, Dm: any, h: any, mat: any): void;
+    mixWork: Float64Array<any>[];
+    _mixCrowded(gL: any, gR: any, bL: any, bR: any, on: any, k0: any): void;
+    _dKslot(g: any, i: any, j: any, t: any): any;
+    _mixBase(gL: any, gR: any, bL: any, bR: any, on: any): {
+        Jl: Float64Array<ArrayBuffer>;
+        Jr: Float64Array<ArrayBuffer>;
+        dcs: Float64Array<ArrayBuffer>;
+    };
+    mixCrowd: {
+        Jl: Float64Array<ArrayBuffer>;
+        Jr: Float64Array<ArrayBuffer>;
+        dcs: Float64Array<ArrayBuffer>;
+    };
+    _Kat(g: any, i: any, j: any): any;
+    _dc(g: any, k: any, d: any): void;
+    bulkRate(rx: any, g: any): number;
+    bulkForward(rx: any, g: any): any;
+    bulkOneWay(rx: any, g: any): number;
+    _srhRate(law: any, cn: any, cp: any, a: any, xn?: number, xp?: number): {
+        rate: number;
+        forward: number;
+        oneWay: number;
+        Cn: number;
+        Cp: number;
+        Ca: number;
+        Cxn: number;
+        Cxp: number;
+    };
+    _srhDegen(gn: any, gq: any, law: any): any[];
+    _srhInto(g: any, i: any, C: any, Cx: any, d: any): void;
+}

package/types/solver.d.ts

@@ -1,3 +1,7 @@
+export function profileAt({ x, values: c }: {
+    x: any;
+    values: any;
+}, at: any): any;
 export class SolverError extends Error {
     constructor(message: any, details: any);
     details: any;
@@ -49,6 +53,8 @@ export class Solver {
     sheetSign: Int8Array<any>;
     conductorLast: Uint8Array<any>;
     K: Float64Array<ArrayBuffer>;
+    nodeDK: Uint8Array<any>;
+    dK: Float64Array<ArrayBuffer>;
     ex: Float64Array<ArrayBuffer>;
     zeta: Float64Array<any>;
     scratch: Map<any, any>;
@@ -56,10 +62,11 @@ export class Solver {
     dB: Float64Array<any>;
     jL: Float64Array<any>;
     jR: Float64Array<any>;
+    sg: Float64Array<ArrayBuffer>;
     time: number;
     lastDt: number;
     atSteady: boolean;
-    lin: DifferenceTerms;
+    lin: any;
     contactFlux: {
         left: Float64Array<any>;
         right: Float64Array<any>;
@@ -126,7 +133,7 @@ export class Solver {
     _activeSlots(): void;
     active: Uint8Array<ArrayBuffer>;
     loc: Int32Array<ArrayBuffer>;
-    sys: any;
+    sys: BlockTridiagonal;
     SINK: number;
     rix: Int32Array<ArrayBuffer>;
     fullOf: Int32Array<ArrayBuffer>;
@@ -224,162 +231,27 @@ export class Solver {
         nodeMaterial: Int32Array<any>;
         phiUndefined: Uint8Array<any>;
     };
-    _directSteady(): boolean;
     _surfaceStart(g: any): void;
     /** Amount (mol per unit area) of surface column j's species, Γ Σ v·a·θ, in the current state. */
     surfaceAmount(j: any): number;
     /** Total amount (mol per unit area) of a stretch's species in the current state. */
     amount(stretch: any): number;
     redrive(): void;
-    deltaV: Float64Array<any>;
-    stuckReactions(): any[];
+    deltaV: any;
     _drivenKey(): any;
     _refreshSources(): void;
     /** η_i (μ̄/RT) of a port's outside level for species i (its electrode's carrier: at V itself). */
     portEta(port: any, i: any): number;
     /** η_i/RT that a fixed contact link imposes (or NaN if the link isn't fixed). */
     contactEta(side: any, i: any): number;
-    /**
-     * Cold start. Each species takes its region's c0 where one is given (for a spectator, it fixes
-     * the conserved amount), else its contact's level. φ in each region is then chosen for local neutrality (node by node where a
-     * profile varies), or continued across the interface dipole if nothing there responds.
-     */
     initFromComposition(): void;
-    _portRate(port: any, rx: any, g: any): number;
-    _materialAt(mat: any, background: any, eta: any, mode: any, cFix: any, ph: any, zeta: any, cc: any): void;
-    _coverages(): void;
-    computeConcentrations(): void;
-    _work(md: any): any;
-    _nodeStatistics(g: any, b: any, phiHat: any): void;
-    _Kz(g: any, i: any): number;
-    /** zᵀKz at node g (per RT): the charge response that sets the screening length. */
-    screening(g: any): number;
-    _dlnc(g: any, i: any, w: any, d: any): void;
-    _j(rb: any, rs: any, cb: any, cs: any, v: any): void;
-    /** Assemble residual and Jacobian for a backward-Euler step of size dt. */
-    assemble(dt: any): void;
-    dtNow: any;
-    transformed: any;
-    _nodeConductor(g: any, dt: any): void;
-    _portHeldAt(g: any, i: any): boolean;
-    _nodesDilute(g0: any, g1: any, dt: any): void;
-    _nodeConcentrated(g: any, dt: any): void;
-    _storage(g: any, i: any, dt: any, Kz?: number): void;
-    _chargeRows(dt: any): void;
-    _untransform(delta: any): void;
-    _bulkReactions(g: any, rxs: any): void;
-    _segmentDisplacement(s: any, bL: any, bR: any, mat: any, h: any): void;
-    _segmentsDilute(g0: any, g1: any, region: any, mat: any, vel: any): void;
-    _face(f: any): void;
-    _gateSlot(f: any, q: any): any;
-    _gateVoltage(gt: any): number;
-    _portVoltage(k: any, g: any): number;
-    _faceVoltage(f: any): number;
-    _faceGates(f: any, bf: any, bL: any, bR: any): void;
-    _segmentConcentrated(s: any, bL: any, bR: any, mat: any, h: any, vel: any): void;
-    _fluxConcentrated(s: any, bL: any, bR: any, mat: any, h: any, vel: any, i: any): {
-        N: number;
-        E: number;
-        gBc: number;
-        dNdd: number;
-        fL: number;
-        cR: number;
-    };
-    _segmentConductor(s: any, bL: any, bR: any, mat: any, h: any): void;
-    _segmentMixing(s: any, bL: any, bR: any, Dm: any, h: any, mat: any): void;
-    mixWork: Float64Array<any>[];
-    _dc(g: any, k: any, d: any): void;
-    bulkRate(rx: any, g: any): number;
-    bulkForward(rx: any, g: any): any;
-    bulkOneWay(rx: any, g: any): number;
-    _srhRate(law: any, cn: any, cp: any, a: any, xn?: number, xp?: number, sn?: number, sp?: number): {
-        rate: number;
-        forward: number;
-        oneWay: number;
-        Cn: number;
-        Cp: number;
-        Ca: number;
-    };
-    _srhDegen(gn: any, gq: any, law: any): number[];
-    _degen(g: any, i: any): number[];
-    _faceReaction(rx: any, k: any, f: any, bf: any, bL: any, bR: any, Af: any): void;
-    _liveTerms(): any;
-    _allTerms: any;
-    _terminals(dt: any): void;
-    _circuit(k: any): void;
-    _captureRow(b: any, s: any, w: any, into: any): any;
-    _port(port: any, flux: any, k: any, dt: any, holds: any): void;
-    _portReaction(port: any, rx: any, area: any, rates: any, flux: any, k: any): void;
-    _portGates(port: any, k: any, dt: any): void;
-    _open(gated: any, x: any): number;
-    _dOpen(gated: any, q: any, p: any, x: any): number;
-    _portCapacitance(port: any, k: any, dt: any): void;
-    _surfaceStorage(port: any, dt: any): void;
-    _contact(side: any, dt: any): void;
-    _replaceRow(b: any, rs: any): void;
-    _equilibrate(): void;
-    _assembleDifference(dt: any): {
-        rest: any;
-        lin: DifferenceTerms;
-    };
-    sysRest: any;
-    diffTerms: DifferenceTerms;
-    _refine(dt: any, delta: any, deltaV: any): boolean;
-    _maxPotentialStep(delta: any, deltaV?: Float64Array<any>): number;
-    /**
-     * Newton iteration for one backward-Euler step from the current cOld.
-     * @returns {{converged: boolean, iterations: number, history: number[]}}
-     */
-    newton(dt: any, { maxIter, tol, maxStep, islands }?: {
-        maxIter?: number;
-        tol?: number;
-        maxStep?: number;
-        islands?: boolean;
-    }): {
-        converged: boolean;
-        iterations: number;
-        history: number[];
-    };
-    _kirchhoff(): number;
-    _noteConditioning(): void;
-    conditioning: {
-        digits: any;
-        x: number;
-        where: string;
-        nodes: any[];
-    };
+    newton(dt: any, opts: any): any;
     /**
      * Advance by dt, splitting the interval into halves (recursively) wherever Newton fails.
      * The end time is always t + dt; the result reports the substeps taken.
      */
     advance(dt: any, opts: any, depth?: number): any;
-    _addToState(d: any, scale: any): void;
-    /**
-     * One time step of size dt. Backward Euler by default; with `method: 'bdf2'`, variable-step
-     * BDF2 once a previous step exists (and the step ratio is at most 2, for stability). On
-     * failure the state is restored.
-     *
-     * BDF2's storage term (a0 c − (1+ω) c_n + ω²/(1+ω) c_{n−1})/dt is written in backward-Euler
-     * form (c − c*)/(dt/a0), so assembly is shared: c* and the displacement histories replace
-     * the start-of-step values, and dt/a0 replaces dt.
-     */
-    step(dt: any, opts?: {}): {
-        converged: boolean;
-        iterations: number;
-        history: number[];
-    };
-    contactDEnd: any;
-    sourceBefore: boolean;
-    solvedV: any;
-    stepped: boolean;
-    _guess(guess: any): void;
-    /**
-     * Adaptive time stepping to tEnd: variable-step BDF2 (or backward Euler), with the local error
-     * estimated against an explicit predictor through the previous states, and controlled to
-     * `tol` thermal units per step in every potential (φ̂, each η, a surface's coverages as η). The first
-     * step is checked by step doubling. Stops early when `budgetMs` of wall time is used, so an
-     * animation can call it once per frame; the step size carries over between calls.
-     */
+    step(dt: any, opts?: {}): any;
     integrate(tEnd: any, opts?: {}): {
         stopped?: string;
         converged: boolean;
@@ -394,19 +266,13 @@ export class Solver {
             voltage: any[];
         };
     };
-    landing: any;
-    _extrapolate(out: any, h: any): any;
-    _predict(pred: any, bdf: any): {
-        scale: number;
-        order: number;
-    };
     _probes(probes: any): {
         out: any;
         read: () => any;
         push: (values: any) => any;
     };
-    _errorNorm(ref: any): number;
     _warmFrom(src: any): void;
+    solvedV: any;
     _snapshot(): {
         u: Float64Array<ArrayBuffer>;
         uLo: Float64Array<ArrayBuffer>;
@@ -435,113 +301,11 @@ export class Solver {
         sourceTime: number;
     };
     _restore(s: any): void;
+    contactDEnd: any;
     passedCurrent(k: any): any;
     _terminalCurrent(): number;
-    /**
-     * Small-signal impedance about the current (steady) state, seen at one terminal. Linearising
-     * 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
-     * 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
-     */
-    impedance(frequencies: ArrayLike<number>, opts: any): {
-        f: Float64Array<ArrayBuffer>;
-        Z: {
-            re: Float64Array<any>;
-            im: Float64Array<any>;
-        };
-    };
-    allTerminals: any;
-    _impedance(frequencies: any, { profiles, terminal }?: {
-        profiles?: boolean;
-        terminal?: string;
-    }): {
-        f: Float64Array<ArrayBuffer>;
-        Z: {
-            re: Float64Array<any>;
-            im: Float64Array<any>;
-        };
-    };
-    _regionShift(yr: any, yi: any): Float64Array<any>[];
-    _regionEdgeRows(): Uint8Array<any>;
-    _currentCuts(): {
-        s: any;
-        idx: any[];
-        g: any[];
-        d: any[];
-    }[];
     segmentFluxes(): Float64Array<ArrayBuffer>[];
     faceOneWay(f: any): any;
-    _smallSignalProfiles(xr: any, xi: any): {
-        phi: {
-            re: Float64Array<any>;
-            im: Float64Array<any>;
-        };
-        mu: {};
-        c: {};
-    };
-    _assembleBookkeeping(dt: any): void;
     _accumulateBoundaryIntake(dt: any, cN: any): void;
-    slowestTime(): number;
-    fastestTime(): number;
-    /**
-     * Steady state: where a transient from the present state ends, found as the solution of the
-     * steady equations (dt = ∞, no storage term), with no slow modes to wait out, however slow the
-     * physics (e.g. exponentially scarce minority carriers). What the storage term held is held by
-     * the steady system's own rows instead (see src/laws.js): each conserved amount in place of a balance
-     * row that says nothing new, levels that carry nothing held flat, islands' summed balances.
-     * Where Newton from here fails: continuation along the drives, then the pseudo-transient ramp.
-     * The clock is not advanced, and open-system conservation bookkeeping restarts here.
-     */
-    solveSteady(opts?: {}): any;
-    unreached: {
-        terminal: any;
-        target: any;
-        low: any;
-        high: any;
-    };
-    charging: {
-        terminal: any;
-        current: any;
-        what: any[];
-    };
-    steadyAt: number;
-    _solveSteadyAll(opts: any): any;
-    _steadyFromHere(opts: any): any;
-    dimmer: boolean;
-    _bound(k: any): boolean;
-    _floatingContinuation(opts: any, r: any): any;
-    _generationContinuation(opts: any, r: any): {
-        converged: boolean;
-        steps: any;
-        iterations: any;
-        history: any;
-    };
-    _continuation(opts: any, k: any, level: any, target: any, r: any, warm: any, hold: any): any;
-    _steadySteps({ maxSteps, tol }?: {
-        maxSteps?: number;
-        tol?: number;
-    }): {
-        converged: boolean;
-        steps: number;
-        iterations: number;
-        history: ({
-            dt: number;
-            converged: boolean;
-            iterations: number;
-            maxStep?: undefined;
-        } | {
-            dt: number;
-            converged: boolean;
-            iterations: number;
-            maxStep: number;
-        })[];
-    };
-    _renormalizeSpectators(): void;
-    _diff(): Float64Array<ArrayBuffer>;
 }
-import { DifferenceTerms } from './difference.js';
+import { BlockTridiagonal } from './blockTridiagonal.js';

package/types/start.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Cold start. Each species takes its region's c0 where one is given (for a spectator, it fixes
+ * the conserved amount), else its contact's level. φ in each region is then chosen for local neutrality (node by node where a
+ * profile varies), or continued across the interface dipole if nothing there responds.
+ */
+export function initFromComposition(s: any): void;

package/types/steady.d.ts

@@ -0,0 +1,78 @@
+export class SteadySolves {
+    slowestTime(): number;
+    _usedMaterials(): any[];
+    fastestTime(): number;
+    /**
+     * Steady state: where a transient from the present state ends, found as the solution of the
+     * steady equations (dt = ∞, no storage term), with no slow transport to wait out (e.g.
+     * exponentially scarce minority carriers); but a slow reaction that alone settles a closed
+     * combination is waited out by time steps, to ~1e12 of the slowest diffusion time (invariant
+     * 5). What the storage term held is held by
+     * the steady system's own rows instead (see src/laws.js): each conserved amount in place of a balance
+     * row that says nothing new, levels that carry nothing held flat, islands' summed balances.
+     * Where Newton from here fails: continuation along the drives, then the pseudo-transient ramp.
+     * The clock is not advanced, and open-system conservation bookkeeping restarts here.
+     */
+    solveSteady(opts?: {}): any;
+    violent: any[];
+    unreached: {
+        terminal: any;
+        target: any;
+        low: any;
+        high: any;
+    };
+    charging: {
+        terminal: any;
+        current: any;
+        what: any;
+    };
+    steady: boolean;
+    steadyAt: any;
+    drifted: any;
+    _solveSteadyAll(opts: any): any;
+    atSteady: any;
+    _steadyFromHere(opts: any): any;
+    conditioning: any;
+    sourceTime: any;
+    solvedV: any[];
+    stepped: boolean;
+    dimmer: boolean;
+    _bound(k: any): any;
+    _floatingContinuation(opts: any, r: any): any;
+    _generationContinuation(opts: any, r: any): {
+        converged: boolean;
+        steps: any;
+        iterations: any;
+        history: any;
+    };
+    generationScale: number;
+    _continuation(opts: any, k: any, level: any, target: any, r: any, warm: any, hold: any): any;
+    _steadySteps({ maxSteps, tol }?: {
+        maxSteps?: number;
+        tol?: number;
+    }): {
+        converged: boolean;
+        steps: number;
+        iterations: number;
+        history: ({
+            drifted?: boolean;
+            dt: number;
+            converged: any;
+            iterations: any;
+            maxStep?: undefined;
+        } | {
+            dt: number;
+            converged: any;
+            iterations: any;
+            maxStep: number;
+        })[];
+    };
+    time: any;
+    history: any[];
+    dtNext: any;
+    _unkeptAmounts(): any;
+    _renormalizeSpectators(): void;
+    _diff(): any;
+    _directSteady(): any;
+    stuckReactions(): any[];
+}

package/types/timeSteps.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Advance by dt, splitting the interval into halves (recursively) wherever Newton fails.
+ * Converged, the end time is t + dt; failed, wherever the halves that converged got to (the
+ * substeps counted are those of the last attempt's halves).
+ */
+export function advance(s: any, dt: any, opts: any, depth?: number): any;
+/**
+ * One time step of size dt. Backward Euler by default; with `method: 'bdf2'`, variable-step
+ * BDF2 once a previous step exists (and the step ratio is at most 2, for stability). On
+ * failure the state is restored.
+ *
+ * BDF2's storage term (a0 c − (1+ω) c_n + ω²/(1+ω) c_{n−1})/dt is written in backward-Euler
+ * form (c − c*)/(dt/a0), so assembly is shared: c* and the displacement histories replace
+ * the start-of-step values, and dt/a0 replaces dt.
+ */
+export function step(s: any, dt: any, opts?: {}): any;
+/**
+ * Adaptive time stepping to tEnd: variable-step BDF2 (or backward Euler), with the local error
+ * estimated against an explicit predictor through the previous states, and controlled to
+ * `tol` thermal units per step in every potential (φ̂, each η, a surface's coverages as η). The first
+ * step is checked by step doubling. Stops early when `budgetMs` of wall time is used, so an
+ * animation can call it once per frame; the step size carries over between calls.
+ */
+export function integrate(s: any, tEnd: any, opts?: {}): {
+    stopped?: string;
+    converged: boolean;
+    done: boolean;
+    steps: number;
+    rejected: number;
+    iterations: number;
+    trace: {
+        probes?: any;
+        t: any[];
+        current: any[];
+        voltage: any[];
+    };
+};
+export function violentStart(s: any): any[];

package/types/types.d.ts

@@ -820,6 +820,12 @@ export type ImpedanceResult = {
         re: Float64Array;
         im: Float64Array;
     };
+    /**
+     * each Z's estimated error, relative to |Z| (on Re Z and Im Z alike): the current's round-off
+     * and the solves' residuals; cautious (it can exceed the true error many times). Over 1%, or over 10·|Re Z|/|Z|,
+     * a warning says so
+     */
+    relError: Float64Array;
     /**
      * per frequency, per unit excitation (volt, or A/m² in current mode)
      */