driftlet 1.2.1 → 1.2.3

package/types/lawRows.d.ts

@@ -0,0 +1,5 @@
+export function applyLaws(s: any, dt: any): void;
+export function captureLaws(s: any): void;
+export function captureLocal(s: any): void;
+export function solveBordered(s: any, rhs: any, delta: any, deltaV: any, pins: any): void;
+export function snapFlat(s: any): void;

package/types/laws.d.ts

@@ -0,0 +1,86 @@
+export function moves({ model }: {
+    model: any;
+}, st: any): boolean;
+export function still({ model }: {
+    model: any;
+}, st: any): boolean;
+export function carrierZ({ model, z }: {
+    model: any;
+    z: any;
+}, k: any): any;
+export function contactCharges({ model, nNodes, phiUndefined }: {
+    model: any;
+    nNodes: any;
+    phiUndefined: any;
+}, k: any): boolean;
+export function feeds(k: any, st: any): any;
+export function noCurrent(t: any): boolean;
+export function chargeOnly({ model, terms }: {
+    model: any;
+    terms: any;
+}, k: any): boolean;
+export function conservedMoieties(s: any, { drives, alsoCurrent, skip }?: {
+    drives?: boolean;
+    alsoCurrent?: any[];
+    skip?: any;
+}): Float64Array<any>[];
+export function findLaws(s: any): {
+    constraints: any[];
+    affinities: {
+        rx: any;
+        f: any;
+        row: any;
+        idx: Int32Array<any>;
+        w: Float64Array<any>;
+        len: number;
+        res: number;
+    }[];
+    localConstraints: {
+        parts: ({
+            i: any;
+            w: number;
+            q?: undefined;
+            k?: undefined;
+        } | {
+            q: any;
+            k: any;
+            w: number;
+            i?: undefined;
+        })[];
+        row: any;
+        nodes: any;
+        reference: Float64Array<any>;
+    }[];
+    islands: {
+        stretch: any;
+        row: any;
+        flux: any[];
+        weight: number[];
+        outside: any[];
+        idx: Int32Array<ArrayBuffer>;
+        w: Float64Array<ArrayBuffer>;
+        len: number;
+        res: number;
+    }[];
+    timeLaws: {
+        parts: {
+            stretch: number;
+            w: number;
+        }[];
+        surface: {
+            col: number;
+            w: number;
+        }[];
+        carriers: any;
+        terminals: any[];
+        circuit: any;
+        lambda: number;
+        idx: Int32Array<ArrayBuffer>;
+        w: Float64Array<ArrayBuffer>;
+        len: number;
+    }[];
+    contactLaw: boolean[];
+    carriers: any;
+    conserved: Set<any>;
+    unkept: Float64Array<any>[];
+};

package/types/solver.d.ts

@@ -138,48 +138,93 @@ export class Solver {
     _findStretches(): void;
     stretches: any[];
     stretchOf: Int32Array<ArrayBuffer>;
+    rough: number[];
     moieties: Float64Array<any>[];
     flatStretches: any[];
     _roughAmount(st: any): number;
-    _moves(st: any): boolean;
-    _still(st: any): boolean;
-    _carrierZ(k: any): number;
-    _contactCharges(k: any): boolean;
-    _feeds(k: any, st: any): any;
     _laws(): void;
     constraints: any[];
-    affinities: any[];
-    contactQ: any[];
+    affinities: {
+        rx: any;
+        f: any;
+        row: any;
+        idx: Int32Array<any>;
+        w: Float64Array<any>;
+        len: number;
+        res: number;
+    }[];
+    localConstraints: {
+        parts: ({
+            i: any;
+            w: number;
+            q?: undefined;
+            k?: undefined;
+        } | {
+            q: any;
+            k: any;
+            w: number;
+            i?: undefined;
+        })[];
+        row: any;
+        nodes: any;
+        reference: Float64Array<any>;
+    }[];
+    islands: {
+        stretch: any;
+        row: any;
+        flux: any[];
+        weight: number[];
+        outside: any[];
+        idx: Int32Array<ArrayBuffer>;
+        w: Float64Array<ArrayBuffer>;
+        len: number;
+        res: number;
+    }[];
+    timeLaws: {
+        parts: {
+            stretch: number;
+            w: number;
+        }[];
+        surface: {
+            col: number;
+            w: number;
+        }[];
+        carriers: any;
+        terminals: any[];
+        circuit: any;
+        lambda: number;
+        idx: Int32Array<ArrayBuffer>;
+        w: Float64Array<ArrayBuffer>;
+        len: number;
+    }[];
     contactLaw: boolean[];
-    localConstraints: any[];
-    islands: any[];
+    carriers: any;
+    unkept: Float64Array<any>[];
+    contactQ: any[];
     pinnedIslands: any[];
     islandsOn: boolean;
     pins: any[];
-    timeLaws: any[];
-    carriers: any;
-    _captureLaws(): void;
-    _captureLocal(): void;
-    _applyIslands(): any[];
-    islandRow: Float64Array<any>;
-    _rowInto(o: any, add: any): void;
-    linRow: Float64Array<any>;
-    _sites(g: any): number;
-    _applyLocalConstraints(): void;
-    _conservedMoieties(drives?: boolean, alsoCurrent?: any[], skip?: any): Float64Array<any>[];
-    _directSteady(): boolean;
-    _applyConstraints(): void;
-    _lawAmount(cs: any): {
-        amount: number;
-        reference: number;
-        dV: any;
-        gross: number;
+    _structure(): {
+        model: any;
+        n: any;
+        M: any;
+        z: Int32Array<ArrayBuffer>;
+        nNodes: any;
+        stretches: any[];
+        stretchOf: Int32Array<ArrayBuffer>;
+        flatStretches: any[];
+        rough: number[];
+        surfCols: any;
+        surfColOf: any;
+        terms: any;
+        floating: any;
+        blockOfNode: Int32Array<any>;
+        blockOfFace: Int32Array<ArrayBuffer>;
+        rxsIn: any;
+        nodeMaterial: Int32Array<any>;
+        phiUndefined: Uint8Array<any>;
     };
-    _lawStart(cs: any): number;
-    _circuitLaws(dt: any): void;
-    _solveBordered(rhs: any, delta: any, deltaV: any, pins: any): void;
-    dWork: Float64Array<any>;
-    borderCols: 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;
@@ -189,7 +234,6 @@ export class Solver {
     deltaV: Float64Array<any>;
     stuckReactions(): any[];
     _drivenKey(): any;
-    _noCurrent(t: any): boolean;
     _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;
@@ -272,14 +316,6 @@ export class Solver {
     _portCapacitance(port: any, k: any, dt: any): void;
     _surfaceStorage(port: any, dt: any): void;
     _contact(side: any, dt: any): void;
-    _flatLevel(st: any): {
-        k: number;
-        hi: number;
-        lo: number;
-    };
-    _snapFlat(): void;
-    _flatRows(): void;
-    _applyAffinities(): void;
     _replaceRow(b: any, rs: any): void;
     _equilibrate(): void;
     _assembleDifference(dt: any): {
@@ -456,7 +492,7 @@ export class Solver {
      * 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 _laws): each conserved amount in place of a balance
+     * 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.
@@ -478,7 +514,6 @@ export class Solver {
     _steadyFromHere(opts: any): any;
     dimmer: boolean;
     _bound(k: any): boolean;
-    _chargeOnly(k: any): boolean;
     _floatingContinuation(opts: any, r: any): any;
     _generationContinuation(opts: any, r: any): {
         converged: boolean;