BurnSim vs openMotor

From BurnSim Wiki
Jump to navigation Jump to search

BurnSim is a solid rocket motor (rocket engine) simulator and propellant grain design program for experimental and amateur rocketry. openMotor is a free, open-source internal-ballistics simulator for the same kind of motors, and the tool BurnSim users most often ask about. People usually arrive here with one of two questions: can I open my openMotor designs in BurnSim? and which one should I be using? The short answers are yes, directly - BurnSim 4 reads openMotor's .ric files natively - and BurnSim, if you want the simulation to match your static fires: it models erosive burning, works out propellant thermochemistry from an ingredient list, and fits burn-rate coefficients to your own test data, none of which openMotor does today.

The two are licensed differently, and it is worth being plain about it. openMotor is free and open source (GNU GPL v3), written in Python/PyQt. BurnSim is commercial, closed-source software: a personal license is $49, it is free for students and educators, and there is a free trial - the full program, every feature except saving files, for five days - so you can run your own motors through both before deciding. Because your openMotor designs import directly, trying BurnSim costs nothing but the time it takes to open a file. See burnsim.com.

Both run on Windows, macOS and Linux, so platform is not a reason to pick one over the other. The differences that matter are in the physics each one models and the workflow around it.

Which one should you use?

Where BurnSim is the better choice

  • Erosive burning. BurnSim 4 models the burn-rate augmentation that high mass flux causes down a long, tight core. openMotor computes and reports mass flux, and will warn you when it exceeds a limit you set, but does not feed it back into the burn rate - its own README lists erosivity simulation under planned features. If your motor has a high length-to-port ratio or a low port-to-throat ratio, this is the single biggest modeling difference between the two, and it shows up exactly where it matters: the early pressure peak that decides whether a case survives.
  • Propellant thermochemistry. BurnSim computes C*, combustion temperature, gamma and molar mass from an ingredient list, so a propellant you are formulating yourself does not need those numbers sourced from elsewhere first.
  • Characterizing propellant from your own static fires. BurnSim imports measured test data, overlays it on the simulation, and will fit burn-rate coefficients to it. This is the workflow openMotor has least to say about, and it is the one that turns a simulation into a calibrated one.
  • Nozzle design. Divergence angle feeds BurnSim's thrust coefficient rather than being assumed ideal. The nozzle optimizer runs the full simulation across a sweep of exit diameters and plots total impulse against each one, so you see not just the best exit diameter but how flat the peak is - which tells you how tightly that dimension actually needs to be held.
  • Throat erosion and slag use the same two coefficients openMotor does, so this is not a gap in either direction, and imported openMotor coefficients convert directly.
  • More grain geometries, including Tablet, Tapered Core and Tapered Finocyl, which have no openMotor equivalent.
  • Custom grains from more sources - DXF, SVG, and traced raster images, as well as a built-in shape editor.
  • A printable motor report - one page with the headline numbers, the grain stack, the nozzle and the Kn, pressure and thrust curves, saved as a PDF to file alongside a static test or a certification build.
  • Batch mode, for sweeping a design or running simulations from a script without opening the UI. Note this one is not available on an educational license or in trial mode - it needs a paid personal or commercial license, which is worth knowing if scripted runs are the reason you are reading this page.
  • Named snapshots that live in the motor file. BurnSim can store the complete state of a motor under a name, with notes and a timestamp, inside the .bsx itself - so alternative designs come back when you reopen the file and travel with it if you send it to someone. Both programs have undo (see below); this is the different thing, a saved record rather than a session's history.

Where openMotor has the edge

  • It is free, and it is open source. No purchase, no license, no activation. For a first motor, or anyone who simply wants to check a number, that matters more than any feature list.
  • You can read and change it. It is Python, under the GPL. If you want to see exactly how a result was computed, script it, or bend the model to something unusual, you can - and BurnSim, being closed source, cannot offer that at any price.

Things that are true of both

Worth saying plainly, because comparison pages tend to invent differences here: both run on Windows, macOS and Linux; both work in metric or imperial; both have a propellant editor with an unlimited user library; both support pressure-dependent burn rate with Saint-Robert coefficients; both show grain regression visually while you edit; both export .eng; both have multi-level undo and redo, kept for the session and not written into the saved file; and both regress arbitrary cross-sections numerically rather than relying on closed-form formulas - openMotor with the Fast Marching Method, BurnSim with a pixel-based eroder - so a shape either one can describe is a shape it can burn. Neither is a substitute for measuring your own motors, and both say so.

Opening an openMotor design in BurnSim

This is the quickest way to compare the two on your own motor: import it, run it, and put the curves side by side.

File → Import openMotor (.ric)... reads the file openMotor saves. There is no converter to install and no intermediate format - BurnSim parses the .ric YAML itself and builds a motor you can simulate immediately.

