Add Custom Configurations (#24)

* feat: add new Configurator singleton class to configure default launch options

* chore: bump gradle version

* fix: remove old comments, add return to try catch

* docs: split development and user instructions in readme

* chore: add logging to Configurator

* ci: add config.toml to release

* fix: add config.toml to git

Author: vincentjguo

.github/workflows/release.yml

@@ -54,9 +54,11 @@ jobs:
       - name: Create GitHub Release (attaches JAR)
         uses: softprops/action-gh-release@v2
         with:
-          tag_name:  ${{ steps.version.outputs.version }}
-          name:      Release ${{ steps.version.outputs.version }}
-          files:     build/libs/*-all.jar
+          tag_name: ${{ steps.version.outputs.version }}
+          name: Release ${{ steps.version.outputs.version }}
+          files: |
+            build/libs/*-all.jar
+            config.toml
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
 

README.md

@@ -2,41 +2,50 @@
 
 OpenRocket, and our code for running monte carlo simulations in OpenRocket.
 
-## Dependencies
-- Java 17 (JDK 17, Required for OpenRocket)
-- IntelliJ IDEA (Recommended for development)
-- OpenRocket 24.12.RC.01 (Included as a submodule)
+## Requirements
 
-## Release Process
+- Java 17
 
-Follow these steps to release a new version of the Monte-Carlo OR plugin:
+## Running the Simulator
 
-### 1. Update the Version Number
-Edit the [build.gradle](build.gradle) file to reflect the new version:
+Download the latest release from
+the [releases page](https://github.com/waterloo-rocketry/or-monte-carlo/releases/latest)
 
-```gradle
-group 'com.waterloorocketry'
-version 'X.Y.Z' // Format: Major.Minor.Hotfix
-```
+In the downloaded directory run `java -jar WaterlooRocketry-OpenRocket-{version}-all.jar`
 
-Example: Change `version '1.0.0'` to `version '1.1.0'` for a minor update.
+## Configuration
 
-### 2. Verify CI Build
-Ensure the following CI workflow is successful on the `main` branch:
+Create a file named `config.toml` in the same directory as the jar with the structure as follows:
 
-- CI – Build Monte-Carlo or-plugin
+```toml
+[simulation]
 
-You can check this in your CI/CD platform (e.g., GitHub Actions, Jenkins, etc.).
+[simulation.executor]
+batch_size = 30
 
-### 3. Trigger the Release
-Initiate the release by running the following workflow on the `main` branch:
+[simulation.options]
+launch_latitude = 47.965378
+launch_longitude = -81.873536
+launch_altitude = 420.0144
+launch_rod_length = 9.144
+launch_into_wind = false
+launch_rod_angle = 0.0872665
+launch_rod_direction = 4.71239
+max_simulation_time = 2400
+```
 
-- Manual Release – Monte-Carlo or-plugin
+The above is the default configuration if no configuration file is provided.
+All measurements are in SI units.
 
-This step will publish the current build based on the version specified in `build.gradle`.
+## Development
+
+### Setup
 
+#### Dependencies
 
-## Setup
+- Java 17 (JDK 17, Required for OpenRocket)
+- IntelliJ IDEA (Recommended for development)
+- OpenRocket 24.12.RC.01 (Included as a submodule)
 
 Start by cloning this repository:
 
@@ -47,18 +56,51 @@ git clone --recurse-submodules https://github.com/waterloo-rocketry/openrocket
 (If you did not use `--recurse-submodules`, run `git submodule update --init --recursive`. See
 https://git-scm.com/book/en/v2/Git-Tools-Submodules for details.)
 
-### IntelliJ
+#### IntelliJ
 
 We will continue using [IntelliJ IDEA](https://www.jetbrains.com/idea/) IDE. Open the project.
 You do not need to install a JDK or Ant separately.
 
-You will need to configure your project JDK in File > Project Structure > Project. We will use Java 17. 
+You will need to configure your project JDK in File > Project Structure > Project. We will use Java 17.
 Intellij should recognize and download this automatically.
 
 In the top-right of the project, you will see a few gradle tasks. Here are the three important ones:
+
 - `./gradlew buildOpenRocket`: This builds OpenRocket. **Run this first before running the plugin**!
 - `./gradlew runOpenRocket`: This is used to run OpenRocket by itself.
 - `./gradlew run`: This is used to run the Monte-Carlo plugin
-- `./gradlew buildExtensions`: This will build all extensions in the extensions directory. Run this first if you want extensions
+- `./gradlew buildExtensions`: This will build all extensions in the extensions directory. Run this first if you want
+  extensions
 
-To get debug logging from OpenRocket and the extension, add `-Dlog-level='DEBUG'` to the run command.
+To get debug logging from OpenRocket and the extension, add `-Dlog-level='DEBUG'` to the run command.
+
+### Release Process
+
+Follow these steps to release a new version of the Monte-Carlo OR plugin:
+
+#### 1. Update the Version Number
+
+Edit the [build.gradle](build.gradle) file to reflect the new version:
+
+```gradle
+group 'com.waterloorocketry'
+version 'X.Y.Z' // Format: Major.Minor.Hotfix
+```
+
+Example: Change `version '1.0.0'` to `version '1.1.0'` for a minor update.
+
+#### 2. Verify CI Build
+
+Ensure the following CI workflow is successful on the `main` branch:
+
+- CI – Build Monte-Carlo or-plugin
+
+You can check this in your CI/CD platform (e.g., GitHub Actions, Jenkins, etc.).
+
+#### 3. Trigger the Release
+
+Initiate the release by running the following workflow on the `main` branch:
+
+- Manual Release – Monte-Carlo or-plugin
+
+This step will publish the current build based on the version specified in `build.gradle`.

build.gradle

@@ -5,7 +5,7 @@ plugins {
 }
 
 group 'com.waterloorocketry'
-version '1.1.1'
+version '1.2.0'
 
 ext {
     openRocketVersion = '24.12'

config.toml

@@ -0,0 +1,14 @@
+[simulation]
+
+[simulation.executor]
+batch_size = 30
+
+[simulation.options]
+launch_latitude = 47.965378
+launch_longitude = -81.873536
+launch_altitude = 420.0144
+launch_rod_length = 9.144
+launch_into_wind = false
+launch_rod_angle = 0.0872665
+launch_rod_direction = 4.71239
+max_simulation_time = 2400

or-monte-carlo/src/com/waterloorocketry/openrocket_monte_carlo/Configurator.java

@@ -0,0 +1,110 @@
+package com.waterloorocketry.openrocket_monte_carlo;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.FileNotFoundException;
+import java.io.IOException;
+
+public class Configurator {
+    private final static Logger log = LoggerFactory.getLogger(Configurator.class);
+    private final static String CONFIG_FILE_PATH = "config.toml";
+    private static Configurator instance;
+    private int batchSize = 30;
+    private double launchLatitude = 47.965378;
+    private double launchLongitude = -81.873536;
+    private double launchAltitude = 420.0144;
+    private double launchRodLength = 9.144;
+    private boolean launchIntoWind = false;
+    private double launchRodAngle = 0.0872665;
+    private double launchRodDirection = 4.71239;
+    private int maxSimulationTime = 2400;
+
+    private Configurator() {
+        try {
+            java.util.Properties props = new java.util.Properties();
+            java.io.FileInputStream fis = new java.io.FileInputStream(CONFIG_FILE_PATH);
+            props.load(fis);
+
+            batchSize = Integer.parseInt(props.getProperty("batch_size", String.valueOf(batchSize)));
+            launchLatitude = Double.parseDouble(props.getProperty("launch_latitude", String.valueOf(launchLatitude)));
+            launchLongitude = Double.parseDouble(props.getProperty("launch_longitude", String.valueOf(launchLongitude)));
+            launchAltitude = Double.parseDouble(props.getProperty("launch_altitude", String.valueOf(launchAltitude)));
+            launchRodLength = Double.parseDouble(props.getProperty("launch_rod_length", String.valueOf(launchRodLength)));
+            launchIntoWind = Boolean.parseBoolean(props.getProperty("launch_into_wind", String.valueOf(launchIntoWind)));
+            launchRodAngle = Double.parseDouble(props.getProperty("launch_rod_angle", String.valueOf(launchRodAngle)));
+            launchRodDirection = Double.parseDouble(props.getProperty("launch_rod_direction", String.valueOf(launchRodDirection)));
+            maxSimulationTime = Integer.parseInt(props.getProperty("max_simulation_time", String.valueOf(maxSimulationTime)));
+
+            fis.close();
+        } catch (FileNotFoundException ex) {
+            log.info("No user configuration file found, using defaults.");
+            log.debug(ex.getMessage());
+            return;
+        } catch (IOException ex) {
+            log.warn("Error reading configuration file: " + CONFIG_FILE_PATH);
+            log.debug(ex.getMessage());
+            System.exit(-1); // exit since we don't want to run with partial config
+        }
+        log.info("User configuration loaded.");
+        log.info(this.toString());
+    }
+
+
+    public static Configurator getInstance() {
+        if (instance == null) {
+            instance = new Configurator();
+        }
+        return instance;
+    }
+
+    @Override
+    public String toString() {
+        return "Configuration: \n" +
+                "batchSize=" + batchSize + "\n" +
+                "launchLatitude=" + launchLatitude + "\n" +
+                "launchLongitude=" + launchLongitude + "\n" +
+                "launchAltitude=" + launchAltitude + "\n" +
+                "launchRodLength=" + launchRodLength + "\n" +
+                "launchIntoWind=" + launchIntoWind + "\n" +
+                "launchRodAngle=" + launchRodAngle + "\n" +
+                "launchRodDirection=" + launchRodDirection + "\n" +
+                "maxSimulationTime=" + maxSimulationTime;
+    }
+
+    public int getBatchSize() {
+        return batchSize;
+    }
+
+    public double getLaunchLatitude() {
+        return launchLatitude;
+    }
+
+    public double getLaunchLongitude() {
+        return launchLongitude;
+    }
+
+    public double getLaunchAltitude() {
+        return launchAltitude;
+    }
+
+    public double getLaunchRodLength() {
+        return launchRodLength;
+    }
+
+    public boolean isLaunchIntoWind() {
+        return launchIntoWind;
+    }
+
+    public double getLaunchRodAngle() {
+        return launchRodAngle;
+    }
+
+    public double getLaunchRodDirection() {
+        return launchRodDirection;
+    }
+
+    public int getMaxSimulationTime() {
+        return maxSimulationTime;
+    }
+}

or-monte-carlo/src/com/waterloorocketry/openrocket_monte_carlo/SimulationEngine.java

@@ -42,6 +42,8 @@ public class SimulationEngine {
     private final static int CSV_SIMULATION_COLUMN_COUNT = 2; // skip the date column
     private final static int CSV_WIND_LEVEL_COLUMN_COUNT = 3;
 
+    private final Configurator config = Configurator.getInstance();
+
     private final OpenRocketDocument document;
     /**
      * How many simulations we should run
@@ -289,21 +291,27 @@ private void configureMonteCarloSimulationOptions(SimulationOptions opts) {
         log.debug("Cond: Pressure: {}Pa", pressure);
     }
 
+    /**
+     * Generates a reference simulation with default values. Use createMonteCarloSimulations to create
+     * Monte-Carlo simulations based on this reference simulation.
+     * @return Reference simulation with default values
+     * @see SimulationEngine#createMonteCarloSimulations(Simulation)
+     */
     public Simulation generateDefaultSimulation() {
         Simulation defaultSimulation = new Simulation(document, document.getRocket());
         defaultSimulation.setName("Monte-Carlo Simulation");
         SimulationOptions opts = defaultSimulation.getOptions();
 
-        opts.setLaunchLatitude(47.58);
-        opts.setLaunchLongitude(-81.87);
-        opts.setLaunchAltitude(420.0144); // 1378ft
+        opts.setLaunchLatitude(config.getLaunchLatitude());
+        opts.setLaunchLongitude(config.getLaunchLongitude());
+        opts.setLaunchAltitude(config.getLaunchAltitude());
 
-        opts.setLaunchRodLength(11.2776); // 444in
-        opts.setLaunchIntoWind(false);
-        opts.setLaunchRodAngle(0.0872665);
-        opts.setLaunchRodDirection(1.62316);
+        opts.setLaunchRodLength(config.getLaunchRodLength());
+        opts.setLaunchIntoWind(config.isLaunchIntoWind());
+        opts.setLaunchRodAngle(config.getLaunchRodAngle());
+        opts.setLaunchRodDirection(config.getLaunchRodDirection());
 
-        opts.setMaxSimulationTime(2400); // double sim time
+        opts.setMaxSimulationTime(config.getMaxSimulationTime());
 
         return defaultSimulation;
     }

or-monte-carlo/src/com/waterloorocketry/openrocket_monte_carlo/SimulationOptionsFrame.java

@@ -57,7 +57,8 @@ public class SimulationOptionsFrame extends JFrame {
             SIMULATIONS_PROCESSED_EVENT = "simulationProcessed", // fires whenever a batch is processed (updates table)
             SIMULATIONS_DONE_EVENT = "simulationDone"; // fires when all simulations are done (begin export)
 
-    private final int BATCH_RUN_SIZE = 30;
+    private final Configurator config = Configurator.getInstance();
+    private final int BATCH_RUN_SIZE = config.getBatchSize();
 
     private OpenRocketDocument document;