@sdeverywhere/cli 0.7.0

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016-2022 Todd Fincannon and Climate Interactive / New Venture Fund
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,14 @@
+# @sdeverywhere/cli
+
+This package contains the `sde` command line interface for the SDEverywhere
+suite of tools.
+
+SDEverywhere can be used to translate System Dynamics models from Vensim to C and WebAssembly.
+
+## Documentation
+
+TODO
+
+## License
+
+SDEverywhere is distributed under the MIT license. See `LICENSE` for more details.

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@sdeverywhere/cli",
+  "version": "0.7.0",
+  "description": "Contains the `sde` command line interface for the SDEverywhere tool suite.",
+  "type": "module",
+  "files": [
+    "src/**",
+    "!.DS_Store"
+  ],
+  "bin": {
+    "sde": "src/main.js"
+  },
+  "dependencies": {
+    "@sdeverywhere/build": "^0.1.0",
+    "@sdeverywhere/compile": "^0.7.0",
+    "bufx": "^1.0.5",
+    "byline": "^5.0.0",
+    "fs-extra": "^10.1.0",
+    "ramda": "^0.27.0",
+    "shelljs": "^0.8.3",
+    "yargs": "^17.5.1"
+  },
+  "author": "Climate Interactive",
+  "license": "MIT",
+  "homepage": "https://sdeverywhere.org",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/climateinteractive/SDEverywhere.git",
+    "directory": "packages/cli"
+  },
+  "bugs": {
+    "url": "https://github.com/climateinteractive/SDEverywhere/issues"
+  },
+  "scripts": {
+    "lint": "eslint . --max-warnings 0",
+    "prettier:check": "prettier --check .",
+    "prettier:fix": "prettier --write .",
+    "precommit": "../../scripts/precommit",
+    "ci:build": "run-s lint prettier:check"
+  }
+}

package/src/c/macros.c

@@ -0,0 +1,4 @@
+#include "sde.h"
+
+extern double _time;
+extern double _time_step;

package/src/c/main.c

@@ -0,0 +1,58 @@
+#include "sde.h"
+
+int main(int argc, char** argv) {
+  // TODO make the input buffer size dynamic
+  char inputs[1500];
+  // 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.
+  bool suppress_data_output = false;
+  // 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) {
+      fclose(instream);
+      size_t len = strlen(inputs);
+      if (inputs[len - 1] == '\n') {
+        inputs[len - 1] = '\0';
+      }
+    }
+    if (argc > 2) {
+      // Set option flags.
+      if (strcmp(argv[2], "--raw") == 0) {
+        raw_output = true;
+      }
+    }
+  } else {
+    *inputs = '\0';
+  }
+  // Run the model and get output for all time steps.
+  char* outputs = run_model(inputs);
+  if (!suppress_data_output) {
+    if (raw_output) {
+      // Write raw output data directly.
+      fputs(outputs, stdout);
+    } 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++;
+            }
+          }
+          *p++ = '\0';
+          printf("%s\n", line);
+        }
+      }
+    }
+  }
+  finish();
+}

package/src/c/makefile

@@ -0,0 +1,15 @@
+# Do "export P={c-file-basename}" before running this makefile.
+OBJECTS=main.o vensim.o model.o macros.o
+CFLAGS=-Wall -O3
+LDLIBS=
+
+# In case of a Linux build we need to add
+# an extra flag, to link with math library
+UNAME_S := $(shell uname -s)
+ifeq ($(UNAME_S),Linux)
+    LDLIBS+= -lm
+endif
+
+CC=clang
+
+$(P): $(OBJECTS) $P.o

package/src/c/model.c

@@ -0,0 +1,134 @@
+#include <time.h>
+
+#include "sde.h"
+
+// Define PERF_TEST to output run time information.
+// #define PERF_TEST
+#ifdef PERF_TEST
+struct timespec startTime, finishTime;
+#endif
+
+// 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`
+double* outputBuffer = NULL;
+size_t outputVarIndex = 0;
+size_t numSavePoints = 0;
+size_t savePointIndex = 0;
+
+int step = 0;
+
+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;
+}
+
+/**
+ * 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.
+ *
+ * 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:
+ *   `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.
+ */
+void runModelWithBuffers(double* inputs, double* outputs) {
+  outputBuffer = outputs;
+  initConstants();
+  setInputsFromBuffer(inputs);
+  initLevels();
+  run();
+  outputBuffer = NULL;
+}
+
+void run() {
+#ifdef PERF_TEST
+  clock_gettime(CLOCK_MONOTONIC, &startTime);
+#endif
+
+  // Restart fresh output for all steps in this run.
+  numSavePoints = (size_t)(round((_final_time - _initial_time) / _saveper)) + 1;
+  savePointIndex = 0;
+  outputIndex = 0;
+
+  // Initialize time with the required INITIAL TIME control variable.
+  _time = _initial_time;
+
+  // Set up a run loop using a fixed number of time steps.
+  int lastStep = (int)(round((_final_time - _initial_time) / _time_step));
+  step = 0;
+  while (step <= lastStep) {
+    evalAux();
+    if (fmod(_time, _saveper) < 1e-6) {
+      outputVarIndex = 0;
+      storeOutputData();
+      savePointIndex++;
+    }
+    if (step == lastStep) break;
+    // Propagate levels for the next time step.
+    evalLevels();
+    _time += _time_step;
+    step++;
+  }
+}
+
+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;
+  }
+}
+
+void finish() {
+#ifdef PERF_TEST
+  clock_gettime(CLOCK_MONOTONIC, &finishTime);
+  double runtime =
+      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/model.h

@@ -0,0 +1,12 @@
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+double roundToSignificantFigures(double num, int n);
+double print6(double num);
+
+#ifdef __cplusplus
+}
+#endif

package/src/c/sde.h

@@ -0,0 +1,73 @@
+#pragma once
+
+#ifndef EXTERN
+#ifdef __cplusplus
+#define EXTERN extern "C"
+#else
+#define EXTERN extern
+#endif
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <math.h>
+#include <stdlib.h>
+#include <stdarg.h>
+#include <stdbool.h>
+#include <float.h>
+#include <string.h>
+#include <ctype.h>
+#include <stdio.h>
+
+#include "model.h"
+#include "vensim.h"
+#include "macros.h"
+
+EXTERN double _epsilon;
+
+// Enable this to add print statements in initLevels and evalAux for debugging.
+// #define PRDBG
+#ifdef PRDBG
+#define PRINIT(v) printf("initLevels: " #v " = %g\n", (v));
+#define PRAUX(v, t) if (_time == t) { printf("evalAux: " #v " = %g\n", (v)); }
+#else
+#define PRINIT(v)
+#define PRAUX(v, t)
+#endif
+
+// Each number in the output can take up to 13 characters plus a separator character.
+#define OUTPUT_STRING_LEN 14
+
+// Internal variables
+EXTERN const int numOutputs;
+
+// Standard simulation control parameters
+EXTERN double _time;
+EXTERN double _initial_time;
+EXTERN double _final_time;
+EXTERN double _time_step;
+EXTERN double _saveper;
+
+// API
+char* run_model(const char* inputs);
+void runModelWithBuffers(double* inputs, double* outputs);
+void run(void);
+void startOutput(void);
+void outputVar(double value);
+void finish(void);
+
+// Functions implemented by the model
+void initConstants(void);
+void initLevels(void);
+void setInputs(const char* inputData);
+void setInputsFromBuffer(double *inputData);
+void evalAux(void);
+void evalLevels(void);
+void storeOutputData(void);
+const char* getHeader(void);
+
+#ifdef __cplusplus
+}
+#endif