Keyboard shortcuts

Press ← or → to navigate between chapters

Press S or / to search in the book

Press ? to show this help

Press Esc to hide this help

Solid motors

Learn how to fly a commercial solid motor in HPR Sim, and how it models the thrust curve, propellant burn, mass and ejection delay.

In short

  • What it models: commercial solid motors: the thrust curve and its statistics (total impulse, burn time, average thrust, class), and how the propellant burns away. It also models the motor’s mass, center of mass and inertia as it burns, thrust at altitude, and ejection delays.
  • Sources: NASA SP-8039 (1971), the National Association of Rocketry’s Standard Motor Codes, ThrustCurve.org’s glossary, statistics page and code, and RocketPy 1.13.0’s motor code.
  • How well it is validated: by analytic tests (exact answers worked out by hand) and by another code (code-to-code). Those are the first and third of the four kinds of evidence. Small numbers here are in scientific notation, and a relative difference is a fraction of the value compared. ThrustCurve.org’s own statistics code agrees to 3e-15, relative, on all 412 files that pass the 1% check, once its averaging of two or more samples at the same time is turned off on the 8 files that have them. With that averaging on, as ThrustCurve.org runs it, 6 of the 412 differ in at least one of total impulse, burn time, average and peak thrust, by up to 6.5% (a peak thrust), and one of them would fail the 1% check (Validation). On three of the 32 curves first bundled, RocketPy’s total mass and inertias agree within 7.9e-5 relative, the centers of mass within 5.9e-6 of the motor’s length. The propellant’s own mass and inertias agree within 1e-4 of their values at ignition. OpenRocket 24.12 reads the same 32 curve files. On each it gets exactly the same total impulse, peak thrust, burn-time window and curve duration. Its average thrust differs by definition: HPR Sim’s is +0.0107% to +0.3147% higher. Nothing else in this model is compared with OpenRocket: not the propellant’s burn-back, its mass and inertias, or the delays. The files that fail the 1% check have only that check against ThrustCurve.org’s figures so far (the whole catalog). Nothing here is compared with a real flight.
  • What it leaves out: anything but commercial off-the-shelf solids. The 80 catalog motors with no curve file that reads can’t fly (the whole catalog). Propellant burns in proportion to the impulse delivered, an approximation. With only catalog data, the center of mass stays at mid-length. Commercial motor files give no nozzle exit size, so thrust at altitude goes uncorrected unless one is supplied. Grain temperature isn’t modeled either: every motor flies its certified curve, fired with the grain at about 15 to 25 °C. A grain 10 K warmer delivers 0.1% to 0.8% more impulse, which adds 0.06 to 1.3% to apogee. Its shorter, harder burn moves apogee by −0.2 to +0.4% too, or by +1.1 to +2.2% for a slow, long burn. So on a hot day the predicted apogee can read low, the flattering side for a waiver. A grain 20 K cold loses 0.1% to 2.6% of apogee to impulse alone. These figures are borrowed from military and sounding-rocket motors. One hobby test of 71 F-class motors agrees (+0.2% impulse per 10 K) (propellant temperature, hobby firings).

Using a motor

A flight needs a motor in the rocket’s motor mount. There are two ways to get one:

Either way, the motor then goes into one of the rocket design’s configurations. A short program, crates/hpr-sim/examples/motors.rs, shows all of this: it counts the built-in motors and lists one of each class with a passing file, reads a .eng file, and flies that motor in a rocket. Run it from anywhere in the repository (the setup is on Getting started):

cargo run --example motors -p fusionspace-hpr-sim

It prints this. The output is committed in motors.output.txt. CI runs the program on macOS, Windows and Linux and fails if it prints anything else. So the counts and rows below are always the code’s.

1004 motors come built in, 924 of them with a curve file. One of each class:

                                           dia  length    loaded       total   average    burn
designation  maker     type        class    mm      mm    mass g impulse N·s  thrust N  time s
B4           Quest     single-use  B        18      80      19.8         4.9       4.4    1.11
C5           Estes     single-use  C        18      70      23.8         7.8       3.9    1.98
D5           Quest     single-use  D        20      96      45.1        17.6       3.8    4.59
26E31-15A    Cesaroni  reload      E        24      69      52.0        26.1      30.7    0.85
F30FJ        AeroTech  single-use  F        24      90      70.0        47.1      30.4    1.55
G142         AeroTech  single-use  G        29     113      97.6        84.6     136.5    0.62
166H175-14A  Cesaroni  reload      H        29     231     247.0       166.1     175.0    0.95
I175WS       AeroTech  single-use  I        38     214     348.0       333.2     177.5    1.88
644J94-P     Cesaroni  reload      J        38     367     660.0       644.6      95.0    6.79
K750ST       AeroTech  reload      K        75   266.7    1948.0      1296.7     741.8    1.75
2645L265-P   Cesaroni  reload      L        54     649    2481.0      2646.0     267.3    9.90
M1350W       AeroTech  single-use  M        75     622    4808.0      5179.5    1350.1    3.84
N3120X-PS    AeroTech  single-use  N        75    1156    8200.0     10369.1    3125.1    3.32
21062O3400-P Cesaroni  reload      O        98    1239   16842.0     21041.0    3424.3    6.14

From the .eng file: I377CT by Loki, 38 mm by 292 mm, 560 g loaded, 250 g of propellant
  525.8 N·s (class I), 377.9 N average over 1.39 s, 657.0 N peak
  effective exhaust velocity 2103 m/s

Valetudo on the I377CT: 8.82 kg at liftoff
  leaves the 3 m rail at 17.7 m/s
  apogee 151.7 m above the pad, at 6.09 s
Not yet validated: see the Accuracy page before trusting these numbers.

The whole program is at the end of this page.

The bundled motors

Each curve is a ThrustCurve.org file, bundled unchanged, under the license the whole catalog gives. The size, masses and delays come from its header, and the rest is worked out from its curve. Its ThrustCurve.org record’s impulse, thrusts and burn time are bundled too, as published facts with credit (third-party notices). They aren’t the maker’s data. Each file is checked against them: its total impulse, average thrust and burn time must each be within 1% of the record’s to pass. A gap is the file’s figure less the record’s, as a share of the record’s, so + means the file reads high. A motor flies a passing file where it has one, else the first by format and by who measured it. Flying a failing file in hpr sim warns, naming each failing figure: burn time +2.00%. So does a failing mass check (below). The library gives the same warnings: Rust’s Motor::from_catalog keeps them in warnings(), and Python’s raises each as a UserWarning. Check such a file against the maker’s data. hpr motors show lists each file with its check. cargo xtask motor-catalog writes the catalog, and a test fails if the committed one differs.

