@sdeverywhere/runtime 0.2.6 → 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,
@@ -1906,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;
@@ -1917,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++) {
@@ -1949,7 +1950,7 @@ var ModelScheduler = class {
       if (this.runNeeded) {
         this.runNeeded = false;
         setTimeout(() => {
-          this.runWasmModelNow();
+          this.runModelNow();
         }, 0);
       } else {
         this.runNeeded = false;
@@ -1971,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,
@@ -1978,6 +2165,7 @@ function createSimpleInputValue(varId) {
   MockWasmModule,
   ModelListing,
   ModelScheduler,
+  MultiContextModelScheduler,
   Outputs,
   ReferencedRunModelParams,
   Series,