@sdeverywhere/cli 0.7.37 → 0.7.39

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sdeverywhere/cli",
-  "version": "0.7.37",
+  "version": "0.7.39",
   "description": "Contains the `sde` command line interface for the SDEverywhere tool suite.",
   "type": "module",
   "files": [
@@ -11,8 +11,8 @@
     "sde": "src/main.js"
   },
   "dependencies": {
-    "@sdeverywhere/build": "^0.3.8",
-    "@sdeverywhere/compile": "^0.7.26",
+    "@sdeverywhere/build": "^0.3.10",
+    "@sdeverywhere/compile": "^0.7.27",
     "byline": "^5.0.0",
     "ramda": "^0.27.0",
     "shelljs": "^0.10.0",

package/src/c/main.c

@@ -1,8 +1,70 @@
 #include "sde.h"
 
+/**
+ * Count the number of input pairs in the input string in the format
+ * "varIndex:value varIndex:value ..." (for example, "0:3.14 6:42").
+ */
+static size_t countInputs(const char* inputData) {
+  if (inputData == NULL || *inputData == '\0') {
+    return 0;
+  }
+
+  // Make a copy since strtok modifies the string
+  char* inputsCopy = (char*)malloc(strlen(inputData) + 1);
+  strcpy(inputsCopy, inputData);
+
+  size_t count = 0;
+  char* token = strtok(inputsCopy, " ");
+  while (token) {
+    if (strchr(token, ':') != NULL) {
+      count++;
+    }
+    token = strtok(NULL, " ");
+  }
+  free(inputsCopy);
+
+  return count;
+}
+
+/**
+ * Parse an input data string in the format "varIndex:value varIndex:value ..."
+ * (for example, "0:3.14 6:42") and populate the inputValues and inputIndices
+ * arrays for sparse input setting.
+ *
+ * @param inputData The input string to parse.
+ * @param inputValues The array to populate with input values.
+ * @param inputIndices The array to populate with input indices (first element is count).
+ */
+static void parseInputs(const char* inputData, double* inputValues, int32_t* inputIndices) {
+  if (inputData == NULL || *inputData == '\0') {
+    return;
+  }
+
+  // Make a copy since strtok modifies the string
+  char* inputsCopy = (char*)malloc(strlen(inputData) + 1);
+  strcpy(inputsCopy, inputData);
+
+  size_t i = 0;
+  char* token = strtok(inputsCopy, " ");
+  while (token) {
+    char* p = strchr(token, ':');
+    if (p) {
+      *p = '\0';
+      int modelVarIndex = atoi(token);
+      double value = atof(p + 1);
+      inputIndices[i + 1] = modelVarIndex;
+      inputValues[i] = value;
+      i++;
+    }
+    token = strtok(NULL, " ");
+  }
+  inputIndices[0] = (int32_t)i;
+  free(inputsCopy);
+}
+
 int main(int argc, char** argv) {
   // TODO make the input buffer size dynamic
-  char inputs[500000];
+  char inputString[500000];
   // When true, output data without newlines or a header, suitable for embedding reference data.
   bool raw_output = false;
   // When true, suppress data output when using PR* macros.
@@ -10,11 +72,11 @@ int main(int argc, char** argv) {
   // Try to read input from a file named in the argument.
   if (argc > 1) {
     FILE* instream = fopen(argv[1], "r");
-    if (instream && fgets(inputs, sizeof inputs, instream) != NULL) {
+    if (instream && fgets(inputString, sizeof inputString, instream) != NULL) {
       fclose(instream);
-      size_t len = strlen(inputs);
-      if (inputs[len - 1] == '\n') {
-        inputs[len - 1] = '\0';
+      size_t len = strlen(inputString);
+      if (inputString[len - 1] == '\n') {
+        inputString[len - 1] = '\0';
       }
     }
     if (argc > 2) {
@@ -24,35 +86,68 @@ int main(int argc, char** argv) {
       }
     }
   } else {
-    *inputs = '\0';
+    *inputString = '\0';
+  }
+
+  // Parse input string and create sparse input arrays. Only allocate buffers if there
+  // are inputs to parse; otherwise pass NULL to runModelWithBuffers so that the model
+  // uses its default values from initConstants.
+  double* inputValues = NULL;
+  int32_t* inputIndices = NULL;
+  size_t inputCount = countInputs(inputString);
+  if (inputCount > 0) {
+    inputValues = (double*)malloc(inputCount * sizeof(double));
+    inputIndices = (int32_t*)malloc((inputCount + 1) * sizeof(int32_t));
+    parseInputs(inputString, inputValues, inputIndices);
   }
-  // Run the model and get output for all time steps.
-  char* outputs = run_model(inputs);
+
+  // Calculate the number of save points for the output buffer
+  double initialTime = getInitialTime();
+  double finalTime = getFinalTime();
+  double saveper = getSaveper();
+  size_t numSavePoints = (size_t)(round((finalTime - initialTime) / saveper)) + 1;
+
+  // Allocate output buffer
+  double* outputBuffer = (double*)malloc(numOutputs * numSavePoints * sizeof(double));
+
+  // Run the model with the sparse input arrays and output buffer
+  runModelWithBuffers(inputValues, inputIndices, outputBuffer, NULL, NULL, NULL);
+
   if (!suppress_data_output) {
     if (raw_output) {
-      // Write raw output data directly.
-      fputs(outputs, stdout);
+      // Write raw output data directly (tab-separated, no newlines)
+      for (size_t t = 0; t < numSavePoints; t++) {
+        for (size_t v = 0; v < numOutputs; v++) {
+          // Output buffer is organized by variable (each variable has numSavePoints values)
+          double value = outputBuffer[v * numSavePoints + t];
+          printf("%g\t", value);
+        }
+      }
     } else {
       // Write a header for output data.
       printf("%s\n", getHeader());
       // Write tab-delimited output data, one line per output time step.
-      if (outputs != NULL) {
-        char* p = outputs;
-        while (*p) {
-          char* line = p;
-          for (size_t i = 0; i < numOutputs; i++) {
-            if (i > 0) {
-              p++;
-            }
-            while (*p && *p != '\t') {
-              p++;
-            }
+      for (size_t t = 0; t < numSavePoints; t++) {
+        for (size_t v = 0; v < numOutputs; v++) {
+          // Output buffer is organized by variable (each variable has numSavePoints values)
+          double value = outputBuffer[v * numSavePoints + t];
+          if (v > 0) {
+            printf("\t");
           }
-          *p++ = '\0';
-          printf("%s\n", line);
+          printf("%g", value);
         }
+        printf("\n");
       }
     }
   }
+
+  // Clean up
+  if (inputValues != NULL) {
+    free(inputValues);
+  }
+  if (inputIndices != NULL) {
+    free(inputIndices);
+  }
+  free(outputBuffer);
   finish();
 }

package/src/c/model.c

@@ -11,11 +11,7 @@ struct timespec startTime, finishTime;
 // The special _time variable is not included in .mdl files.
 double _time;
 
-// Output data buffer used by `run_model`
-char* outputData = NULL;
-size_t outputIndex = 0;
-
-// Output data buffer used by `runModelWithBuffers`
+// Output data buffer and parameters used by `runModelWithBuffers`
 double* outputBuffer = NULL;
 int32_t* outputIndexBuffer = NULL;
 size_t outputVarIndex = 0;
@@ -67,47 +63,157 @@ double getSaveper() {
   return _saveper;
 }
 
-char* run_model(const char* inputs) {
-  // run_model does everything necessary to run the model with the given inputs.
-  // It may be called multiple times. Call finish() after all runs are complete.
-  // Initialize the state to default values in the model at the start of each run.
-  initConstants();
-  // Set inputs for this run that override default values.
-  // fprintf(stderr, "run_model inputs = %s\n", inputs);
-  setInputs(inputs);
-  initLevels();
-  run();
-  return outputData;
+/**
+ * Set constant overrides from the given buffers.
+ *
+ * The `constantIndices` buffer contains the variable indices and subscript indices
+ * for each constant to override. The format is:
+ *   [count, varIndex1, subCount1, subIndex1_1, ..., varIndex2, subCount2, ...]
+ *
+ * The `constantValues` buffer contains the corresponding values for each constant.
+ */
+void setConstantOverridesFromBuffers(double* constantValues, int32_t* constantIndices) {
+  if (constantValues == NULL || constantIndices == NULL) {
+    return;
+  }
+
+  size_t indexBufferOffset = 0;
+  size_t valueBufferOffset = 0;
+  size_t constantCount = (size_t)constantIndices[indexBufferOffset++];
+
+  for (size_t i = 0; i < constantCount; i++) {
+    size_t varIndex = (size_t)constantIndices[indexBufferOffset++];
+    size_t subCount = (size_t)constantIndices[indexBufferOffset++];
+    size_t* subIndices;
+    if (subCount > 0) {
+      subIndices = (size_t*)(constantIndices + indexBufferOffset);
+      indexBufferOffset += subCount;
+    } else {
+      subIndices = NULL;
+    }
+    double value = constantValues[valueBufferOffset++];
+    setConstant(varIndex, subIndices, value);
+  }
 }
 
 /**
  * Run the model, reading inputs from the given `inputs` buffer, and writing outputs
  * to the given `outputs` buffer.
  *
- * This function performs the same steps as the original `run_model` function,
- * except that it uses the provided pre-allocated buffers.
- *
- * The `inputs` buffer is assumed to have one double value for each input variable;
- * they must be in exactly the same order as the variables are listed in the spec file.
+ * This is a simplified version of `runModelWithBuffers` that passes NULL for
+ * all parameters other than `inputs` and `outputs`.
  *
  * After each step of the run, the `outputs` buffer will be updated with the output
- * variables.  The buffer needs to be at least as large as:
+ * variables.  The `outputs` buffer needs to be at least as large as:
  *   `number of output variables` * `number of save points`
- * where `number of save points` is typically one point for each year inclusive of
- * the start and end times.
  *
  * The outputs will be stored in the same order as the outputs are defined in the
  * spec file, with one "row" for each variable.  For example, the first value in
- * the buffer will be the output value at t0 for the first output variable, followed
- * by the output value for that variable at t1, and so on.  After the value for tN
- * (where tN is the last time in the range), the second variable outputs will begin,
- * and so on.
+ * the buffer will be the output value at t0 for the first output variable,
+ * followed by the output value for that variable at t1, and so on.  After the
+ * value for tN (where tN is the last time in the range), the second variable
+ * outputs will begin, and so on.
+ *
+ * @param inputs The buffer that contains the model input values.  If NULL,
+ * no inputs will be set and the model will use the default values for all
+ * constants as defined in the generated model.  If non-NULL, the buffer is
+ * assumed to have one double value for each input variable in exactly the
+ * same order that the variables are listed in the spec file.
+ * @param outputs The required buffer that will receive the model output
+ * values.  See above for details on the expected format.
+ */
+void runModel(double* inputs, double* outputs) {
+  runModelWithBuffers(inputs, NULL, outputs, NULL, NULL, NULL);
+}
+
+/**
+ * Run the model, reading inputs from the given `inputs` buffer, and writing outputs
+ * to the given `outputs` buffer.
+ *
+ * INPUTS
+ * ------
+ *
+ * If `inputIndices` is NULL, the `inputs` buffer is assumed to have one double value
+ * for each input variable, in exactly the same order as the variables are listed in
+ * the spec file.
+ *
+ * If `inputIndices` is non-NULL, it specifies which inputs are being set:
+ *   - inputIndices[0] is the count (C) of inputs being specified
+ *   - inputIndices[1...C] are the indices of the inputs to set (where each index
+ *     corresponds to the index of the input variable in the spec.json file)
+ *   - inputs[0...C-1] are the corresponding values
+ *
+ * OUTPUTS
+ * -------
+ *
+ * After each step of the run, the `outputs` buffer will be updated with the output
+ * variables.  The `outputs` buffer needs to be at least as large as:
+ *   `number of output variables` * `number of save points`
+ *
+ * If `outputIndices` is NULL, outputs will be stored in the same order as the outputs
+ * are defined in the spec file, with one "row" for each variable.  For example, the
+ * first value in the buffer will be the output value at t0 for the first output
+ * variable, followed by the output value for that variable at t1, and so on.  After
+ * the value for tN (where tN is the last time in the range), the second variable
+ * outputs will begin, and so on.
+ *
+ * If `outputIndices` is non-NULL, it specifies which outputs are being stored:
+ *   - outputIndices[0] is the count (C) of output variables being stored
+ *   - outputIndices[1...] are the indices of the output variables to store, in
+ *     the following format:
+ *       [count, varIndex1, subCount1, subIndex1_1, ..., varIndex2, subCount2, ...]
+ *     where `count` is the number of variables to store, `varIndexN` is the index
+ *     of the variable to store (from the {model}.json listing file), `subCountN` is
+ *     the number of subscripts for that variable, and `subIndexN_M` is the index of
+ *     the subscript at the Mth position for that variable
+ *   - outputs[0...C-1] are the corresponding values
+ *
+ * CONSTANT OVERRIDES
+ * ------------------
+ *
+ * If `constants` and `constantIndices` are non-NULL, the provided constant values will
+ * override the default values for those constants as defined in the generated model.
+ *
+ * The `constantIndices` buffer specifies which constants are being overridden.  The
+ * format is the same as described above for `outputIndices`:
+ *   - constantIndices[0] is the count (C) of constants being overridden
+ *   - constantIndices[1...] are the indices of the constants to override, in the
+ *     following format:
+ *       [count, varIndex1, subCount1, subIndex1_1, ..., varIndex2, subCount2, ...]
+ *     where `count` is the number of constants to override, `varIndexN` is the index
+ *     of the variable to store (from the {model}.json listing file), `subCountN` is
+ *     the number of subscripts for that variable, and `subIndexN_M` is the index of
+ *     the subscript at the Mth position for that variable
+ *   - constants[0...C-1] are the corresponding values
+ *
+ * @param inputs The buffer that contains the model input values.  If NULL, no inputs
+ * will be set and the model will use the default values for all constants as defined
+ * in the generated model.  If non-NULL, the buffer is assumed to have one double value
+ * for each input variable.  The number of values provided depends on `inputIndices`;
+ * see above for details on the expected format of these two parameters.
+ * @param inputIndices The optional buffer that specifies which input values from the
+ * `inputs` buffer are being set.  See above for details on the expected format.
+ * @param outputs The required buffer that will receive the model output values.  See
+ * above for details on the expected format.
+ * @param outputIndices The optional buffer that specifies which output values will be
+ * stored in the `outputs` buffer.  See above for details on the expected format.
+ * @param constants An optional buffer that contains the values of the constants to
+ * override.  Pass NULL if not overriding any constants.  Each value in the buffer
+ * corresponds to the value of the constant at the corresponding index.
+ * @param constantIndices An optional buffer that contains the indices of the constants
+ * to override.  Pass NULL if not overriding any constants.  See above for details on
+ * the expected format.
  */
-void runModelWithBuffers(double* inputs, double* outputs, int32_t* outputIndices) {
+void runModelWithBuffers(double* inputs, int32_t* inputIndices, double* outputs, int32_t* outputIndices, double* constants, int32_t* constantIndices) {
   outputBuffer = outputs;
   outputIndexBuffer = outputIndices;
   initConstants();
-  setInputsFromBuffer(inputs);
+  if (constants != NULL && constantIndices != NULL) {
+    setConstantOverridesFromBuffers(constants, constantIndices);
+  }
+  if (inputs != NULL) {
+    setInputs(inputs, inputIndices);
+  }
   initLevels();
   run();
   outputBuffer = NULL;
@@ -121,7 +227,6 @@ void run() {
 
   // Restart fresh output for all steps in this run.
   savePointIndex = 0;
-  outputIndex = 0;
 
   // Initialize time with the required INITIAL TIME control variable.
   _time = _initial_time;
@@ -171,25 +276,11 @@ void run() {
 }
 
 void outputVar(double value) {
-  if (outputBuffer != NULL) {
-    // Write each value into the preallocated buffer; each variable has a "row" that
-    // contains `numSavePoints` values, one value for each save point
-    double* outputPtr = outputBuffer + (outputVarIndex * numSavePoints) + savePointIndex;
-    *outputPtr = value;
-    outputVarIndex++;
-  } else {
-    // Allocate an output buffer for all output steps as a single block.
-    // Add one character for a null terminator.
-    if (outputData == NULL) {
-      int numOutputSteps = (int)(round((_final_time - _initial_time) / _saveper)) + 1;
-      size_t size = numOutputSteps * (OUTPUT_STRING_LEN * numOutputs) + 1;
-      // fprintf(stderr, "output data size = %zu\n", size);
-      outputData = (char*)malloc(size);
-    }
-    // Format the value as a string in the output data buffer.
-    int numChars = snprintf(outputData + outputIndex, OUTPUT_STRING_LEN + 1, "%g\t", value);
-    outputIndex += numChars;
-  }
+  // Write each value into the preallocated buffer; each variable has a "row" that
+  // contains `numSavePoints` values, one value for each save point
+  double* outputPtr = outputBuffer + (outputVarIndex * numSavePoints) + savePointIndex;
+  *outputPtr = value;
+  outputVarIndex++;
 }
 
 void finish() {
@@ -199,7 +290,4 @@ void finish() {
       1000.0 * finishTime.tv_sec + 1e-6 * finishTime.tv_nsec - (1000.0 * startTime.tv_sec + 1e-6 * startTime.tv_nsec);
   fprintf(stderr, "calculation runtime = %.0f ms\n", runtime);
 #endif
-  if (outputData != NULL) {
-    free(outputData);
-  }
 }

package/src/c/sde.h

@@ -41,6 +41,7 @@ EXTERN double _epsilon;
 #define OUTPUT_STRING_LEN 14
 
 // Internal variables
+EXTERN const int numInputs;
 EXTERN const int numOutputs;
 
 // Standard simulation control parameters
@@ -54,8 +55,8 @@ EXTERN double _saveper;
 double getInitialTime(void);
 double getFinalTime(void);
 double getSaveper(void);
-char* run_model(const char* inputs);
-void runModelWithBuffers(double* inputs, double* outputs, int32_t* outputIndices);
+void runModel(double* inputs, double* outputs);
+void runModelWithBuffers(double* inputs, int32_t* inputIndices, double* outputs, int32_t* outputIndices, double* constants, int32_t* constantIndices);
 void run(void);
 void startOutput(void);
 void outputVar(double value);
@@ -64,8 +65,8 @@ void finish(void);
 // Functions implemented by the generated model
 void initConstants(void);
 void initLevels(void);
-void setInputs(const char* inputData);
-void setInputsFromBuffer(double *inputData);
+void setInputs(double* inputValues, int32_t* inputIndices);
+void setConstant(size_t varIndex, size_t* subIndices, double value);
 void setLookup(size_t varIndex, size_t* subIndices, double* points, size_t numPoints);
 void evalAux(void);
 void evalLevels(void);