driftlet 0.10.0 → 0.11.4

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/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/solver.d.ts

@@ -54,6 +54,7 @@ export class Solver {
     time: number;
     lastDt: number;
     atSteady: boolean;
+    lin: DifferenceTerms;
     contactFlux: {
         left: Float64Array<any>;
         right: Float64Array<any>;
@@ -95,7 +96,6 @@ export class Solver {
     rxs: any;
     portArea: any;
     portRates: any;
-    strictlyNeutral: any;
     generationScale: number;
     hasGeneration: any;
     rxsIn: any;
@@ -105,6 +105,7 @@ export class Solver {
     };
     chargeNode: Uint8Array<any>;
     chargeNodes: Int32Array<ArrayBuffer>;
+    lateStorage: Uint8Array<any>;
     combining: boolean;
     bookkeeping: any;
     bookkeepingFaces: number[];
@@ -114,29 +115,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 +181,7 @@ 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;
+    transformed: any;
     _nodeConductor(g: any, dt: any): void;
     _nodesDilute(g0: any, g1: any, dt: any): void;
     _nodeConcentrated(g: any, dt: any): void;
@@ -195,31 +209,42 @@ export class Solver {
     _faceReaction(rx: any, k: any, f: any, bf: any, bL: any, bR: any, Af: any): void;
     _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;
     _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;
     };
@@ -328,6 +353,13 @@ export class Solver {
             im: Float64Array<ArrayBuffer>;
         };
     };
+    _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 +383,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 +438,4 @@ export class Solver {
     _renormalizeSpectators(): void;
     _diff(): Float64Array<ArrayBuffer>;
 }
-import { BlockTridiagonal } from './blockTridiagonal.js';
+import { DifferenceTerms } from './difference.js';