driftlet 0.10.0 → 0.12.0

package/types/blockTridiagonal.d.ts

@@ -31,11 +31,19 @@ export class BlockTridiagonal {
     minPivotRatio: number;
     /** The block found exactly singular by the last factor(), or −1. */
     singularBlock: number;
+    /**
+     * Static pivoting: an exactly zero pivot (all its candidates cancelled to nothing) is
+     * replaced by 1e-15 of its block's largest entry rather than thrown on, for a caller that
+     * refines its solves (and counted in `perturbedPivots`).
+     */
+    staticPivots: boolean;
+    /** How many pivots the last factor() replaced. */
+    perturbedPivots: number;
     /** Zero all of A, B, C (ready for fresh assembly). */
     clear(): void;
     /**
      * Factorise the current A, B, C. A, B, C are left untouched.
-     * Throws if a diagonal block is exactly singular.
+     * Throws if a diagonal block is exactly singular (unless `staticPivots`).
      */
     factor(): void;
     /**

package/types/channels.d.ts

@@ -0,0 +1,39 @@
+export function ghkCurrent(z: any, inside: any, outside: any, V: any, T: any): number;
+/**
+ * Hodgkin and Huxley's squid-axon channels, for a membrane face with the outside on its left
+ * (so the gates' voltage, φ_right − φ_left, is the membrane potential): the face's `gates`, and
+ * `species` links for Na⁺ (P·m³h), K⁺ (P·n⁴) and the leak (ungated), to spread into the face
+ * beside its φ law, `{ phi: { type: 'capacitive', C: 0.01 }, ...hh }`, adding links (or blocks)
+ * for any other species.
+ *
+ * The currents are GHK's, which rectify, so a permeability matches a conductance at one voltage
+ * only: each is the one whose chord conductance at `at` (rest, −65 mV) is Hodgkin and Huxley's
+ * (`g`: 120, 36 and 0.3 mS/cm²), at the concentrations given. The leak is carried by one ion
+ * (`leak`, of charge `leakZ`: Cl⁻ by default, whose Nernst level in squid is near their leak
+ * reversal, −54 mV). The
+ * rates are theirs at 6.3 °C, scaled to `T` by Q₁₀ = 3.
+ * @param {{ inside: object, outside: object, T?: number, g?: { Na?: number, K?: number, leak?: number },
+ *   leak?: string, leakZ?: number, at?: number, names?: { Na?: string, K?: string } }} opts concentrations in
+ *   mol/m³ by species name, K, S/m², V
+ * @returns {{ gates: object, species: object }}
+ */
+export function hodgkinHuxley({ inside, outside, T, g, leak, leakZ, at, names }?: {
+    inside: object;
+    outside: object;
+    T?: number;
+    g?: {
+        Na?: number;
+        K?: number;
+        leak?: number;
+    };
+    leak?: string;
+    leakZ?: number;
+    at?: number;
+    names?: {
+        Na?: string;
+        K?: string;
+    };
+}): {
+    gates: object;
+    species: object;
+};

package/types/difference.d.ts

@@ -0,0 +1,30 @@
+export class DifferenceTerms {
+    constructor(N: any, nodes: any, segments: any);
+    N: any;
+    dead: Uint8Array<any>;
+    nI: Int32Array<any>;
+    nP: Int32Array<any>;
+    nZ: Float64Array<any>;
+    nMass: Float64Array<any>;
+    nCharge: Float64Array<any>;
+    sI: Int32Array<ArrayBuffer>;
+    sZ: Float64Array<any>;
+    sC: Float64Array<ArrayBuffer>;
+    dI: Int32Array<ArrayBuffer>;
+    dK: Float64Array<any>;
+    combos: any[];
+    t: Float64Array<any>;
+    x: Float64Array<any>;
+    reset(rate?: number): void;
+    rate: number;
+    nn: number;
+    ns: number;
+    nd: number;
+    node(i: any, p: any, z: any, mass: any, charge: any): void;
+    segment(iL: any, iR: any, pL: any, pR: any, z: any, a: any, b: any, d: any): void;
+    displacement(pL: any, pR: any, k: any): void;
+    kill(row: any): void;
+    combine(rk: any, ri: any, w: any): void;
+    capture(row: any, w: any, mass: any, into: any): void;
+    apply(v: any, out: any, steady?: number, mass?: number): any;
+}

package/types/index.d.ts

@@ -14,7 +14,8 @@ export class Device {
     get grid(): any;
     /**
      * Change part of the definition (deep-merged). A contact given V or I drops the other, so
-     * `{ contacts: { right: { I: 0 } } }` switches it to open circuit. A change to the terminals'
+     * `{ contacts: { right: { I: 0 } } }` switches it to open circuit. Ports are patched by name,
+     * `{ ports: { gate: { V: 0.2 } } }` (an array replaces them all). A change to the terminals'
      * drives alone (V, I, R) is applied in place, cheaply. Otherwise the device is rebuilt, keeping the current state as
      * the warm start when the grid and species are unchanged (else restarting from the regions' c0).
      * @param {object} patch a partial device definition, merged into the current one

package/types/kit.d.ts

@@ -61,6 +61,7 @@ export { build, combine, layer, ohmic, bath } from "./stack.js";
 export { parseEquation, stoichiometry, half, SHE, level } from "./equation.js";
 export { traces, speciesRole, typeset } from "./traces.js";
 export { pulse, square, triangle, ramp, injector, recombination, photogeneration } from "./sources.js";
+export { hodgkinHuxley, ghkCurrent } from "./channels.js";
 export { describe, unitWarnings } from "./describe.js";
 export { henderson, planck } from "./junction.js";
 export { perovskiteCell, PEROVSKITE_SCANS, hysteresis } from "./devices.js";

package/types/recorder.d.ts

@@ -4,17 +4,21 @@
  * neither, at the end of each `advance()` call. The trace (`t`, `current`, `voltage`, and
  * `probes` if given) runs from the start through every accepted step of every call.
  * @param {import('./index.js').Device} device
- * @param {{ every?: number, times?: number[], probes?: { x: number, species?: string, quantity?: 'c' | 'V' | 'phi', region?: string | number }[] }} [opts]
+ * @param {{ every?: number, times?: number[], probes?: ({ x: number, species?: string, quantity?: 'c' | 'V' | 'phi', region?: string | number } | { interface: number, species?: string, gate?: string })[] }} [opts]
  */
 export function recorder(device: import("./index.js").Device, opts?: {
     every?: number;
     times?: number[];
-    probes?: {
+    probes?: ({
         x: number;
         species?: string;
         quantity?: "c" | "V" | "phi";
         region?: string | number;
-    }[];
+    } | {
+        interface: number;
+        species?: string;
+        gate?: string;
+    })[];
 }): {
     advance: (tEnd: number, aopts?: object) => import("./types.js").Solution;
     frame: (t: number) => import("./types.js").Solution;

package/types/solver.d.ts

@@ -23,6 +23,11 @@ export class Solver {
     thOld: Float64Array<ArrayBuffer>;
     th0: Float64Array<any>;
     th0Old: Float64Array<any>;
+    gatePort: Int32Array<any>;
+    gateList: any[];
+    gateOld: Float64Array<ArrayBuffer>;
+    gateIndex: Int32Array<ArrayBuffer>;
+    portGateIndex: any;
     present: Uint8Array<ArrayBuffer>;
     cRef: Float64Array<ArrayBuffer>;
     mu0hat: Float64Array<ArrayBuffer>;
@@ -54,6 +59,7 @@ export class Solver {
     time: number;
     lastDt: number;
     atSteady: boolean;
+    lin: DifferenceTerms;
     contactFlux: {
         left: Float64Array<any>;
         right: Float64Array<any>;
@@ -95,7 +101,6 @@ export class Solver {
     rxs: any;
     portArea: any;
     portRates: any;
-    strictlyNeutral: any;
     generationScale: number;
     hasGeneration: any;
     rxsIn: any;
@@ -105,6 +110,7 @@ export class Solver {
     };
     chargeNode: Uint8Array<any>;
     chargeNodes: Int32Array<ArrayBuffer>;
+    lateStorage: Uint8Array<any>;
     combining: boolean;
     bookkeeping: any;
     bookkeepingFaces: number[];
@@ -114,29 +120,42 @@ export class Solver {
     _activeSlots(): void;
     active: Uint8Array<ArrayBuffer>;
     loc: Int32Array<ArrayBuffer>;
-    sys: BlockTridiagonal;
+    sys: any;
     SINK: number;
     rix: Int32Array<ArrayBuffer>;
     fullOf: Int32Array<ArrayBuffer>;
     res: Float64Array<ArrayBuffer>;
     delta: Float64Array<ArrayBuffer>;
+    rowScale: Float64Array<ArrayBuffer>;
     _factor(): void;
     _solveLinear(rhs: any, delta: any): void;
     _findStretches(): void;
     stretches: any[];
     stretchOf: Int32Array<ArrayBuffer>;
     moieties: Float64Array<any>[];
+    flatStretches: any[];
+    levelStretches: any[];
+    flattening: boolean;
     constraints: any[];
     localConstraints: any[];
+    islands: any[];
+    pinnedIslands: any[];
+    islandsOn: boolean;
+    pins: any[];
     constrained: boolean;
     _captureLocal(): void;
+    _applyIslands(): any[];
+    islandRow: Float64Array<any>;
+    _rowInto(o: any, add: any): void;
+    linRow: Float64Array<any>;
     _applyLocalConstraints(): void;
     _conservedMoieties(): Float64Array<any>[];
     _directSteady(): boolean;
     _applyConstraints(): void;
     _solveBordered(rhs: any, delta: any, deltaV: any, pins: any): void;
-    dWork: Float64Array<ArrayBuffer>;
+    dWork: Float64Array<any>;
     borderCols: any[];
+    _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. */
@@ -167,7 +186,8 @@ export class Solver {
     _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;
-    transformed: boolean;
+    dtNow: any;
+    transformed: any;
     _nodeConductor(g: any, dt: any): void;
     _nodesDilute(g0: any, g1: any, dt: any): void;
     _nodeConcentrated(g: any, dt: any): void;
@@ -178,6 +198,11 @@ export class Solver {
     _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;
     _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;
@@ -193,33 +218,49 @@ export class Solver {
         Ca: 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): number;
+    _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;
+    _flatRows(): void;
+    _levelRows(): 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 }?: {
+    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: number;
+        digits: any;
         x: number;
         where: string;
     };
@@ -285,6 +326,7 @@ export class Solver {
         cOld: Float64Array<ArrayBuffer>;
         thOld: Float64Array<ArrayBuffer>;
         th0Old: Float64Array<ArrayBuffer>;
+        gateOld: Float64Array<ArrayBuffer>;
         time: number;
         lastDt: number;
         atSteady: boolean;
@@ -318,16 +360,31 @@ export class Solver {
      * Z = δV/δI with I into the device (positive real part for a passive device).
      * @param {ArrayLike<number>} frequencies Hz
      */
-    impedance(frequencies: ArrayLike<number>, { profiles, terminal }?: {
+    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<ArrayBuffer>;
-            im: Float64Array<ArrayBuffer>;
+            re: Float64Array<any>;
+            im: Float64Array<any>;
         };
     };
+    _regionShift(yr: any, yi: any): Float64Array<any>[];
+    _regionEdgeRows(): Uint8Array<any>;
+    _currentCuts(): {
+        idx: any[];
+        g: any[];
+        d: any[];
+    }[];
     _smallSignalProfiles(xr: any, xi: any): {
         phi: {
             re: Float64Array<any>;
@@ -351,7 +408,16 @@ export class Solver {
      * The clock is not advanced, and open-system conservation bookkeeping restarts here.
      */
     solveSteady(opts?: {}): any;
+    unreached: {
+        terminal: any;
+        target: any;
+        low: any;
+        high: any;
+    };
+    _solveSteadyAll(opts: any): any;
     _steadyFromHere(opts: any): any;
+    dimmer: boolean;
+    _floatingContinuation(opts: any, r: any): any;
     _generationContinuation(opts: any, r: any): {
         converged: boolean;
         steps: any;
@@ -397,4 +463,4 @@ export class Solver {
     _renormalizeSpectators(): void;
     _diff(): Float64Array<ArrayBuffer>;
 }
-import { BlockTridiagonal } from './blockTridiagonal.js';
+import { DifferenceTerms } from './difference.js';