columnwhat it iswhere it comes from
designationThe motor’s full name (motor designation)the motor’s name, as ThrustCurve.org lists the file
makerThe manufacturer, abbreviatedas ThrustCurve.org lists the file
typesingle-use, or reload: a propellant load for a reusable caseas ThrustCurve.org lists the file
classThe impulse class letterHPR Sim, from the curve
dia, lengthThe case’s diameter and length, mmthe file’s header
loaded massThe motor ready to fly, g. For a reload this includes the casethe file’s header
total impulseTotal impulse, N·sHPR Sim, from the curve
average thrustAverage thrust, NHPR Sim, from the curve
burn timeBurn time, sHPR Sim, from the curve

Before the lookups moved to the whole catalog, 32 of these motors were the only ones built in. How those 32 were chosen:

  • They were public-domain ThrustCurve.org curves of motors in production.
  • When they were chosen (September 17, 2026), each curve’s total impulse, burn time and average thrust were within 1% of the values ThrustCurve.org publishes for the motor. Peak thrust is not held to it: it runs from 16.7% below (Cesaroni 26E31-15A) to 2.1% above (Loki M1378LR).
  • The files’ headers differ from ThrustCurve.org’s records in a few places, and the header is what the simulator flies. Five lengths differ, from 1.2% shorter (the B4) to 1.3% longer (the N3300R). So do 7 propellant masses, from 2.7% lighter (the C5) to 52% heavier (the 26E31-15A). So do 6 loaded masses, from 4.0% lighter (the C5) to 2.3% heavier (the D5). For the 26E31-15A the header is the likelier: the record’s 11.1 g of propellant would need an effective exhaust velocity of 2,350 m/s (7,710 ft/s) for its 26.1 N·s, more than every one of the 32 but the K400C. The delays are the header’s too, which often lists fewer settings than the maker sells.
  • There were up to three per impulse class, from different manufacturers, none in class A.
  • The selection, and the curves left out, are in the ThrustCurve.org data notes.

In code, Catalog::bundled() returns the list (Catalog). catalog.find("I377") finds a motor by its designation or common name, ignoring case, spaces and hyphens. A leading maker name keeps only that maker’s motors (Estes C6). A motor whose designation is the name outranks one whose common name is: D5 is Quest’s D5, not the D5-P. Otherwise it returns every match: I175 finds both the AeroTech I175WS and the Cesaroni 411I175-14A. Then entry.bundled_motor() builds the motor (CatalogMotor), with the catalog’s size and masses. The catalog doesn’t say where inside the motor its mass sits, so the simulator uses a rough guess, the envelope default. The propellant and the rest of the motor (case, nozzle and closures) are each spread evenly along its length. So the center of mass stays at mid-length as it burns (The whole motor gives the details).

The whole catalog

