driftlet 0.11.4 → 0.13.0

package/src/stack.js

@@ -87,16 +87,18 @@ export function ohmic(d = 0, carriers = ['e-', 'h+']) {
 }
 
 /**
- * A bath: a neutral composition `c` (mol/m³) held at the contact, its levels referred to the
- * charged `reference` species (the ion a reference electrode would sense, e.g. Cl⁻ for
- * Ag/AgCl), which is the terminal.
+ * A bath: a neutral composition `c` (mol/m³) held at the contact. With a `reference`, the charged
+ * species a reference electrode would sense (Cl⁻ for Ag/AgCl), its levels are referred to that
+ * species, which is the terminal. Without one, `bath(c, drive)`, the terminal voltage is the
+ * bath's φ: an ideal salt bridge, the convention of membrane potentials.
  * @param {Record<string, number>} c
- * @param {string} reference
+ * @param {string | number | object} [reference] the reference species, or the drive
  * @param {number | object} [drive]
  * @param {{ offset?: number }} [opts] where the reference species sits relative to the terminal
  *   voltage, V_ref = V + offset (V)
  */
 export function bath(c, reference, d = 0, { offset } = {}) {
+  if (typeof reference !== 'string') return { ...drive(reference ?? 0, 'bath'), bath: { c: { ...c } } };
   return { ...drive(d, 'bath'), bath: { c: { ...c }, reference, ...(offset === undefined ? {} : { offset }) } };
 }
 

package/src/types.js

@@ -114,7 +114,8 @@
  * @typedef {'blocked' | 'equilibrium'
  *   | { type: 'equilibrium', offset?: number, mu?: number }
  *   | { type: 'conductance', G: number, offset?: number }
- *   | { type: 'exchange', k: number, mu: number }} ContactSpeciesLink
+ *   | { type: 'exchange', k: number, mu: number }
+ *   | { type: 'velocity', v: number, offset?: number, mu?: number }} ContactSpeciesLink
  */
 /**
  * 'bulk': the end node is plain bulk (locally neutral, no double layer); 'neutral': no charge at

package/types/channels.d.ts

@@ -0,0 +1,50 @@
+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.
+ *
+ * Or with `linear: true`, Hodgkin and Huxley's own linear channels on the face: conductance links,
+ * G = g, gated the same, whose currents are g(V − E) with E each ion's Nernst level at the
+ * concentrations on either side (so `inside`, `outside` and `at` aren't needed).
+ *
+ * Or, given `area` (membrane per volume of the region, 2/a for an axon of radius a), for a membrane
+ * port along a region: links that are their linear conductances, G = g × area per volume, gated the
+ * same, each ion's reversal potential following from the port's bath and the concentrations inside
+ * (so `inside`, `outside` and `at` aren't needed).
+ * @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 }, linear?: boolean, area?: number }} 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, linear, area }?: {
+    inside: object;
+    outside: object;
+    T?: number;
+    g?: {
+        Na?: number;
+        K?: number;
+        leak?: number;
+    };
+    leak?: string;
+    leakZ?: number;
+    at?: number;
+    names?: {
+        Na?: string;
+        K?: string;
+    };
+    linear?: boolean;
+    area?: number;
+}): {
+    gates: object;
+    species: object;
+};

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>;
@@ -181,6 +186,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;
+    dtNow: any;
     transformed: any;
     _nodeConductor(g: any, dt: any): void;
     _nodesDilute(g0: any, g1: any, dt: any): void;
@@ -192,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;
@@ -207,11 +218,16 @@ 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): 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;
@@ -278,6 +294,7 @@ export class Solver {
      * animation can call it once per frame; the step size carries over between calls.
      */
     integrate(tEnd: any, opts?: {}): {
+        stopped?: string;
         converged: boolean;
         done: boolean;
         steps: number;
@@ -291,7 +308,7 @@ export class Solver {
         };
     };
     landing: any;
-    _extrapolate(out: any, t: any): any;
+    _extrapolate(out: any, h: any): any;
     _predict(pred: any, bdf: any): {
         scale: number;
         order: number;
@@ -310,6 +327,7 @@ export class Solver {
         cOld: Float64Array<ArrayBuffer>;
         thOld: Float64Array<ArrayBuffer>;
         th0Old: Float64Array<ArrayBuffer>;
+        gateOld: Float64Array<ArrayBuffer>;
         time: number;
         lastDt: number;
         atSteady: boolean;
@@ -343,19 +361,28 @@ 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(): {
+        s: any;
         idx: any[];
         g: any[];
         d: any[];
@@ -399,7 +426,7 @@ export class Solver {
         iterations: any;
         history: any;
     };
-    _continuation(opts: any, level: any, target: any, r: any, warm: any): any;
+    _continuation(opts: any, k: any, level: any, target: any, r: any, warm: any, hold: any): any;
     _solveSteady(opts?: {}): {
         converged: boolean;
         steps: number;

package/types/stack.d.ts

@@ -31,16 +31,17 @@ export function drive(d: any, path: any): any;
  */
 export function ohmic(d?: number, carriers?: string[]): any;
 /**
- * A bath: a neutral composition `c` (mol/m³) held at the contact, its levels referred to the
- * charged `reference` species (the ion a reference electrode would sense, e.g. Cl⁻ for
- * Ag/AgCl), which is the terminal.
+ * A bath: a neutral composition `c` (mol/m³) held at the contact. With a `reference`, the charged
+ * species a reference electrode would sense (Cl⁻ for Ag/AgCl), its levels are referred to that
+ * species, which is the terminal. Without one, `bath(c, drive)`, the terminal voltage is the
+ * bath's φ: an ideal salt bridge, the convention of membrane potentials.
  * @param {Record<string, number>} c
- * @param {string} reference
+ * @param {string | number | object} [reference] the reference species, or the drive
  * @param {number | object} [drive]
  * @param {{ offset?: number }} [opts] where the reference species sits relative to the terminal
  *   voltage, V_ref = V + offset (V)
  */
-export function bath(c: Record<string, number>, reference: string, d?: number, { offset }?: {
+export function bath(c: Record<string, number>, reference?: string | number | object, d?: number, { offset }?: {
     offset?: number;
 }): any;
 /**

package/types/types.d.ts

@@ -264,6 +264,11 @@ export type ContactSpeciesLink = "blocked" | "equilibrium" | {
     type: "exchange";
     k: number;
     mu: number;
+} | {
+    type: "velocity";
+    v: number;
+    offset?: number;
+    mu?: number;
 };
 /**
  * 'bulk': the end node is plain bulk (locally neutral, no double layer); 'neutral': no charge at