@sdeverywhere/runtime 0.2.5 → 0.2.7

package/README.md

@@ -52,7 +52,7 @@ import loadGeneratedModel from './sde-prep/generated-model.js'
 ### 2. Initialize a `ModelRunner`
 
 The next step is to create a `ModelRunner` instance, which simplifies
-the process of running a `WasmModel` with a given set of inputs and
+the process of running a generated model with a given set of inputs and
 parsing the outputs.
 The `ModelRunner` produces an `Outputs` instance that provides easy
 access to time series data for each output variable in the model.

package/dist/index.cjs

@@ -58,6 +58,7 @@ __export(src_exports, {
   MockWasmModule: () => MockWasmModule,
   ModelListing: () => ModelListing,
   ModelScheduler: () => ModelScheduler,
+  MultiContextModelScheduler: () => MultiContextModelScheduler,
   Outputs: () => Outputs,
   ReferencedRunModelParams: () => ReferencedRunModelParams,
   Series: () => Series,
@@ -251,7 +252,7 @@ function encodeVarIndices(varSpecs, indicesArray) {
   }
 }
 function getEncodedLookupBufferLengths(lookupDefs) {
-  var _a;
+  var _a, _b;
   let lookupIndicesLength = 1;
   let lookupsLength = 0;
   for (const lookupDef of lookupDefs) {
@@ -263,7 +264,7 @@ function getEncodedLookupBufferLengths(lookupDefs) {
     const subCount = ((_a = varSpec.subscriptIndices) == null ? void 0 : _a.length) || 0;
     lookupIndicesLength += subCount;
     lookupIndicesLength += 2;
-    lookupsLength += lookupDef.points.length;
+    lookupsLength += ((_b = lookupDef.points) == null ? void 0 : _b.length) || 0;
   }
   return {
     lookupIndicesLength,
@@ -283,10 +284,15 @@ function encodeLookups(lookupDefs, lookupIndicesArray, lookupsArray) {
     for (let i = 0; i < subCount; i++) {
       lookupIndicesArray[li++] = subs[i];
     }
-    lookupIndicesArray[li++] = lookupDataOffset;
-    lookupIndicesArray[li++] = lookupDef.points.length;
-    lookupsArray == null ? void 0 : lookupsArray.set(lookupDef.points, lookupDataOffset);
-    lookupDataOffset += lookupDef.points.length;
+    if (lookupDef.points !== void 0) {
+      lookupIndicesArray[li++] = lookupDataOffset;
+      lookupIndicesArray[li++] = lookupDef.points.length;
+      lookupsArray == null ? void 0 : lookupsArray.set(lookupDef.points, lookupDataOffset);
+      lookupDataOffset += lookupDef.points.length;
+    } else {
+      lookupIndicesArray[li++] = -1;
+      lookupIndicesArray[li++] = 0;
+    }
   }
 }
 function decodeLookups(lookupIndicesArray, lookupsArray) {
@@ -307,10 +313,14 @@ function decodeLookups(lookupIndicesArray, lookupsArray) {
       subscriptIndices
     };
     let points;
-    if (lookupsArray) {
-      points = lookupsArray.slice(lookupDataOffset, lookupDataOffset + lookupDataLength);
+    if (lookupDataOffset >= 0) {
+      if (lookupsArray) {
+        points = lookupsArray.slice(lookupDataOffset, lookupDataOffset + lookupDataLength);
+      } else {
+        points = new Float64Array(0);
+      }
     } else {
-      points = new Float64Array(0);
+      points = void 0;
     }
     lookupDefs.push({
       varRef: {
@@ -324,11 +334,14 @@ function decodeLookups(lookupIndicesArray, lookupsArray) {
 
 // src/_shared/lookup-def.ts
 function createLookupDef(varRef, points) {
-  const flatPoints = new Float64Array(points.length * 2);
-  let i = 0;
-  for (const p of points) {
-    flatPoints[i++] = p.x;
-    flatPoints[i++] = p.y;
+  let flatPoints;
+  if (points) {
+    flatPoints = new Float64Array(points.length * 2);
+    let i = 0;
+    for (const p of points) {
+      flatPoints[i++] = p.x;
+      flatPoints[i++] = p.y;
+    }
   }
   return {
     varRef,
@@ -884,18 +897,59 @@ var _NA_ = -Number.MAX_VALUE;
 // src/js-model/js-model-lookup.ts
 var JsModelLookup = class {
   /**
-   * @param n The number of (x,y) pairs in the lookup.
+   * @param size The number of (x,y) pairs in the lookup.
    * @param data The lookup data, as (x,y) pairs.  The length of the array must be
    * >= 2*n.  Note that the data will be stored by reference, so if there is a chance
    * that the array will be reused or modified by other code, be sure to pass in a
    * copy of the array.
    */
-  constructor(n, data) {
-    this.n = n;
-    this.data = data;
-    if (data.length < n * 2) {
-      throw new Error(`Lookup data array length must be >= 2*size (length=${data.length} size=${n}`);
+  constructor(size, data) {
+    if (data && data.length < size * 2) {
+      throw new Error(`Lookup data array length must be >= 2*size (length=${data.length} size=${size}`);
+    }
+    this.originalData = data;
+    this.originalSize = size;
+    this.dynamicData = void 0;
+    this.dynamicSize = 0;
+    this.activeData = this.originalData;
+    this.activeSize = this.originalSize;
+    this.lastInput = Number.MAX_VALUE;
+    this.lastHitIndex = 0;
+  }
+  /**
+   * Set new data for this lookup instance, or restore the original data.
+   *
+   * If `data` is undefined, the original data that was supplied to the constructor will
+   * be restored as the "active" data.  Otherwise, `data` will be copied to an internal
+   * data buffer, which will be the "active" data.  If `size` is greater than the size
+   * passed to previous calls, the internal data buffer will be grown as needed.
+   *
+   * @param size The number of (x,y) pairs in the lookup.
+   * @param data The lookup data, as (x,y) pairs.  The length of the array must be
+   * >= 2*n.  Note that the data will be copied into an internal data buffer, so it
+   * is not necessary to defensively copy data before calling this method.
+   */
+  setData(size, data) {
+    if (data) {
+      if (data.length < size * 2) {
+        throw new Error(`Lookup data array length must be >= 2*size (length=${data.length} size=${size}`);
+      }
+      const dataLengthInElems = size * 2;
+      if (this.dynamicData === void 0 || dataLengthInElems > this.dynamicData.length) {
+        this.dynamicData = new Float64Array(dataLengthInElems);
+      }
+      this.dynamicSize = size;
+      if (size > 0) {
+        const subarray = data.subarray(0, dataLengthInElems);
+        this.dynamicData.set(subarray);
+      }
+      this.activeData = this.dynamicData;
+      this.activeSize = this.dynamicSize;
+    } else {
+      this.activeData = this.originalData;
+      this.activeSize = this.originalSize;
     }
+    this.invertedData = void 0;
     this.lastInput = Number.MAX_VALUE;
     this.lastHitIndex = 0;
   }
@@ -904,8 +958,8 @@ var JsModelLookup = class {
   }
   getValueForY(y) {
     if (this.invertedData === void 0) {
-      const numValues = this.n * 2;
-      const normalData = this.data;
+      const numValues = this.activeSize * 2;
+      const normalData = this.activeData;
       const invertedData = Array(numValues);
       for (let i = 0; i < numValues; i += 2) {
         invertedData[i] = normalData[i + 1];
@@ -920,11 +974,11 @@ var JsModelLookup = class {
    * NOTE: The x values are assumed to be monotonically increasing.
    */
   getValue(input, useInvertedData, mode) {
-    if (this.n === 0) {
+    if (this.activeSize === 0) {
       return _NA_;
     }
-    const data = useInvertedData ? this.invertedData : this.data;
-    const max = this.n * 2;
+    const data = useInvertedData ? this.invertedData : this.activeData;
+    const max = this.activeSize * 2;
     const useCachedValues = !useInvertedData;
     let startIndex;
     if (useCachedValues && input >= this.lastInput) {
@@ -983,10 +1037,10 @@ var JsModelLookup = class {
    * no points) or if the provided time is earlier than the first data point.
    */
   getValueForGameTime(time, defaultValue) {
-    if (this.n <= 0) {
+    if (this.activeSize <= 0) {
       return defaultValue;
     }
-    const x0 = this.data[0];
+    const x0 = this.activeData[0];
     if (time < x0) {
       return defaultValue;
     }
@@ -1001,33 +1055,34 @@ var JsModelLookup = class {
    * lookup behavior, so we implement it as a separate method here.
    */
   getValueBetweenTimes(input, mode) {
-    if (this.n === 0) {
+    if (this.activeSize === 0) {
       return _NA_;
     }
-    const max = this.n * 2;
+    const data = this.activeData;
+    const max = this.activeSize * 2;
     switch (mode) {
       case "forward": {
         input = Math.floor(input);
         for (let xi = 0; xi < max; xi += 2) {
-          const x = this.data[xi];
+          const x = data[xi];
           if (x >= input) {
-            return this.data[xi + 1];
+            return data[xi + 1];
           }
         }
-        return this.data[max - 1];
+        return data[max - 1];
       }
       case "backward": {
         input = Math.floor(input);
         for (let xi = 2; xi < max; xi += 2) {
-          const x = this.data[xi];
+          const x = data[xi];
           if (x >= input) {
-            return this.data[xi - 1];
+            return data[xi - 1];
           }
         }
         if (max >= 4) {
-          return this.data[max - 3];
+          return data[max - 3];
         } else {
-          return this.data[1];
+          return data[1];
         }
       }
       case "interpolate":
@@ -1039,17 +1094,17 @@ var JsModelLookup = class {
           throw new Error(msg);
         }
         for (let xi = 2; xi < max; xi += 2) {
-          const x = this.data[xi];
+          const x = data[xi];
           if (x >= input) {
-            const last_x = this.data[xi - 2];
-            const last_y = this.data[xi - 1];
-            const y = this.data[xi + 1];
+            const last_x = data[xi - 2];
+            const last_y = data[xi - 1];
+            const y = data[xi + 1];
             const dx = x - last_x;
             const dy = y - last_y;
             return last_y + dy / dx * (input - last_x);
           }
         }
-        return this.data[max - 1];
+        return data[max - 1];
       }
     }
   }
@@ -1500,7 +1555,8 @@ var MockJsModel = class {
     if (varId === void 0) {
       throw new Error(`No lookup variable found for spec ${varSpec}`);
     }
-    this.lookups.set(varId, new JsModelLookup(points.length / 2, points));
+    const numPoints = points ? points.length / 2 : 0;
+    this.lookups.set(varId, new JsModelLookup(numPoints, points));
   }
   // from JsModel interface
   storeOutputs(storeValue) {
@@ -1629,14 +1685,21 @@ var WasmModel = class {
         } else {
           subIndicesAddress = 0;
         }
-        const numLookupElements = lookupDef.points.length;
-        if (this.lookupDataBuffer === void 0 || this.lookupDataBuffer.numElements < numLookupElements) {
-          (_c = this.lookupDataBuffer) == null ? void 0 : _c.dispose();
-          this.lookupDataBuffer = createFloat64WasmBuffer(this.wasmModule, numLookupElements);
+        let pointsAddress;
+        let numPoints;
+        if (lookupDef.points) {
+          const numLookupElements = lookupDef.points.length;
+          if (this.lookupDataBuffer === void 0 || this.lookupDataBuffer.numElements < numLookupElements) {
+            (_c = this.lookupDataBuffer) == null ? void 0 : _c.dispose();
+            this.lookupDataBuffer = createFloat64WasmBuffer(this.wasmModule, numLookupElements);
+          }
+          this.lookupDataBuffer.getArrayView().set(lookupDef.points);
+          pointsAddress = this.lookupDataBuffer.getAddress();
+          numPoints = numLookupElements / 2;
+        } else {
+          pointsAddress = 0;
+          numPoints = 0;
         }
-        this.lookupDataBuffer.getArrayView().set(lookupDef.points);
-        const pointsAddress = this.lookupDataBuffer.getAddress();
-        const numPoints = numLookupElements / 2;
         const varIndex = varSpec.varIndex;
         this.wasmSetLookup(varIndex, subIndicesAddress, pointsAddress, numPoints);
       }
@@ -1844,7 +1907,7 @@ var ModelScheduler = class {
     /** Whether a model run is in progress. */
     this.runInProgress = false;
     const afterSet = () => {
-      this.runWasmModelIfNeeded();
+      this.runModelIfNeeded();
     };
     for (const userInput of userInputs) {
       userInput.callbacks.onSet = afterSet;
@@ -1855,24 +1918,24 @@ var ModelScheduler = class {
     }
   }
   /**
-   * Schedule a wasm model run (if not already pending).  When the run is
+   * Schedule a model run (if not already pending).  When the run is
    * complete, save the outputs and call the `onOutputsChanged` callback.
    */
-  runWasmModelIfNeeded() {
+  runModelIfNeeded() {
     this.runNeeded = true;
     if (this.runInProgress) {
       return;
     } else {
       this.runInProgress = true;
       setTimeout(() => {
-        this.runWasmModelNow();
+        this.runModelNow();
       }, 0);
     }
   }
   /**
-   * Run the wasm model asynchronously using the current set of input values.
+   * Run the model asynchronously using the current set of input values.
    */
-  runWasmModelNow() {
+  runModelNow() {
     return __async(this, null, function* () {
       var _a;
       for (let i = 0; i < this.userInputs.length; i++) {
@@ -1887,7 +1950,7 @@ var ModelScheduler = class {
       if (this.runNeeded) {
         this.runNeeded = false;
         setTimeout(() => {
-          this.runWasmModelNow();
+          this.runModelNow();
         }, 0);
       } else {
         this.runNeeded = false;
@@ -1909,6 +1972,192 @@ function createSimpleInputValue(varId) {
   };
   return { varId, get, set, reset, callbacks: {} };
 }
+
+// src/model-scheduler/multi-context-model-scheduler.ts
+var MultiContextModelScheduler = class {
+  /**
+   * @param runner The model runner.
+   * @param options Additional options for the scheduler.
+   * @param options.initialOutputs An optional `Outputs` instance that will be reused
+   * for the initial context.  This is useful for saving memory when an `Outputs`
+   * instance was already created for, e.g., a initial baseline/reference run.
+   */
+  constructor(runner, options) {
+    this.runner = runner;
+    /** The contexts that hold distinct sets of inputs and outputs. */
+    this.contexts = [];
+    /** Whether a model run has been scheduled. */
+    this.runNeeded = false;
+    /** Whether a model run is in progress. */
+    this.runInProgress = false;
+    this.initialOutputs = options == null ? void 0 : options.initialOutputs;
+  }
+  /**
+   * Return true if the scheduler has started any model runs.
+   */
+  isStarted() {
+    return this.initialOutputs === void 0;
+  }
+  /**
+   * Add a new context that holds a distinct set of model inputs and outputs.
+   * These inputs and outputs are kept separate from those in other contexts,
+   * which allows an application to use the same underlying model to run with
+   * multiple I/O contexts.
+   *
+   * Note that the contexts created before the first scheduled model run
+   * will inherit the data from `initialOutputs` passed to the constructor,
+   * but contexts created after that will initially have output values set
+   * to zero.
+   *
+   * @param inputs The input values, in the same order as in the spec file passed to `sde`.
+   * @param options Additional options for the context.
+   * @param options.externalData Additional data that is external to the model outputs.
+   * For example, this can contain data that was captured from an initial reference
+   * run, or other static data that is displayed in graphs alongside the model
+   * output data in graphs.
+   */
+  addContext(inputs, options) {
+    let outputs;
+    if (this.initialOutputs !== void 0) {
+      if (this.contexts.length === 0) {
+        outputs = this.initialOutputs;
+      } else {
+        outputs = this.runner.createOutputs();
+        for (const varId of outputs.varIds) {
+          const series0 = this.initialOutputs.getSeriesForVar(varId);
+          const series1 = outputs.getSeriesForVar(varId);
+          for (let i = 0; i < series0.points.length; i++) {
+            series1.points[i].y = series0.points[i].y;
+          }
+        }
+      }
+    } else {
+      outputs = this.runner.createOutputs();
+    }
+    const context = new ModelContextImpl(inputs, outputs, options == null ? void 0 : options.externalData);
+    const afterSet = () => {
+      context.runNeeded = true;
+      this.runModelIfNeeded();
+    };
+    for (const input of inputs) {
+      input.callbacks.onSet = afterSet;
+    }
+    this.contexts.push(context);
+    return context;
+  }
+  /**
+   * Remove the given context from the set of contexts managed by the scheduler.
+   *
+   * @param context The context to remove.
+   */
+  removeContext(context) {
+    const index = this.contexts.findIndex((c) => c === context);
+    if (index >= 0) {
+      this.contexts.splice(index, 1);
+    }
+  }
+  /**
+   * Schedule a model run (if not already pending).  When the run is
+   * complete, save the outputs and call the `onOutputsChanged` callback.
+   */
+  runModelIfNeeded() {
+    this.runNeeded = true;
+    if (this.runInProgress) {
+      return;
+    } else {
+      this.runInProgress = true;
+      setTimeout(() => {
+        this.runModelNow();
+      }, 0);
+    }
+  }
+  /**
+   * Run the model asynchronously for all relevant contexts.
+   */
+  runModelNow() {
+    return __async(this, null, function* () {
+      this.initialOutputs = void 0;
+      for (const context of this.contexts) {
+        if (context.runNeeded) {
+          context.runNeeded = false;
+          yield this.runModelNowForContext(context);
+        }
+      }
+      if (this.runNeeded) {
+        this.runNeeded = false;
+        setTimeout(() => {
+          this.runModelNow();
+        }, 0);
+      } else {
+        this.runNeeded = false;
+        this.runInProgress = false;
+      }
+    });
+  }
+  /**
+   * Run the model asynchronously using the current set of input values in the given context.
+   *
+   * @param context The context to use for the model run.
+   */
+  runModelNowForContext(context) {
+    return __async(this, null, function* () {
+      var _a;
+      if (this.currentInputs === void 0) {
+        this.currentInputs = Array(context.inputsArray.length);
+      }
+      for (let i = 0; i < context.inputsArray.length; i++) {
+        this.currentInputs[i] = context.inputsArray[i].get();
+      }
+      try {
+        yield this.runner.runModel(this.currentInputs, context.outputs);
+        (_a = context.onOutputsChanged) == null ? void 0 : _a.call(context);
+      } catch (e) {
+        console.error("ERROR: The scheduler encountered an error when running the model:", e);
+      }
+    });
+  }
+};
+var ModelContextImpl = class {
+  /**
+   * @hidden This is intended for use by `MultiContextModelScheduler` only.
+   *
+   * @param inputs The input values, in the same order as in the spec file passed to `sde`.
+   * @param outputs The structure into which the model outputs will be stored.
+   * @param externalData Additional data that is external to the model outputs.  For example, this can contain
+   * data that was captured from an initial reference run, or other static data that is displayed in graphs
+   * alongside the model output data in graphs.
+   */
+  constructor(inputs, outputs, externalData) {
+    this.externalData = externalData;
+    /**
+     * Whether a model run is needed for this context.
+     * @hidden This is intended for use by `MultiContextModelScheduler` only.
+     */
+    this.runNeeded = false;
+    this.inputsArray = Array.from(inputs);
+    this.outputs = outputs;
+  }
+  /**
+   * Return the series data for the given model output variable or external
+   * dataset.
+   *
+   * @param varId The ID of the output variable associated with the data.
+   * @param sourceName The external data source name (e.g. "Ref"), or
+   * undefined to use the latest model output data from this context.
+   */
+  getSeriesForVar(varId, sourceName) {
+    if (sourceName === void 0) {
+      return this.outputs.getSeriesForVar(varId);
+    } else {
+      const dataForSource = this.externalData.get(sourceName);
+      if (dataForSource !== void 0) {
+        return dataForSource.get(varId);
+      } else {
+        return void 0;
+      }
+    }
+  }
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   BufferedRunModelParams,
@@ -1916,6 +2165,7 @@ function createSimpleInputValue(varId) {
   MockWasmModule,
   ModelListing,
   ModelScheduler,
+  MultiContextModelScheduler,
   Outputs,
   ReferencedRunModelParams,
   Series,