hpr-motor carries a copy of ThrustCurve.org’s whole solid catalog, taken on October 28, 2026: the record of every single-use and reload motor, 1,004 of them, in production or not, and 1,701 of the 1,706 files listed for them. Every lookup reads it: hpr motors, hpr sim --motor and a design’s motor (every motor by name). 32 designations are shared by several makers. Such a motor’s selector, the name that finds it alone, is its maker’s short name and designation; hpr motors list --json gives each motor’s selector.

  • Each motor’s names and stated figures are its record’s, unchanged. Its listed figures are its default file’s own: a passing file where it has one, else the first by format and by who measured it. The 80 motors with no file that reads list their record’s figures, and can’t fly: hpr motors list names them in a closing note, and hpr motors show and hpr sim --motor refuse them.
  • Each file is stored with its 1% check, passing or not. 412 of the 1,701 files pass, and 239 of the 924 motors with a file have one that does. The other 685 fly with a warning naming each failing figure.
  • ThrustCurve.org’s statistics code checks the figures of the 412 files that pass (Validation). The 1,289 that fail have only the 1% check. The comparison with OpenRocket and the .eng/.rse round trip cover the 32 files first bundled. The round trip over every file is planned (issue #1002).
  • Of the 1,701 indexed files, 589 are public domain, 33 free to use, and 1,079 carry no license; none is marked restricted. The third-party notices say how each is used.
  • Five files are left out, each listed in the index with its reason:
    • two RockSim files whose times run backwards;
    • three whose header’s diameter is more than 10% from the record’s, either way: two give 75 mm (3.0 in) for a 54 mm reload (Loft lesson L43), and one 38 mm (1.5 in) for a 29 mm single-use motor. Every other header sits within 7.3% of its record (four files give a Pro150 reload’s 150 mm (5.9 in) where the record gives 161 mm (6.3 in)); the three are 31% to 39% off. Sizes closer than 10% apart, such as 152 mm (6.0 in) and 161 mm (6.3 in), aren’t told apart.
  • 48 motors’ default files give a propellant mass more than 5% below their record’s, and warn; 151 more than 5% above it, which alone doesn’t (issue #1003). Either side may be the wrong one.
  • 36 of the 840 motors whose file and record both give a loaded mass are more than 5% apart, 17 heavier and 19 lighter (issue #1233), and warn, naming both. The Quest D8’s file gives 454 g (16 oz), its record 45.6 g (1.6 oz). Either may be wrong; if the record is right, a heavier file gives too low an apogee, a lighter one too high a margin. A propellant share outside the records’ span, about 11.5% to 75%, warns too (the D8’s 4.8%). With the loaded mass within 5%, a burnout mass (loaded less propellant) more than 5% from the record’s burnout mass, either way, warns: 208 more. cargo xtask motor-catalog prints them.
  • What still passes unwarned: a burnout mass (the empty case) up to 5% from the record’s, either way, while the loaded mass is within 5%; past that the burnout check doesn’t run, and the loaded-mass warning fires instead. A light case, aft of the center of gravity as on nearly every rocket, moves it forward, so the margin after burnout reads high. On RocketPy’s Calisto, a case 5% light adds 0.037 calibers; the earlier bound allowed 0.098 (issue #1294).

Online, hpr motors update caches the motors and files ThrustCurve.org’s records show as added since; it can miss a file swapped for another under an unchanged record (newer motors). Offline, it prints the bundle’s date, counts and size:

$ hpr motors update --offline
The bundled catalog: ThrustCurve.org's solid motors as of 2026-10-28
  motors           1004, 924 with a file that reads
  files            1701, and 5 left out
  passing          412 files within 1% of their records, of 239 motors
  size             4.2 MB (4196056 bytes)
note: offline, with no whole update cached; online, `hpr motors update` looks for motors and files newer than 2026-10-28
Motor data and thrust curves courtesy of ThrustCurve.org, https://www.thrustcurve.org/

python3 validation/oracles/thrustcurve/snapshot.py takes a fresh snapshot, and cargo xtask motor-catalog writes the index from it. The command names each file it expects to leave out by its id; any other file left out fails it.

A motor from a file

Motor files come in two formats, and ThrustCurve.org serves both:

  • RASP .eng, a plain-text format named after RASP, the rocket simulation program it comes from. It is the more common of the two: 889 of the 1,712 solid-motor files ThrustCurve.org held when surveyed.
  • RockSim .rse, an XML format from the RockSim simulator.

The example reads a .eng file in four steps:

  1. Read the text. For a file you downloaded, use std::fs::read_to_string("my-motor.eng")?. The motor crate never opens files itself. The example builds one of the bundled files into the program with include_str! instead, so that it runs anywhere.
  2. Parse it. eng::parse(&text)? (eng::parse) returns the file’s entries, one per motor (a file can hold several), and a list of warnings. The reader is lenient: it accepts the oddities real files have and reports each one, with its line number (reader policy). This file reads with no warnings.
  3. Take the curve. entry.thrust_curve()? makes the thrust curve, starting it from zero thrust at ignition.
  4. Build the motor with SolidMotor::from_envelope(curve, diameter_m, length_m, propellant_kg, loaded_kg) (SolidMotor). A .eng header gives the size in millimeters and the masses in kilograms. So the example multiplies the size by 0.001 and passes the masses as they are. Check that step yourself: the motor can’t tell a size left in millimeters. The units check looks at the impulse and the propellant mass, not the size, so any positive size is accepted. If the same size goes into the rocket, the design checks stop the flight for a diameter too wide for the mount. A length too long for it only draws a warning (Putting it in a rocket).

For a .rse file, use rse::parse (rse::parse) instead. Its motors are in engines rather than entries. Its masses are in grams (initial_mass_g, propellant_mass_g), so multiply those by 0.001 too. Forget it for the propellant, and the units check catches it: the exhaust velocity is 1,000 times too small, and the motor is refused. The check sees only the propellant mass. Forget it only for the loaded mass, and the motor is accepted as 1,000 times heavier.

The file here is Loki Research’s I377. The program prints what it read, 38 mm by 292 mm (1.50 by 11.5 in), 560 g loaded with 250 g of propellant. From the curve it works out 525.8 N·s, an I motor, averaging 377.9 N over 1.39 s. Its effective exhaust velocity, 2,103 m/s (6,900 ft/s), is well inside the check’s range.

Three things to know about a motor built from a file:

  • The header can be wrong. Whoever made the file typed its size and masses. Of ThrustCurve.org’s 554 public-domain files, 66 headers give a length more than 1 mm (0.039 in) off the catalog’s. Five give a diameter more than 0.5 mm (0.020 in) off (data notes, section 4). The bundled motors fly their headers’ values too. cargo xtask motor-catalog refuses a file whose header diameter is more than 10% from its record’s. In Loft, one header listed a 54 mm motor as a 75 mm motor (Loft lesson L43). For any other motor, check the header against the motor’s page on ThrustCurve.org.

    A motor fetched from ThrustCurve.org gets one more check, against its record: a propellant mass over 5% below the record’s draws a warning naming both (PROPELLANT_SHORT_BOUND). With the file’s loaded mass right, that flies too heavy a burnout mass and too low an apogee, the side that flatters a waiver. A heavier one draws none, and the loaded mass isn’t checked (survey, section 5).

  • Where its mass sits is a rough guess, the envelope default (The whole motor). If you know the grain sizes, SolidMotor::new with Propellant::Grains does better (Where the propellant is).

  • Its nozzle size is unknown, so its thrust is not corrected for altitude (Thrust at altitude).

Putting it in a rocket

A rocket design keeps its motors in configurations: named sets of motors, at most one in each motor mount (Motors and configurations). The example adds one to Valetudo, the rocket of Getting started: a Configuration with the id from-file, holding one MountedMotor.

field of MountedMotorwhat it holds
mountThe id of the mount in the design, here motor-mount
designationA name, for display
diameter_m, length_mThe case’s size, in meters. The design checks compare the diameter with the mount’s bore: a motor wider than its mount is an error, and the flight refuses to start unless design errors are accepted (--accept-design-errors) or a nominal size’s real case fits (a nominal motor in its matching tube). A case that reaches forward past the mount’s top is only a warning
motorThe motor built above
delayThe ejection delay chosen, if any. A parachute can fire on it, with the MotorDelay trigger (Recovery)

Valetudo’s mount is 43 mm (1.7 in) inside, so this 38 mm motor fits. Simulation::new(&rocket, "from-file", ...) then flies the configuration by its id: straight up from a 3 m (9.8 ft) rail, in calm air, with no parachutes. The rocket weighs 8.82 kg at liftoff and leaves the rail at 17.7 m/s (58 ft/s). It reaches 151.7 m (498 ft) above the pad at 6.09 s. These flight numbers are not validated (evidence row G24). See Accuracy before trusting them.

A design file holds configurations in the same form, as JSON, with the motor written out in full. See the configurations list at the end of the Valetudo design. Every motor lights at launch, t=0, unless its ignition says otherwise: at a time, after another motor’s burnout, or after its stage separates (Staging). It then burns on its own clock from that moment.

Code and conventions

Where the motor code lives, its sources, and the units and axes it uses.

Code and sources

Code: hpr_motor (API reference), in its modules curve, class, motor, grains, mass, delay and catalog. The file formats are described in .eng files and .rse files.

Each source has a short key in square brackets, used below. A source that can be downloaded is pinned. Its address and a checksum of its bytes are in the reference lock file, under the name given. So anyone can fetch the same copy (Checking a claim).

Line numbers below, such as “lines 40–91”, link to those lines of the source.

Conventions

  • Time t is seconds from ignition.
  • Positions are meters along the motor’s axis from the nozzle exit plane (where the exhaust leaves) toward the forward closure (the motor’s front end). So +z points toward the nose, like the body frame (Frames). The design model places the motor’s nozzle exit in the body frame (its milestone).
  • Every part is symmetric about the axis. Ia is about the axis and It about a transverse axis, both through the part’s own center of mass (RocketPy’s I_33 and I_11).
  • Motor files keep their own units (mm, kg or g). The model is SI: meters, kilograms and seconds.

The model

How a motor’s thrust, propellant, mass, altitude effect and delay are worked out.

Thrust curve

A thrust curve is the motor’s thrust against time, as its file lists it.

  • Samples (ti,Fi) joined by straight lines, as [RP] reads them (interpolation_method "linear"). Before the first sample the curve starts from (0,0) when t0>0, as the RASP format specifies (.eng files) and TC-A integrates. From the last sample on F=0, that instant included. Like any step, the end takes the later value. So at burnout the thrust, the mass flow and the propellant left are all zero together.

  • Equal consecutive times are a step: the later value holds from that time on. Real files use them for an abrupt burnout. Decreasing times and negative thrust are rejected, and so is a curve with no impulse or no burn time (defined below).

  • A sample is delivered when it starts or ends a stretch of the curve that lasts some time (ti<ti+1 or ti−1<ti). The thrust then really takes its value. A sample that starts a stretch is reached at its own instant. One that ends a stretch is approached ever closer as time runs up to its instant. A sample strictly inside a run of three or more equal times is never delivered: the step jumps straight past it. Nor is the first sample of a step at the curve’s start, or the last of a step at its end. Peak thrust is the largest delivered sample, which is exactly the most the curve’s thrust reaches. The burn-time crossings below compare only delivered samples with the threshold. For example, times 0, 1, 1, 1, 2 s and thrusts 10, 10, 1000, 10, 0 N hold 15 N·s. The step skips the 1,000 N sample, so the thrust never exceeds 10 N, and 10 N is the peak. The burn runs from 0 to 1.95 s. Counting the skipped sample would set the 5% threshold at 50 N, above anything the curve delivers. The curve would then be refused (the decision record, issue #10, the report of the refusal). A one-off run over the surveyed ThrustCurve.org files found no file whose statistics change. Its scripts are not committed; the decision record has the counts.

  • Before integrating, TC-A drops leading points below 500 µN and averages points closer than 50 µs (lines 40–91). HPR Sim keeps leading zeros and treats equal times as steps. On the 412 files that pass the 1% check, the results agree to 3e-15 on all but 6, each with repeated times, where the averaging moves at least one of total impulse, burn time, average and peak thrust, by up to 6.5% (Validation). A survey on September 17, 2026 read 1,710 of ThrustCurve.org’s 1,712 solid-motor files. The two agreed to 1e-9 on all but 17 with repeated times, and on those differed by up to 1.1% in average thrust. HPR Sim keeps the step because a vertical drop is what the file draws.

  • Total impulse: the exact integral of the lines (SP glossary p. 96: I=∫Fdt),

    I=∑i12(Fi+Fi+1)×(ti+1−ti).

    I(t) is the same sum up to t, with the partial interval.

  • Burn time follows the rule of NFPA 1125, as ThrustCurve.org applies it. NFPA 1125 is the US National Fire Protection Association’s code for making model and high-power rocket motors. The burn runs from the moment the thrust first reaches 5% of peak to the moment it last falls to 5% of peak. Each crossing is interpolated on its segment (TC-G “Burn Time”; TC-S; TC-A lines 165–203). The peak and the crossings use delivered samples only (above). The last sample’s time is not the burn time (Loft lesson L39: Loft took it as the burn time).

  • Average thrust: total impulse over the NFPA 1125 burn time (TC-G “Average Thrust”; TC-A line 231).

    • TC-S says instead “the total impulse during the 5%-defined burn time”. The two differ by the impulse outside the window, a median 0.13% on ThrustCurve’s public-domain curves (data notes). HPR Sim follows the glossary and the site’s code.
  • Impulse class: each letter covers twice the total impulse of the one before. A goes up to 2.5 N·s, B to 5, C to 10, and so on. In general upper(k)=1.25⋅2kNs, from 1/8A (k=−2) to O (k=15), and on to Z by doubling. Upper limits are inclusive: NAR states C as “5.01 to 10.0 N-sec”. Loft gave B for 2.5 N·s (Loft lesson L38).

Propellant consumption

The effective exhaust velocity c is the thrust divided by the rate at which propellant mass leaves, c=F/m˙ (SP glossary p. 95). Held constant through the burn, it makes the propellant burned proportional to the impulse delivered so far. When half the impulse has been delivered, half the propellant is gone. With I the total impulse, I(t) the impulse delivered by time t, and mp0 the propellant at ignition:

c=Imp0,m˙(t)=F(t)c,mp(t)=mp0(1−I(t)I)
  • This is [RP] SolidMotor (solid_motor.py:401-418; motor.py:483-524). ThrustCurve’s .rse files tabulate their mass column the same way (.rse files).
  • Holding c constant is an approximation. SP gives c in instantaneous form, F/m˙p with m˙p the propellant’s mass flow (p. 95). Measured specific impulse (Isp, the same quantity divided by standard gravity) drifts during a burn as the nozzle erodes: one motor lost 6 to 9 s of specific impulse by burnout (SP p. 14). Its efficiency also differs with the pressure inside the motor, in a comparison between motors rather than along one burn (SP Fig. 18, p. 40, which plots vacuum specific-impulse efficiency against chamber pressure). So real consumption is not exactly proportional. No data published for commercial motors resolves the difference.
  • All propellant is gone at the last sample. The whole burned mass leaves as exhaust. Inert material that also leaves (bits of liner and igniter) is not modeled.

Where the propellant is

  • Column (Propellant::Column): a hollow cylinder (R,r,L) (outer radius, inner radius, length) at a fixed center. It keeps its shape and loses density as it burns, so

    Ia=12mp(R2+r2),It=mp(R2+r24+L212)

    This is [RP] GenericMotor’s model (motor.py:1580-1649, a solid cylinder).

  • BATES grains (Propellant::Grains): N identical BATES grains (R,r0,h0) (outer radius, starting bore radius, starting height), spaced h0+s apart, with a gap s between them. Each burns on its bore, the hole along its axis. It also burns on both ends unless the ends are inhibited: coated so that they can’t burn ([RP] solid_motor.py:487-632).

    • Every grain needs a bore (r0>0). A solid end burner is a grain with no hole that burns only on one face. It shortens without widening. This regression (the way the grain burns back) doesn’t describe that, and neither does RocketPy’s.
    • Facing ends burn even with no gap, as in [RP].
    • Every burning surface recedes by the same depth x, the web burned so far (the web is the thickness of propellant between the burning surfaces). The first formula holds with the ends burning, for x≤min(R−r0,h0/2); the second with the ends inhibited, for x≤R−r0:
    V(x)=π(R2−(r0+x)2)×(h0−2x),V(x)=π(R2−(r0+x)2)×h0,

    and

    NρV(x)=mp(t)

    Here V is one grain’s volume and ρ the propellant’s density, so the last line says the N grains hold the propellant left.

    • [RP] integrates r˙=−V˙/Ab, h˙=−2r˙ in time, with Ab the burning area. It uses LSODA, a general-purpose solver for ordinary differential equations (ODEs), from the Python library SciPy. Because dV/dx=−Ab, that ODE is the relation above. HPR Sim solves it for x by safeguarded Newton iteration, exactly at any time. That is Newton’s method, which improves a guess using the slope, kept inside an interval known to hold the answer. A step that would leave the interval halves it instead.

    • mp0=NρV(0) comes from the geometry, as in [RP].

    • About the stack’s center, which doesn’t move:

      Ia=12mp(R2+r2),It=mpR2+r24+mph212+mpN(h0+s)2×N(N2−1)12

      The last term sums mgdk2 over the grain offsets ([RP] solid_motor.py:724-740, 784-789).

The whole motor

  • The dry mass (case, closures, liner, nozzle: everything but the propellant) is one element: mass, center and inertias about its own center. with_added_dry_mass joins more hardware, such as a retainer (the cap or clip that holds the motor in its mount). It must be positive: at burnout it is the whole motor, and with no mass it has no center.

  • The motor is the dry mass and the propellant combined about the instantaneous center with the parallel-axis theorem:

    z=1m∑kmkzk,Ia=∑kIa,k,It=∑k(It,k+mk(zk−z)2)

    This is [RP] Motor.I_11 (motor.py:585-666).

  • The envelope default (SolidMotor::from_envelope) applies when only the motor’s size and masses are known, as from a catalog entry or a motor file’s header:

    • the propellant is a solid column of radius D/2 filling the length, centered at L/2;
    • the dry mass (loaded minus propellant) is a thin tube, Ia=mr2 and It=m(r2/2+L2/12), also centered at L/2.

    These are crude: the center of mass stays at L/2 throughout. Loft fixed the CG at the midpoint with no inertia of its own (Loft lesson L40). HPR Sim gives the parts inertia, and moves the CG as soon as the dry and propellant centers differ.

    • ThrustCurve’s loaded mass includes the reusable case (TC-G “Total Weight”: “propellant and case”).
    • [RP] GenericMotor.load_from_eng sets its chamber radius to the motor diameter (motor.py:1759-1761). That quadruples the r2 inertia terms (and the default nozzle area it derives from that radius). HPR Sim uses D/2.
  • A catalog entry’s diameter, length and masses are its curve file’s header values (A motor from a file). ThrustCurve.org’s own records differ in a few places (the bundled motors).

The effective exhaust velocity is a units check

Both constructors, SolidMotor::new and SolidMotor::from_envelope, work out the effective exhaust velocity c=I/mp from the curve and the propellant mass. They refuse a motor whose c is outside 200 to 5,000 m/s (656 to 16,404 ft/s). It is a guard against a slip in the units of the propellant mass, not a filter on propellant:

  • It catches a propellant mass in grams typed where kilograms belong, such as a .rse file’s propellant_mass_g passed unconverted. That moves c by a factor of 1,000. Nothing else in the API notices. Take the 411I175’s envelope typed in millimeters and grams, from_envelope(curve, 38.0, 245.0, 228.9, 437.5). It has positive, finite dimensions and a propellant mass below the loaded mass, and an exhaust velocity of 1.8 m/s (5.9 ft/s). The grams give it away, and the check refuses it.
  • It can’t catch a size in the wrong unit. c doesn’t depend on the diameter or the length, and the motor accepts any positive size. The example’s I377 with its size left in millimeters, from_envelope(curve, 38.0, 292.0, 0.250, 0.560), is accepted, at the same 2,103 m/s (6,900 ft/s). Only the design checks see a size, and only the one given to the MountedMotor (Checks). A diameter wider than the mount’s bore is an error, motor_wider_than_mount, and the flight refuses to start unless design errors are accepted (--accept-design-errors). Within a nominal size’s slack for its narrower case it only warns, motor_tight_in_mount. A case that runs forward past the mount’s top is only a warning, motor_past_mount_top, so a length slip alone still flies. Nor does c involve the loaded mass, so a loaded mass in grams passes too.
  • It lets through every real motor checked. In an earlier survey, the 1,708 ThrustCurve.org files whose motor’s record gives a propellant mass, each taken with that mass, ran from 236 to 3,031 m/s (774 to 9,944 ft/s). Their median is 1,866, and 90% of them are between 928 and 2,210. In the whole catalog, the 924 motors’ default files, each with its own header’s propellant mass, run from 296.83 m/s (973.9 ft/s, a black-powder A8) to 4,128.18 m/s (13,543.9 ft/s, a J228). That highest is no real motor’s: the J228’s header gives 270 g of propellant, where ThrustCurve.org’s record gives 569 g. The guard lets it through, and the J228 flies with 270 g. Since issue #1003 closed, a file more than 5% short of its record’s propellant draws a warning when it flies.
  • Its headroom is real but not great at either end. In the earlier survey both ends are data errors. The lowest, 1.18x above the floor, is a Cesaroni E75 record giving 104 g of propellant for a 52 g motor. The highest, 1.65x below the ceiling, is a misfiled curve. The lowest value NAR’s list backs, a Quest B4’s, is 1.85x above the floor. In the catalog HPR Sim flies, the J228 above is 1.21x below the ceiling. Issue #11 records the fallback if a motor ever falls below 200 m/s (656 ft/s).

I here is the curve’s own impulse, uncorrected for air pressure. The reasoning in full, the table of percentiles, and two figures that were once got wrong are in the exhaust-velocity note.

Thrust at altitude

A motor pushes harder in thinner air. Its thrust has two parts. One is the momentum of the exhaust. The other is a pressure term: the exhaust’s pressure at the nozzle exit less the air’s, times the exit area (SP eq. 2, p. 3; SP-8039’s unit constant gc is 1 in SI):

F=m˙ue+(pe−pa)Ae

Here m˙ is the mass flow and ue the exhaust speed at the exit. pe is the exit pressure, pa the ambient (air) pressure and Ae the exit area. With the flow unchanged, a curve measured at reference pressure pref gives, at ambient pa,

F(pa)=Fcurve+(pref−pa)Ae,Ae=πre2
  • SP doesn’t print this conversion; it follows from eq. 2. [RP] Motor.pressure_thrust (motor.py:1173-1191) applies the same term.
  • pref is the air pressure at the static test site, where the motor was fired on a test stand to measure its curve. It is stored with the nozzle (Nozzle::reference_pressure_pa). Motor files and catalogs don’t record it, so a design gives it, or gives none (below). Standard sea-level pressure (101 325 Pa) suits a motor tested near sea level, but it is a guess. Take a test at 1,500 m (4,921 ft) elevation, 84.6 kPa in the 1976 standard atmosphere. For that motor, sea-level pressure makes the term 16.8 kPa × Ae too large at every altitude.
  • It holds while the exhaust fills the nozzle to its exit. A nozzle made for high altitude, tested at sea level, can have its flow come away from the nozzle wall (separate). Then the conversion doesn’t hold. That is this project’s inference. SP pp. 32–34 say the flow stays attached while the outside pressure is “less than or only slightly greater than” the exit pressure, that an outside pressure “considerably greater” can separate it, and that an overexpanded nozzle delivers less thrust.
  • HPR Sim applies it strictly inside the burn, 0<t<tend (tend the curve’s last time), as RocketPy’s flight does (simulation/flight.py:1936-1956). HPR Sim applies the term only where the curve’s thrust is positive; RocketPy also adds it inside zero-thrust gaps, where nothing flows. HPR Sim never lets thrust go negative. Without a known nozzle it returns the curve. Commercial motor files carry no exit diameter: .eng has no field for one, and the .rse format’s exitDia attribute is always 0 (.rse files). So a motor read from a file or the catalog gets no correction.
  • A nozzle may leave reference_pressure_pa empty (None, null in a design file). The curve is then flown as it is at every pressure, which is what RocketPy does by default: its Motor(reference_pressure=None) makes pressure_thrust zero (motor.py:1188-1189). The designs transcribed from RocketPy’s examples say None for that reason (ADR-021). Take the Valetudo of Getting started, at a 1,400 m (4,593 ft) site. With the sea-level stand-in it carried about 23 N of thrust (15.7 kPa × 1.47e-3 m²) that RocketPy’s example never flies. It reached 874 m (2,867 ft), where it now reaches 779 m (2,556 ft). A design must say which it means. The key is required, null for none, so leaving it out is an error rather than a silent choice. The unit test hpr_motor::motor::tests::pressure_correction_uses_the_exit_area pins both forms and the missing key.
  • The full-flow term steps in just after ignition and steps to zero at tend (the integrator should treat both as events). The ignition transient is the first moments, while the pressure inside the motor builds. The tail-off is the end of the burn, while that pressure falls. In both, the real exit pressure is far from its full-flow value, so the term misstates thrust there. In the tail-off, where the exit pressure falls with the chamber’s, the term overstates thrust. Take the 411I175, with a 9.5 mm (0.37 in) exit radius, 19 mm (0.75 in) across, in vacuum. In the 0.14 s after the NFPA 1125 burn ends, the term adds 3.9 N·s, and the curve itself delivers 0.45 N·s. The 3.9 N·s is 0.95% of total impulse.

Delays

A motor’s ejection delay is the time from burnout to its ejection charge, which deploys the recovery. TC-G lists every achievable delay, adjustable ones included. A plugged motor has no ejection charge, and files mark it P. See hpr_motor::delay and .eng files for the markers files use. A 0 is read as its own “zero or plugged” setting. The RASP spec says it means ejection at burnout, but most files mean plugged. HPR Sim never turns it into an ejection event by itself: the user has to decide.

Validation and example

The tests that pin the motor model, and the whole example program.

Validation

  • Catalog (catalog::tests): every figure the catalog lists is its curve file’s own, bit for bit, so what hpr motors lists is what flies. Each file’s stored check is worked out again from the file and its motor’s committed record. 412 of the 1,701 files pass. For the 32 first bundled, 1% was the bundling rule, and all 32 pass. In Loft, a mis-sourced curve flew about 26% high (Loft lesson L42). Of 554 public-domain curves, 196 passed (data notes, which also list the four motors whose stored values are printed coarser than 1%). Each of those 32 files is public domain, its bytes matching the SHA-256 checksum (a fingerprint of a file’s exact bytes) recorded at download. These checks answer Loft lessons L41 to L43, on curve licenses, loose impulse checks and wrong headers.
  • ThrustCurve’s code (catalog::tests::every_bundled_curve_matches_thrustcurve_statistics_code): validation/oracles/thrustcurve/analyze_stats.js runs TC-A (ThrustCurve.org’s code), its bytes unchanged, on every file stored as passing, 412 of them: once as the site runs it, and once with its merge turned off. It writes the results to a fixture, validation/fixtures/motor/thrustcurve-analyze-stats.json. HPR Sim’s impulse, burn window, burn time, average and peak thrust agree to 3e-15, relative: the largest gap measured is 2.93e-15, and the test fails above 1e-12. A burn window’s start under 1 ms is compared in seconds instead, and agrees to 3e-18 s. So the definitions are checked, not only the 1% rule.
    • Two or more samples at the same time are read differently, on purpose (the decision record). HPR Sim reads them as a step: the thrust jumps from the first value to the second, because a vertical drop is what the file draws. TC-A merges points less than 50 µs apart into one point at their average thrust. 8 of the 412 files have such points. The script also runs TC-A with that merge turned off (its timeEpsilon set to 0), and on those 8 files HPR Sim is held to that run. On 6 of them the merge moves a figure, and the test names each; on the other 2 it moves none. The largest move is in the RockSim file of Cesaroni’s 2372K1440-17A, which has 1,061.8 N and then 2,168.21 N, both at 0.01 s. HPR Sim reads a jump, so its peak is 2,168.21 N. TC-A averages the two to 1,615 N, below the next sample, 2,036.3 N, which becomes its peak. So HPR Sim’s peak thrust is 6.5% higher. Another file’s burn time is 0.61% longer here.
    • The recount (analyze_stats.js --recount) works out which files pass from the raw snapshot ThrustCurve.org answered, with TC-A and not HPR Sim’s code, and fails unless the index agrees. It agrees on all 1,701 files the index holds: 412 pass, and 239 motors have one that does. One file passes with every sample kept and would fail with the merge: Cesaroni’s 2765L730-P file, whose burn time is 0.68% short of its record here and 1.28% short after the merge. The raw snapshot isn’t committed, so the recount runs on the maintainer’s machine, not in CI.
    • CI runs cargo xtask motor-catalog --check. It works out each file’s figures again from its bytes, and fails if a file stored as passing is more than 1% from its record, or a file stored as failing is within 1% of it.
  • OpenRocket (catalog::tests::openrocket_s_total_impulse_matches_every_bundled_curve): validation/oracles/openrocket/motors.py hands each of the same 32 files to OpenRocket 24.12’s own motor loader. It records what the loader makes of it in validation/fixtures/motor/openrocket-curve-stats.json, tied to each file by its SHA-256. The two codes are compared on the same bytes, so what is measured is the arithmetic, not two catalogs’ data for one motor. Four numbers are identical, to the last bit of an f64, on all 32 curves. They are total impulse, peak thrust, the 5%-of-peak burn-time window (OpenRocket’s getBurnTimeEstimate) and the curve’s whole duration. That duration is OpenRocket’s getBurnTime, the last listed time rather than a window. The test holds the impulse to the 0.1% that M2.2c asks for, met with everything to spare. It also asserts the bit-for-bit equality, so this paragraph cannot go stale while the suite stays green. Both codes integrate the listed points as straight lines. Both prepend (0, 0) to a file whose first point is after ignition (29 of the 32 start between 1 and 40 ms). So the point counts match as well, and nothing rounds differently.
    • One definition genuinely differs, and is recorded rather than held (ADR-066): the average thrust. Both codes divide by the same 5% window. OpenRocket’s numerator is the impulse inside it, while HPR Sim’s, following TC-A, is the whole curve’s. The tails below 5% are the difference. So HPR Sim’s average is the higher on every one of the 32, by +0.0107% to +0.3147% (median +0.0965%). The test prints all three. Carrying an average thrust between the two codes means saying which numerator it used.

    • Curves outside this repository are held to the same bound. They are not committed, so cargo xtask ork checks them on the machine that has them. It fails if one is outside 0.1% (M2.2c2, ADR-067):

      • The curves the reference library’s designs embed, which are other people’s data. HPR Sim parses each file itself, so these are real checks. All 3 agree to the last bit.
      • Every solid curve in the motor database OpenRocket 24.12 ships: 1,288 of its 1,452 motors, the rest hybrids. The survey supplies them to designs that name a curve by digest without carrying it. Both codes integrate the samples OpenRocket has already parsed, so agreement to the last bit proves the hand-off, not two independent readings.

      The counts, and what the database motors’ masses leave out, are on the .ork format page.

  • RocketPy (motor::tests::matches_rocketpy_solid_motor_for_three_bundled_motors): three bundled curves with BATES loads. They cover grains that burn out radially (the bore reaches the outer wall first) and axially (the burning ends meet first). They also cover inhibited ends, and both of RocketPy’s axis directions (positions measured from the nozzle forward, or toward the nozzle). validation/oracles/rocketpy/solid_motor.py writes validation/fixtures/motor/rocketpy-solid-motor.json, and regenerates it byte for byte.
    • On 203 times per motor, total mass, It and Ia agree within 7.9e-5 of RocketPy’s own values. At the same times the center of mass agrees within 5.9e-6 of the motor length.
    • Quantities that go to zero are compared against a fixed scale. Propellant mass and inertias use their ignition values, grain height its initial height, and centers the motor length. On that scale they agree within 1e-4. Before burnout the propellant mass differs by up to 69% of RocketPy’s own value, where RocketPy holds 6.9 mg in the 38 mm motor. That comes from RocketPy’s interpolation between the points its ODE solver stored.
    • The test holds 0.1% on these scales.
  • Files: 1,710 of ThrustCurve’s 1,712 solid-motor files read, and write back out and read again with every value identical to the last bit. The other two have times that go backwards (.rse files).
  • Unit and property tests cover exact impulse integration, burn windows, grain volume inversion, the parallel-axis theorem, and the impulse-fraction flow integrating to mp0. Property tests check a rule on many random inputs.

The example program

This is the whole of crates/hpr-sim/examples/motors.rs, line for line the file CI runs. Using a motor walks through what it does.

//! Motors: the thrust curves that come with HPR Sim, and a motor read from a RASP `.eng` file
//! like the ones ThrustCurve.org serves, put in a rocket's motor mount and flown.
//!
//! Run it from anywhere in the repository:
//!
//! ```text
//! cargo run --example motors -p fusionspace-hpr-sim
//! ```
//!
//! The documentation site's *Solid motors* page (`docs/physics/motor.md`, "Using a motor") walks
//! through it. What it prints is kept next to it in `motors.output.txt`, and CI checks that the
//! two still agree (`cargo xtask examples --check`).

#![allow(
    clippy::print_stdout,
    reason = "the project's lints forbid printing in library code, and this program exists to print"
)]

use std::error::Error;

use hpr_core::geodesy::Geodetic;
use hpr_design::{Configuration, Ignition, MountedMotor, Rocket};
use hpr_motor::catalog::MotorType;
use hpr_motor::{Catalog, ImpulseClass, SolidMotor, eng};
use hpr_sim::{Environment, EventKind, FlightSettings, Rail, Simulation, Termination};

fn main() -> Result<(), Box<dyn Error>> {
    // 1. The motors that come built in: every solid motor in ThrustCurve.org's catalog. Most
    //    have a curve file; a motor whose files all fail ThrustCurve.org's 1% check still flies,
    //    with a warning. One per impulse class here: the first in the catalog's order with a
    //    file that passes. Size and loaded mass are its file's header values; impulse, class,
    //    average thrust and burn time are worked out here from its curve.
    let catalog = Catalog::bundled()?;
    let with_curve = catalog
        .motors
        .iter()
        .filter(|entry| entry.default_curve().is_some())
        .count();
    println!(
        "{} motors come built in, {with_curve} of them with a curve file. One of each class:",
        catalog.motors.len()
    );
    println!();
    let mut classes = Vec::new();
    let shown: Vec<_> = catalog
        .motors
        .iter()
        .filter(|entry| {
            entry
                .default_curve()
                .is_some_and(|curve| curve.check.passes)
        })
        .filter(|entry| {
            let new = !classes.contains(&entry.impulse_class);
            if new {
                classes.push(entry.impulse_class);
            }
            new
        })
        .collect();
    let heading = [
        [
            "", "", "", "", "dia", "length", "loaded", "total", "average", "burn",
        ],
        [
            "designation",
            "maker",
            "type",
            "class",
            "mm",
            "mm",
            "mass g",
            "impulse N·s",
            "thrust N",
            "time s",
        ],
    ];
    for [a, b, c, d, e, f, g, h, i, j] in heading {
        println!("{a:<12} {b:<8}  {c:<10}  {d:<5} {e:>5} {f:>7} {g:>9} {h:>11} {i:>9} {j:>7}");
    }
    for entry in shown {
        let motor = entry.bundled_motor()?;
        let curve = motor.curve();
        let kind = match entry.motor_type {
            MotorType::SingleUse => "single-use",
            MotorType::Reload => "reload",
            _ => "other",
        };
        let class = ImpulseClass::from_total_impulse(curve.total_impulse_ns())?;
        // An entry the catalog gives no loaded mass for would show a dash; every bundled one has
        // a loaded mass.
        let loaded_g = entry
            .total_mass_g
            .map_or_else(|| "-".to_owned(), |mass_g| format!("{mass_g:.1}"));
        println!(
            "{:<12} {:<8}  {kind:<10}  {:<5} {:>5} {:>7} {loaded_g:>9} {:>11.1} {:>9.1} {:>7.2}",
            entry.designation,
            entry.manufacturer_abbrev,
            class.label(),
            entry.diameter_mm,
            entry.length_mm,
            curve.total_impulse_ns(),
            curve.average_thrust_n(),
            curve.burn_time_s(),
        );
    }

    // 2. A motor from a file. This is one of the bundled files, built into the program so that it
    //    runs anywhere. For a file you downloaded, read its text instead with
    //    `let text = std::fs::read_to_string("path/to/your-motor.eng")?;`
    let text = include_str!("../../hpr-motor/data/thrustcurve/curves/5f4294d20002e90000000863.eng");
    let parsed = eng::parse(text)?;
    for warning in &parsed.warnings {
        println!("warning, line {}: {}", warning.line, warning.message);
    }
    let [entry] = &parsed.value.entries[..] else {
        return Err("expected one motor in the file".into());
    };
    // The file gives the size in millimeters and the masses in kilograms; the motor takes meters
    // and kilograms. Only the size needs converting, and the motor can't tell if it isn't: its
    // units check looks at the impulse and the propellant mass, not the size.
    let diameter_m = entry.diameter_mm * 1e-3;
    let length_m = entry.length_mm * 1e-3;
    let motor = SolidMotor::from_envelope(
        entry.thrust_curve()?,
        diameter_m,
        length_m,
        entry.propellant_mass_kg,
        entry.total_mass_kg,
    )?;
    let curve = motor.curve();
    println!();
    println!(
        "From the .eng file: {} by {}, {} mm by {} mm, {:.0} g loaded, {:.0} g of propellant",
        entry.name,
        entry.manufacturer,
        entry.diameter_mm,
        entry.length_mm,
        entry.total_mass_kg * 1e3,
        entry.propellant_mass_kg * 1e3,
    );
    println!(
        "  {:.1} N·s (class {}), {:.1} N average over {:.2} s, {:.1} N peak",
        curve.total_impulse_ns(),
        ImpulseClass::from_total_impulse(curve.total_impulse_ns())?,
        curve.average_thrust_n(),
        curve.burn_time_s(),
        curve.peak_thrust_n(),
    );
    println!(
        "  effective exhaust velocity {:.0} m/s",
        motor.exhaust_velocity_m_s()
    );

    // 3. Into a rocket: a new configuration that puts the motor in the design's motor mount. The
    //    rocket is Valetudo, the rocket of `first_flight.rs`. Its mount is 43 mm inside, so this
    //    38 mm motor fits: the design checks compare the case diameter given here with the bore.
    let mut rocket: Rocket = serde_json::from_str(include_str!(
        "../../../validation/designs/rocketpy-valetudo.json"
    ))?;
    rocket.configurations.push(Configuration {
        id: "from-file".to_owned(),
        name: format!("{} from its .eng file", entry.name),
        motors: vec![MountedMotor {
            mount: "motor-mount".to_owned(),
            designation: entry.name.clone(),
            diameter_m,
            length_m,
            motor,
            // No ejection delay is chosen: this flight carries no parachutes.
            delay: None,
            ignition: Ignition::Launch,
            failed_tubes: Vec::new(),
        }],
    });

    // Fly it, straight up from a 3 m rail in calm air, with no parachutes.
    let site = Geodetic::from_degrees(32.99, -106.97, 1400.0)?;
    let simulation = Simulation::new(
        &rocket,
        "from-file",
        Environment::standard(site)?,
        Rail::vertical(3.0),
        FlightSettings::default(),
    )?;
    let flight = simulation.run(&mut ())?;
    if flight.termination != Termination::GroundHit {
        return Err(format!("the flight ended with {:?}", flight.termination).into());
    }
    let sample = |kind| {
        flight
            .event(kind)
            .map(|event| event.sample)
            .ok_or(format!("the flight has no {kind:?}"))
    };
    let (liftoff, rail_exit, apogee) = (
        sample(EventKind::Liftoff)?,
        sample(EventKind::RailExit)?,
        sample(EventKind::Apogee)?,
    );
    println!();
    println!(
        "Valetudo on the {}: {:.2} kg at liftoff",
        entry.name, liftoff.mass_kg
    );
    println!(
        "  leaves the 3 m rail at {:.1} m/s",
        rail_exit.cg_velocity_enu_m_s.length()
    );
    println!(
        "  apogee {:.1} m above the pad, at {:.2} s",
        apogee.height_above_ground_m, apogee.time_s,
    );
    println!("Not yet validated: see the Accuracy page before trusting these numbers.");
    Ok(())
}
FusionSpace HPRVersion 0.1.0Issued 2026-11-21In preparationAbout HPR Sim