driftlet 0.13.0 → 0.14.0

package/types/particles.d.ts

@@ -0,0 +1,42 @@
+/**
+ * A swarm of dots sampling a solution's concentrations and fluxes. Amounts are per area (a planar
+ * device's). `step(dt)` moves them on in the device's time, at the rates of the solution last
+ * given; `update(sol)` gives a new one.
+ * @param {object} sol a solution (from solve(), advance(), live(), …)
+ * @param {object} [opts]
+ * @param {string[]} [opts.species] which species (default: every species with a concentration)
+ * @param {number} [opts.dots] about how many dots per species (default 200), for the default weight
+ * @param {number|object} [opts.weight] amount per dot, mol/m²: one number for every species (so
+ *   their dots compare), or { name: weight }; default, each species' total over `dots`
+ * @param {number} [opts.cap] the most dots a cell holds on average before it's a sea (default ∞)
+ * @param {number} [opts.cells] about how many cells across the device (default 120)
+ * @param {() => number} [opts.random] a uniform random source in [0, 1) (default Math.random)
+ */
+export function particles(sol: object, { species, dots, weight, cap, cells, random }?: {
+    species?: string[];
+    dots?: number;
+    weight?: number | object;
+    cap?: number;
+    cells?: number;
+    random?: () => number;
+}): {
+    cells: {
+        x0: any;
+        x1: any;
+        region: any;
+    }[];
+    species: any;
+    weight: {};
+    sea: {};
+    dots: any[];
+    events: any[];
+    crossed: {};
+    time: number;
+    update: (next: any, { resample }?: {
+        resample?: boolean;
+    }) => /*elided*/ any;
+    step: (dt: any, { maxHops }?: {
+        maxHops?: number;
+    }) => /*elided*/ any;
+    expected: (nm: any) => Float64Array<ArrayBuffer>;
+};

package/types/solution.d.ts

@@ -9,6 +9,7 @@ export function makeSolution(solver: any, result?: {}): {
     muStd: {};
     V: {};
     Vstd: {};
+    T: any;
     time: any;
     steady: any;
     converged: any;

package/types/solver.d.ts

@@ -209,9 +209,11 @@ export class Solver {
     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): {
         rate: number;
+        forward: number;
         oneWay: number;
         Cn: number;
         Cp: number;
@@ -387,6 +389,8 @@ export class Solver {
         g: any[];
         d: any[];
     }[];
+    segmentFluxes(): Float64Array<ArrayBuffer>[];
+    faceOneWay(f: any): any;
     _smallSignalProfiles(xr: any, xi: any): {
         phi: {
             re: Float64Array<any>;