What comes across: the nozzle (throat and exit diameter, plus throat erosion and slag coefficients), the propellant (density, and every pressure band of openMotor's tabular burn-rate model, each becoming a BurnSim pressure-vs-performance row), the chamber/case configuration, and every grain in the stack with its dimensions and inhibited-end count.

File versions 0.4.0 through 0.6.2 are supported. An older file is refused rather than guessed at - openMotor's own migration chain would upgrade it, and BurnSim does not replay that - and so is a file newer than this importer was written against, since it may use fields BurnSim would silently misread.

How the grain types map

All eleven of openMotor's grain types import. Several of them land on a BurnSim type with a different name, which is why the stack you get may not look like the one you left:

openMotor BurnSim 4 Notes
BATES BATES
End Burner Tapered Core With core length 0, which is BurnSim's plain end burner. Burns from the one open face, as openMotor's does.
Conical Tapered Core A full-length core tapering between the two end diameters. openMotor's aft core diameter becomes BurnSim's mouth.
D Grain D-Grain
Moon Burner Moon Burner
X Core X-Core
C Grain C-Slot
Star Grain Star Grain
Finocyl Fin-o-cyl Inverted fins are not imported - see below.
Rod and Tube Custom Built as three concentric rings. Not an approximation: the nesting rule reproduces the shape exactly.
Custom Grain Custom openMotor's DXF-derived cross-section, carried over as a BurnSim custom shape.

What does not come across

The importer reports each of these as a warning at the end of the import rather than failing or quietly dropping it. Read that list - it is the difference between a motor that means what you think and one that does not.

  • C-star is derived, not read. openMotor has no characteristic-velocity field; it computes C* from combustion temperature, gamma and molar mass whenever it needs one. BurnSim needs C* as a value up front, so the import derives it the same way, and warns that it did. Check the imported figure if you can - against a measured or published C* for the propellant, or, if you know the formulation, by letting BurnSim compute it for you: its propellant thermochemistry calculator works out C*, combustion temperature, gamma and molar mass from an ingredient list, which is a better number than one back-derived from three imported fields. Note that a .ric file carries no ingredient list - only density and burn-rate coefficients - so the formulation is something you enter once on the BurnSim side.
  • Nozzle erosion and slag both convert as of BurnSim 4.0.0.23, which added Erosion coeff and Slag coeff on the Motor and Nozzle tab, modeled on openMotor's own terms. The importer converts both coefficients directly and warns about neither. openMotor's Throat Erosion Coefficient is in m/(s·Pa) and BurnSim's is in in/sec/psi; its Slag Coefficient is in (m·Pa)/s against BurnSim's in·psi/sec. Both are radial rates in both programs, so the conversion is units only. BurnSim keeps its original flat Throat erosion rate as well and all three terms add up during the burn, so an existing motor that set the flat rate is unaffected. If you are importing into 4.0.0.22 or earlier, neither is carried over - the importer warned about both rather than converting them - so check your version before trusting an eroding nozzle through the import.
  • Inverted-fin Finocyls are skipped. openMotor can invert a Finocyl's fins so they are propellant standing in a void rather than slots cut into the core. BurnSim's Fin-o-cyl has no inverted geometry, so such a grain is refused with a warning instead of imported as its non-inverted twin.
  • A Rod and Tube support diameter is dropped. openMotor can mask out an innermost core as permanently excluded - neither propellant nor burning void. BurnSim's custom shapes are propellant-or-void only, so the rod imports solid to its axis. The grain will have slightly more propellant than the original.
  • Multi-polygon custom grains import as one void per polygon, with no propellant nesting between them. This matches openMotor's own rasterization, and openMotor itself calls these experimental.

A note on units

openMotor stores everything in SI, converting with a 39.37 in/m factor rather than the exact 39.3700787..., so a dimension typed as a clean inch value does not survive the trip unchanged - a 1.125" core is stored as 0.028575057150114304 m. BurnSim deliberately converts back with the same truncated factor, which undoes the error and recovers the number you originally typed, instead of using the exact factor and handing you 1.1250022". Imported dimensions should look like the ones you entered in openMotor.

Going the other way

BurnSim does not write .ric files. openMotor, however, lists BurnSim importing and exporting among its own features, so the return trip is openMotor's job rather than BurnSim's - export a BurnSim file from openMotor and open it in BurnSim, or export one from openMotor to move a design out. The .ric path described above is the direction BurnSim itself implements and tests.

Both programs export .eng thrust curves (File → Export ENG... in BurnSim), which remains the easiest way to get a motor from either one into a flight-simulation package such as OpenRocket or RASAero.

See also

Retrieved from "https://wiki.burnsim.com/index.php?title=BurnSim_vs_openMotor&oldid=384"