Validation plan and reference inventory
Learn how HPR Sim’s physics is checked, over which flight envelope, and against which papers, reference simulators, flight logs and motor data.
This inventory was checked on September 16, 2026. The sources cargo xtask refs fetch downloads were pinned
on September 17, 2026 in validation/refs.lock.toml, by commits and sha256 values
(the lock file’s decision).
That file is the source of truth for versions and URLs. Everything downloaded goes to the
gitignored refs/. Only small extracted fixtures with a clear license are committed, each with its
provenance.
Principles
-
Four levels of evidence:
- Analytic and unit tests.
- Component-level references (tables and worked examples).
- Code-to-code (RocketPy, OpenRocket).
- Real flights.
Code-to-code agreement isn’t truth. Real flights are the final arbiter, and their uncertainty (weather, as-built mass, motor variation) must be stated.
-
Gaps tracked. A page that says a reader, a model or a check rests on less than real evidence links a row of the evidence register. The row names the kind of evidence behind it and the kind wanted (What backs each claim). Until a real sample settles it, the row names an open issue.
cargo xtask evidenceruns in the gate and CI. It fails a row short of what it wants with no open issue, and a gap stated in a listed phrase with no row. A gap worded otherwise passes it (#685). -
Stored references with provenance. Every reference output records the tool, version, date, inputs hash and command, so CI can compare without Java or Python. A manually triggered workflow regenerates the references.
-
Per-case tolerances in files. Tolerances live in the case file, next to the reason for their size. A regression beyond tolerance fails CI.
-
Always regenerated.
validation/reports/latest.md(plus JSON) is regenerated bycargo xtask validate. It lists every case, error, tolerance and verdict. The accuracy census (validation/reports/census.md, the census) counts the numbers the committed reports hold HPR Sim to. -
Initial targets (targets, not gates, until the first report exists):
- Code-to-code apogee within 3% (subsonic) and 5% (transonic/supersonic).
- Real-flight apogee mean absolute error at or below 5% on well-characterized flights.
- Every miss is explained in the report.
Since the harness wrote its first report, the code-to-code 3% is a gate in same-drag mode, where both codes fly the same drag. Later reviews tightened it:
- 0.2% on the burnout and largest speeds, and until November 2, 2026 0.5% on the apogee of the six flights with no written model difference (the decision that tightened them);
- 0.2% to 1% on the rail-exit and apogee times, burnout heights and traces (ADR-294, which tightened the times, burnout heights and traces);
- 0.05% on the rail-exit speeds and 0.1% on the landing speeds (ADR-310, which tightened those speeds);
- 0.35% on those six apogees from then on, and no same-drag apogee more than 0.001% below RocketPy’s (ADR-318, which tightened the apogees).
It stays a target in predicted mode, where neither code’s drag is the truth (predicted mode’s decision): 3% on each relative metric, except 0.1% on the rail-exit and landing speeds and 0.5% on the rail-exit time; the traces keep their absolute targets. A predicted miss is explained in its case file, and a test pins the set of misses.
Operating envelope
The operating envelope says which flights the accuracy work serves first. It sets the order of the work. It doesn’t limit what HPR Sim flies (the envelope’s decision). The bands are set by the Mach number alone:
| term | Mach number | what it means |
|---|---|---|
| Core band | 0 to 2.5 | Accuracy work goes here first. Nearly every flight on commercial motors is in it. |
| Extended band | 2.5 to 3.5 | Record flights on the largest commercial motors. HPR Sim flies it; its accuracy is checked less than the core band’s. |
| The envelope | 0 to 3.5 | Every flight up to Mach 3.5, at any angle of attack. |
| Beyond the envelope | past 3.5 | Deferred, not dropped. These flights still fly. |
The angle of attack is a separate condition. Accuracy work assumes it stays at 15° or less. A flight above 15° more than 1 s after leaving the rail is at high angle of attack, at any Mach number.
The first second doesn’t count, as a rocket meets the air at a steep angle then, for a moment (below). That 1 s was chosen, not measured. The milestone on large angles of attack measures how long the transient lasts and studies high angles.
Every flight still flies, but one that goes past an edge carries a flag (the envelope flags; their decision). Each flag is tested at its edge. A flag only marks numbers to trust less: it changes none. A flight exactly at an edge, such as Mach 2.5, raises no flag; only one past it does. The flags stack: a flight past Mach 3.5 raises all three Mach flags.
-
Beyond the validated range: the flight goes faster than the fastest public whole-flight reference. That means any committed comparison of a public flight against an independent reference, gated or not. Today it’s OpenRocket’s Dual parachute deployment example at Mach 1.1467, OpenRocket’s own top speed for it. The number is a constant in the code. A test reads the committed reports and fails when it isn’t their fastest, so it rises as references are added. Private flights never set it.
-
At high angle of attack: above 15° more than 1 s after leaving the rail and before apogee or the first deployment. It counts only where a 15° angle would give a normal force of at least a fifth of the rocket’s weight.
Without that floor (Flight metrics: the largest angle of attack), every flight whose path turns over would raise it. Near apogee the rocket slows, and its angle swings past 15° where the air is too weak to turn it. There a 15° angle gives 0.7% to 5.0% of the weight on the tests’ rockets. In a wind layer met at speed, it gives 62% to 141%. The fifth is chosen, not measured, like the 1 s.
-
Outside the core band: past Mach 2.5.
-
Beyond the envelope: past Mach 3.5.
hpr sim prints a warning: envelope: line for each and lists them under flags in its JSON.
The library has Flight::envelope_flags, and Python Flight.envelope_flags.
The public designs hpr sim flies offline, 25 .ork files and 12 validation designs, were flown
on October 6, 2026 off an 85° rail. They flew in calm air and in 8 m/s (26 ft/s) of wind (hpr sim <design> --offline --inclination 85 --wind 0, then --wind 8). Only one raises a flag: beyond the validated range, at Mach 1.61. It’s
an invented two-stage rocket,
synthetic-two-stage-75mm-54mm.json,
which hpr sim flies as one stack.
unstable_under_power and unstable_without_margin are reported with the envelope’s flags, but
neither is an edge of the envelope. A flight whose static margin falls below zero while a motor
burns, before apogee or the first deployment, is unstable under power. Where HPR Sim can give no
margin, a pitching-moment slope above zero under power says the same. It raises
unstable_without_margin instead, so a flight raises one of the two at most. hpr sim prints a
warning: unstable: line and marks its apogee as not a prediction
(Flight metrics: unstable under power;
#335).
A margin or of exactly zero raises nothing. When this was written (October 6, 2026), none
of the 37 designs above raised either on its default configuration, in either wind. No test or
report pins that count. Two of the four configurations of OpenRocket’s Pods--powered with
recovery deployment raise unstable_under_power, at −4.21 calibers.
A flight also warns, by issue number, when it meets one of the known errors in HPR Sim’s drag (the drag issue warnings; their decision). #18 warns on every flight, so it names no shape and no Mach edge. #73 has a shape but no Mach edge. The rest have both, each edge exclusive as the flags’ are:
| issue | what reads wrong | when it warns |
|---|---|---|
| #67 | the pressure drag of a cone, an ogive, or a power or parabolic series close to a cone: high from Mach 0.8, about twice Stoney’s measured cone at Mach 0.85, 2 to 9 times MIL-HDBK-762’s ogive from Mach 0.9 to 1.2, still +15% at 1.5 | such a nose, or such a shoulder (a transition widening aft), past Mach 0.8 |
| #68 | base drag: high from Mach 0.8 to 1.2 against MIL-HDBK-762’s data, low from 1.5 against Love’s correlation (17% at Mach 2); the sign between is unmeasured | every rocket, past Mach 0.8 |
| #70 | a sharp fin’s drag, high faster than sound; HPR Sim has no sharp section | airfoil fins, past Mach 1 |
| #72 | a steep boattail’s drag, high faster than sound against NASA’s measured models (+13.5% to +50.8% at 15°, +26% to +54% at 16°) | a boattail steeper than 10°, past Mach 1 |
| #222 | supersonic pressure drag, about twice OpenRocket’s, a comparison between two codes with no measurement to say which is right | an ogive nose or airfoil fins, past Mach 1 |
| #73 | a boattail’s drag below Mach 0.8, by Niskanen’s rule: from −40.8% to +41.7% on Cubbage’s measured 16° boattails (NACA RM L57B21), high on the Arcas Robin’s 15° one | a boattail steeper than 9.5° (atan(1/6), where the rule’s length ratio falls below 3 and it starts to give the boattail drag), on any flight |
| #18 | skin friction, taken as fully turbulent: where a smooth surface keeps a laminar run, Barrowman’s transitional term takes 3.6% off the friction on RocketPy’s Calisto at Mach 0.3, about 2% of its drag at zero lift; nothing says how rough a surface must be to trip the flow at once | every flight, at any speed and on any finish (the decision) |
“Past Mach 0.8” means the flight’s top Mach number is above 0.8; one at exactly 0.8 doesn’t warn. Drag that reads high makes the apogee, top speed and drift read low. It also makes the flutter margin and the largest dynamic pressure look better than they are. Each warning says so. #68’s adds, for a flight past Mach 1.2, that from Mach 1.5 its error turns the other way.
#70’s and #222’s are conditional. HPR Sim has no sharp fin section, so #70 applies if your airfoil fins are really sharp-edged. #222 applies if HPR Sim rather than OpenRocket is the one off. #73 warns at any speed, since every flight is subsonic for a while. Its error runs both ways, and the warning covers the side where the drag reads high.
Where an issue leaves a range unmeasured, such as boattails between 10° and 15°, the warning takes
it in. A flight flown on a drag table or model of your own warns of none, as its drag isn’t HPR
Sim’s. hpr sim prints a warning: drag: line for each and lists them under issues in its JSON.
The library has Flight::issue_warnings, and Python Flight.issue_warnings.
Barrowman (1967) gives no rule for how rough a surface must be to trip its flow at once. So #18 warns on every flight on HPR Sim’s drag, and all 37 public designs raise it.
Of the same 37 flown off an 85° rail in calm air, 8 raise at least one other. #68 is raised on
all 8, #67 on 4 and #222 on 2. #70 and #72 are raised on none, as no public design flown past
Mach 1 has airfoil fins or a steep boattail. Unit tests pin their edges. That count was taken
before #73, #18, #179, #354 and the four flight warnings below joined the list
(the missing warnings).
Nine more warn where the stability margin reads high (the stability issue warnings; their decision):
| issue | what reads wrong | when it warns |
|---|---|---|
| #87 | a step in radius takes the whole body off the supersonic shock-expansion method, so slender-body theory puts the center of pressure aft (on the tests’ rocket at Mach 3 and 4°, −8.65% of the normal force and 1.03 calibers) | a step that stopped the method, past Mach 1.2 |
| #120 | the same, for a lip behind a boattail longer than the boattail’s drop in diameter (−33.0% and 1.77 calibers) | such a lip, past Mach 1.2 |
| #121 | the same, for a pointed tip steeper than the cone tables’ 30° (−7.7% and 0.81 calibers) | such a tip, past Mach 1.2 |
| #172 | the static margin read up to 0.1108 calibers higher than OpenRocket 24.12’s on four private designs (0.0350 to 0.1108), for a reason not yet found | every flight with a static margin |
| #1198 | from Mach 0.8 the fins’ normal force is a straight-line join to linear theory; against TN D-4013’s two Arcas Robin models the center of pressure sits 0.6794 and 1.343 calibers aft of the tunnel’s at Mach 0.9 (0.67 to 1.35, rounded outward), each beyond its reading’s uncertainty, so the flight margin reads high; near Mach 1 the error turns both ways (the short model 0.41 calibers forward at Mach 1.0) | every flight with a static margin past Mach 0.8 |
| #1290 | below the join, with the fins still on Prandtl-Glauert, TN D-4013’s short Arcas Robin model reads its center of pressure 0.1170 calibers aft of the report’s curve at Mach 0.6 and 0.9117 at Mach 0.8 (0.11 to 0.92, rounded outward), each beyond its reading’s ±0.055, so the flight margin may read high; the long model reads 0.360 calibers forward at Mach 0.6 and inside its ±0.071 at 0.8, so one model of two supports it; fitted on the tunnel’s points over the same angles, the misses are −0.03 and +0.87 calibers over −2° to 2°, and −0.49 and +0.08 over −3° to 4°; below Mach 0.6 there is no tunnel point | every flight with a static margin that reaches Mach 0.6 |
| #64 | a fin whose leading edge sweeps forward: supersonic linear theory’s slope rises by up to 7.7% past Mach 1.2, where it should fall, so the center of pressure sits aft | such a fin (a trapezoid’s tip ahead of its root, or a freeform point ahead of the root’s leading edge), past Mach 1 |
| #325 | fin sets at one station are counted apart for fin-fin interference, where OpenRocket counts them together: about 0.029 of the 0.071 to 0.076 calibers HPR Sim reads above OpenRocket on its Pods--airframes and winglets example | fin sets whose roots overlap or touch along the axis, on one airframe or pod set, with more than four fins between them, on any flight |
| #326 | a kinked freeform fin’s center of pressure sits 1.6 mm (0.063 in) aft of OpenRocket 24.12’s, about 0.047 calibers of that example’s gap; other freeform outlines are unprobed | every freeform fin set, at any speed (the decision) |
Mach 1.2 is where the method first joins slender-body theory, so the three switches can’t move a number below it. The aerodynamics code records which switch stopped the method, so the warning follows the code that switches. #172 has no known condition. It gives the gap’s size and sets no threshold, since the margin you need is the range safety officer’s (RSO’s) and the safety code’s call. #325’s rule in OpenRocket is unsized between overlapping roots and a common aft station, so the warning takes the wider: roots that overlap or touch.
The stability warnings above print as warning: stability: lines, with kind "stability" in the
JSON and in Python. A flight on a drag of your own keeps them, as its normal force is still HPR
Sim’s. A model given a normal-force table of its own prints none, #172 included.
A staged flight asks the whole stack’s body, the upper stage at its front. So a switch in the booster can warn with the upper stage’s top speed: it can over-warn. Whether it can miss one isn’t yet checked, a limit of this increment.
One more comes from the design checks, not the flight. A packed part drawn too wide for the room in a nose cone or a shoulder, where the room widens aft of it, names #367. Its mass could sit only farther aft than drawn. So the margin may read high.
Two more warn where a part flies on its own after a separation (the separated parts’ warnings; their decision). HPR Sim flies such a part as a point mass, with no airframe and only its open recovery devices’ drag. Neither error has been measured, so neither has a speed edge. Each warning gives a direction, not a size:
| issue | what reads wrong | when it warns |
|---|---|---|
| #179 | a booster tumbles side-on from the split, where the issue expects a real one first to coast nose-first on its airframe’s drag, so its peak and drift likely read short | a booster or a parallel stage, any part aft of a stage’s joint, flies on its own |
| #354 | a part with no device open has no drag at all until its first one opens: falling, it likely lands early and its drift likely reads short; climbing, its peak reads high; its opening speed reads high after a long fall, low for a light part split off climbing that opens near its drag-free top | a part starts its own flight with no device open, and none opens at that instant |
A booster with no device open at the split prints both: #179 for the missing airframe, #354 for the gap before its device opens. With no drag at all, its peak reads high, not short. Treat a dropped part’s printed landing point as rough. Search a wider area than it suggests, and don’t use it to clear a boundary.
Both read the flight’s parts, not its drag, so a flight on a drag of your own keeps them. They
print as warning: drag: lines and name no parts. hpr sim can’t meet #354 today, since a .ork
payload’s delayed device is refused before the flight. hpr mc warns only of its nominal flight’s
issues. So a sample whose Monte Carlo deployment lag leaves a part
closed at the split isn’t warned.
Four more concern the flight’s path, not its drag or its margin. They err either way by the case, so each warns as if it flattered (the unknown signs; their decision). None is sized against a reference, so each gives a direction, not a size. Where the apogee or the drift sits near a limit, leave room on both sides, since the warning can’t say which:
| issue | what reads wrong | when it warns |
|---|---|---|
| #219 | HPR Sim flies the turn that thrust makes about a center of gravity off the axis; OpenRocket’s flights don’t, and nothing measures which is right (evidence row G15). The turn reverses with the offset’s side, so against a wind or a tilted rail the apogee or the drift can read low | the center of gravity of the rocket, or of a sustainer flying on after a split, more than 1e-9 m off the axis at launch, at a motor’s ignition or burnout, or with its motors spent (exact while one motor burns at a time; two off-axis motors burning together could peak between): most designs with a lug or a rail button, since each sits off the axis. 1e-9 m only screens out rounding (a symmetric design sits near 1e-18 m off), it is not a measured limit |
| #213 | a single side pod’s drag and normal force are applied on the rocket’s axis, so the steady tilt its drag would give (about 0.15° on the pods’ worked example) and the roll its normal force would give are left out; which way that moves the flight turns with the pod’s side | a rocket with one pod, not two or more, off the axis and holding a part; two or more pods stand evenly round the axis and cancel |
| #106 | where the supersonic shock-expansion method hands over from slender-body theory, over 0.3 in Mach number, a body part’s pitch and yaw damping is sampled away from its own center of pressure (4.71 calibers apart at Mach 1.3 on the tests’ 54 mm (2.1 in) rocket); the margins don’t use it, but the apogee and drift can lean either way | the top speed of the rocket, or of a sustainer flying on after a split, past the start of its own handover (Mach 1.2 or later). The message names the handover’s span, or every speed past its start where a lip rides partly in a boattail’s wake or a part behind a boattail keeps slender-body theory’s station |
| #8 | a wind level of 1.5 m/s (4.9 ft/s) or less (light air, whose direction a vane doesn’t show) still turns the interpolated direction; where the other levels share one direction, that likely shortens the drift | a wind table interpolated by speed and direction (SpeedDirection) whose near-calm level turns by any angle against its neighbor inside the flight’s heights; only library flights meet it, as hpr sim flies one wind and Python’s wind is a function |
They print as warning: flight: lines, with kind "flight" in the JSON and in Python. A flight
on a drag or a normal-force table of your own keeps them. Three more issues once of unknown sign
print no wrong number. #104’s figure, a body part’s own center of pressure, is printed nowhere:
every one HPR Sim prints is the whole rocket’s. The .ork reader refuses a file whose surface
finish (#360) or pair of mass-override flags (#361) it can’t read.
Why these edges:
- NASA Student Launch (4,000 to 6,000 ft (1,219 to 1,829 m)) flies below the speed of sound. So does the American Rocketry Challenge (750 ft (229 m), its 2026-season target).
- Spaceport America Cup teams in the 9,144 m (30,000 ft) commercial-motor category fly Mach 1.6 to 2.1. Concordia’s 2018 report gives Mach 1.64, and UC Aerospace’s 2024 flight went “just over Mach 2”.
- The fastest commercial-motor flights, minimum-diameter record builds such as CTI O3400 and N5800 flights, reach about Mach 3.5. Tripoli’s single-stage commercial altitude records, in a 2016 snapshot, were 13,885 m (45,554 ft) on an M motor. They were 15,614 m (51,228 ft) on an N and 20,040 m (65,748 ft) on an O.
- NFPA 1127’s legal wind limit is 20 mph (8.9 m/s). At that limit, a rocket leaving the rail at 50 to 100 ft/s (15 to 30 m/s) meets the air at about 16° to 30°. The slower the rocket, the steeper. So 15° covers the climb, not the first instant off the rail.
What is checked today. Code-to-code whole flights mostly stay below Mach 1.15 and 4 km (2.5 mi). The fastest public one is OpenRocket’s example at Mach 1.147 (Accuracy: results by model; HPR Sim’s flights against OpenRocket’s). One private flight is supersonic, and reads 13.60% high in apogee against OpenRocket.
Real flights reach about Mach 1.0 and 3.9 km (2.4 mi) (Accuracy: real flights). HPR Sim’s peak Mach for each flight is the last column of the real-flight report. So most of the core band is checked part by part, not as whole flights.
The stop rule. An accuracy step makes progress when it shrinks a measured error against an independent reference, or adds a reference that will. Either counts as progress. Two steps in a row that do neither end the milestone, gaps written down. Each step names the band it serves, and work outside the core band needs a stated reason.
The references named for Mach 1.5 to 2.5
The envelope’s decision named nine references to add or check for Mach 1.5 to 2.5 (the reference increment). Each will be reported, with a number on a page, or refused, with the reason (the decision that split the work). So far three are reported and three are refused; three are open.
| reference | where it stands | why, or where |
|---|---|---|
| The Basic Finner’s free-flight data (DREV-TM-9703) | reported | Its normal-force slope and center of pressure are compared at six Mach numbers, 1.08 to 3.15 (Aerodynamics), and so are its drag and pitch damping, the fins’ wedge section modeled from published figures (Aerodynamics). Its roll damping was compared earlier (Aerodynamics). |
| The Rocket Flight Database | refused as a reference set | It keeps a flight only when a fork of OpenRocket predicts its apogee within ±10% of the measured one, so the set is screened to agree with a simulator. Its rows from RASAero II’s comparison page add no apogee that page lacks, and its flights from Mach 1.5 to 2.5 fly team-built or unlisted motors, outside the commercial-motor scope. Its flights on commercial motors are the ones the published supersonic flights take from that page, where they will be reported (research note). |
| ARL-TN-1128 | refused | The report defines a shape, the High-Speed Army Reference Vehicle, and gives no coefficient, test or Mach number (research note). |
| A wind-tunnel drag point at Mach 2.45 | refused | Its authors doubt their own force measurement, and its license bars committing a value (research note). |
| NASA’s six-degree-of-freedom check cases | cases 1 to 3 and 6 to 10 reported | A free body flies cases 1 to 3 and 6 to 10 against each code’s published history. Cases 1 to 3 and 6 to 8 differ from the codes by more than the codes differ from each other; a named difference between the models brings each inside that spread at each code’s largest difference. Cases 9 and 10 are inside it (Rigid-body flight). Cases 4, 5 and 11 to 17 are refused: 4 and 5 need gravitation on a round Earth, 11 to 16 fly an aircraft, and 17 is past Mach 9. None of the cases is a reference for Mach 1.5 to 2.5: they check frames, gravity and rigid-body motion (research note). |
| Tip-off, against RocketPy’s | reported | RocketPy’s tip-off phase, flown on thirteen example designs in still air and in a 20 mph (8.94 m/s) crosswind, moves the landing point by up to 3.765% of the apogee and the apogee by up to 0.414%, from a rocket guided to its last button (Rigid-body flight). That is past the plan’s bar of 1% of the apogee, so HPR Sim gained an opt-in tip-off phase. On RocketPy’s normal force it is within the bars of RocketPy’s on all 26 flights. On HPR Sim’s own it is inside them on the 13 still-air flights and on none of the 13 crosswind flights (the comparison; the open increment). One code against another; no flight checks it. |
| Wind reconstructed from the GPS descent | open | Its increment (research note). |
| A validation uncertainty for each real flight (ASME V&V 20) | open | Its increment. |
| MAPLEAF, as another simulator to compare with | open | Its increment. |
Beside the tip-off reference, the phase was also flown on every real flight HPR Sim compares, with it and without it. That compares HPR Sim with itself, not with a measurement. The phase moves each apogee by under 1%. On the seven public flights the real flights compared as soon as they were flown, the mean absolute apogee error falls by 0.091 percentage points. The phase raises Juno III’s apogee by 26.5 m (87 ft), toward its log, and that one flight alone turns the change into a fall, so the fall is not counted for the phase. On the five whose predictions were published before their comparison, and on the private collection’s 60 flights, it rises by 0.0014 and 0.0033 points. No landing point is compared yet (on the real flights).
The validation harness
cargo xtask validate [--fast|--check] runs every case in validation/cases/lock.toml and writes
validation/reports/latest.md and latest.json
(the harness;
its decision).
Its code is in crates/hpr-validate/. --check writes nothing (see below). It runs the whole
suite, so it can’t be combined with --fast.
A case (validation/cases/<id>.toml) says what to fly and which metrics to compare, each with its
own tolerance. It also names the reference to compare against (validation/fixtures/**, written
by a generator under validation/oracles/).
The rules the harness enforces each come from a lesson of Loft, the project before this one:
- A run reads references and never writes them. A reference moves only when its generator runs (references that followed Loft’s drag). There’s no flag to update one.
- Every reference value carries a source naming the oracle, the generator and the field. The report carries the reference file’s SHA-256, so an edited reference shows up in it (Loft’s hand-written results).
- Every metric a case reports is either held to a tolerance that bounds something or declared, in writing, not scored. A case is refused if HPR Sim measures a metric it doesn’t account for, or if the reference publishes one the case ignores (ungated metrics).
- The cases that must run are locked. A missing one fails, and so does a committed case that isn’t
locked.
--fastcan leave out only cases the lock marks slow, and it names them (Loft’s suites that skipped and passed). - A case’s inputs come from the reference’s own record of what the oracle flew, never from HPR
Sim’s output. That includes which design it flew, what that weighed and, for a whole flight, the
area its drag table is on (Loft’s RocketPy check,
hpr_validate::rocketpy::tests::oracle_inputs_come_from_the_case_file_not_hpr_outputs). - A case may declare a known gap, a limit of HPR Sim’s it runs into. The only one accepted is HPR Sim’s refusal of a Mach number past its models’ range. Since the work on drag through Mach 1, that range ends at Mach 5 for the normal force and the drag buildup alike. The reference must reach Mach 5, and HPR Sim must refuse the flight with that error. A gap that HPR Sim starts flying fails the run (Loft’s half-tolerance gap check). A gap scores nothing and is listed in the report’s own section, and the set is pinned (the whole-flight decision). No case declares one. Prometheus 2022 was one on the declared drag until the work on the normal force through Mach 1 flew it (its decision). On its own drag, refused at Mach 1 by the drag buildup, it was one until the work on drag flew it (its decision).
Not scored is the harness’s one escape hatch, and it’s uncomfortable on purpose. The case has
to write down why, and a blank reason fails outright. The metric is still measured and still
printed with both numbers and the difference. It never counts as a pass. The whole excused set is
pinned by hpr_validate::tests::the_metrics_that_are_not_scored_are_these_and_no_others.
It was written for Valetudo’s northward drift, which read 28x RocketPy’s
(the harness decision).
The right answer there turned out to be to fix the comparison rather than to excuse the number. The same held for the drifts in
wind (issue #50): RocketPy’s equations were at fault, and the comparison now flies them corrected
(the wind decision).
Eleven whole-flight metrics use it today (report),
each argued in its case file
(the whole-flight decision,
the wind decision).
Juno III’s, Bella Lui’s and Prometheus 2022’s drifts in wind and NDRT 2020’s apogee drift use it
as measured model differences. HPR Sim has body lift at the rail exit’s angle of attack,
which RocketPy leaves out, and frees the rocket at the last rail button. With both added to
RocketPy, wind_response.py lands every windy drift within 1.3% of HPR Sim’s. Calisto’s time of
peak acceleration uses it too, in wind and in calm air: its two peaks are 0.9% apart. So do NDRT
2020’s and Prometheus 2022’s whole-flight peaks, their main openings, where RocketPy has added mass
and HPR Sim has none. No case carries an absolute floor: every gate is the milestone’s 3% or
tighter.
Some gates are tighter (the decision that tightened them, and ADR-294, which tightened the times, burnout heights and traces):
- Each burnout and largest speed: 0.2%. The descent time, mean descent rate and drifts of three descents, and Valetudo’s time and rate: 0.3% (ADR-319; largest +0.0857%, Prometheus 2022’s east drift); NDRT 2020’s descent, 0.705% off because RocketPy adds the air a parachute drags along, and Valetudo’s still-air drifts keep 3%.
- Each rail-exit speed: 0.05%. Each landing speed: 0.1% (ADR-310; largest differences −0.0144%, Prometheus 2022’s, and −0.0301%, its descent’s). All nine rail-exit speeds read low, the cautious side, because HPR Sim adds drag when the rocket meets the air at a slant on the rail and counts the propellant’s weight moving, and RocketPy’s rail does neither: without both, every row agrees within 0.00012%. A test fails a rail-exit speed that reads high by more than 0.005%, RocketPy’s solver movement rounded up. The landing speeds split seven and seven around zero, so the −0.0301% is on the flattering side, with no traced cause.
- The largest Mach number of all nine flights: 1%. The largest acceleration under power, and the whole flight’s where it is scored, 1% in the seven flights that aren’t Bella Lui’s; Bella Lui’s keep 3% for the rail’s variable-mass terms at its ignition spike (+1.783%) (ADR-303; largest differences −0.235% in Mach number, Prometheus 2022’s, and +0.248% in acceleration, Valetudo’s).
- The apogee of the six flights with no written model difference: 0.35% since ADR-318, which tightened it, 3.1 times the largest difference (+0.1123%, Valetudo’s). Juno III, Bella Lui and Prometheus 2022 in wind keep 3%, for the model differences their case files measure (the rail release and body lift; Juno III’s thin-plate fins too). All nine read high today (+0.04% to +1.21%), the cautious side, and none may read below RocketPy’s by more than 0.001%: too low an apogee could wrongly clear a waiver. The 0.001% is the largest change in RocketPy’s apogee when its solver’s tolerance is tightened a hundredfold (6.35e-6 of the value), rounded up.
- Each rail-exit time: 0.5%. In the same six flights, the apogee time 1%, the burnout height 0.2%, and the height and speed traces 1% of RocketPy’s apogee and 0.5% of its top speed, rounded down to 0.1 m (0.33 ft) and 0.01 m/s (0.033 ft/s). The three in wind keep 3% on those four, for the same model differences. The time of the largest acceleration, the drifts and the flight time keep 3% (the next decision gives each reason).
- Why: the largest of those differences in the report are +0.056% (Juno III’s burnout speed), +0.112% (Valetudo’s apogee), −0.142% (Juno III’s rail-exit time) and +0.238% (Valetudo’s apogee time), and RocketPy’s own solver moves the point metrics far less (the decisions give its figures; the traces’ movement is not recorded), so a drifting number fails long before it nears 3%. The margins are measured on RocketPy’s six example rockets, and they bound agreement between two codes, not accuracy against a flight.
In CI, and regenerating the references
Every pull request but one that changes only research notes (under docs/research/) runs
cargo xtask validate --check on macOS, Windows and Linux, in continuous
integration (CI). It’s the reports job in .github/workflows/ci.yml
(its milestone). The job flies every locked case, compares
each result with the stored RocketPy numbers, and writes nothing. RocketPy itself isn’t run. The job
fails if a scored metric is outside its tolerance, or if the committed report differs from this
run’s.
Numbers may differ in their last digits, because platforms round differently. HPR Sim’s value and
the reference’s are read at full precision from latest.json. Either can move by up to 2e-6 or
1e-7 of the value, whichever is larger. Everything else must match exactly: the cases, sources,
tolerances, verdicts, notes, known gaps and the harness version. And latest.md must be latest.json’s own
rendering (Report::reproduces;
the CI decision).
So a change that moves a number has to commit the report that shows it.
Two builds run these checks in CI. validate --check runs from the everyday (dev) build, in the
reports job. The checks that fly many flights run from report-check, a Cargo build setting
with release’s speed plus the assertions and overflow checks of the everyday build, in the
validate job: cargo xtask motor-catalog --check and the censuses’ slices, on the same pull
requests. Optimizing keeps their numbers to the digits they compare. The flight censuses, cargo xtask synthetic --check, cargo xtask two-logs --check
and cargo xtask fit --check, fly thousands of flights each, so CI runs them whole each night on
main, not on every pull request
(the time budget):
the synthetic flights and two logs on all five platforms, in the census job, and the fit in
parts on Linux. A test fails if a set of synthetic flights is left out, or if its job runs on any
condition but a full run’s, nightly or started by hand (the synthetic flights’ tests). A
nightly failure opens an issue that is fixed before other work. Pull requests, on all five
platforms, and scripts/gate.sh check a slice of each instead: every 21st flight of each set,
202 flights each, and every 21st fit of each of the fit’s runs, 444 fits (below). The command that writes a
census writes its slice beside the report (synthetic-flights.slice.json, two-logs.slice.json,
fit-intervals.slice.json): a line for each thing the census makes of each of those flights, to
the census’s digits. --slice flies them
again and fails, naming the flight, if a line differs (byte for byte on the build that writes the
reports; elsewhere in its words, each number masked and every other word compared, since a flight’s
numbers can move there but what the census counts, such as the side a truth falls on, must not) or if a flight breaks a rule the census
holds every flight to, such as a reading past its bound. So a pull request’s pass covers one flight
in 21; the rest, and what only a whole set shows, its ranges, coverage tests and fitted shares,
wait for the night. scripts/gate.sh (the gate: the checks a change passes on the maintainer’s Mac
before it merges) runs the slices in the build that writes each report: the everyday build, the
optimized one for the fit. The gate’s default run leaves these checks out only when a change is prose they don’t read,
such as most pages under docs/, and a run that names its steps runs them only when validate is
named. So a report in the repository has to reproduce from both builds, its slice in words. If the optimized build
ever came out differently, the nightly run would fail and regenerating wouldn’t fix it: that would need a
decision record, not a looser check.
These checks have a time budget
(the decision record):
each job of a pull request’s CI within 20 minutes, from the moment a GitHub machine starts it
(waiting for a free one isn’t counted), and the gate within 30 minutes on the maintainer’s Mac.
cargo xtask ci-budget checks it; the maintainer’s checks run it before a pull request opens and
again before it merges, and anyone signed in to GitHub’s gh tool can run it. It needs the network, and
fails, saying why, when it can’t read GitHub’s runs. It fails when:
- the branch’s newest full gate, a
scripts/gate.shrun of every default step (a branch that changed only prose may leavevalidateout, and one that changed only the words of pages may leave outsite, the docs site’s build and checks, which CI runs at every width), took over 30 minutes. A step run again after it on the branch, alone or with others, counts at its newest passing time, and a step the full gate lacked is added. A branch with no full gate yet gets a note, not a failure. - any job of main’s newest passing run of a pull request’s checks took over 20 minutes. Such a run
is one started by a push to main, or by hand without the
fullbox ticked; a push that changed only research notes skips most checks, so the run before it is read. - no full run on main has passed in the last 26 hours. A full run is the one that adds the
censuses: each night, or by hand with
fullticked. It passes when everycensusjob and the fit’s whole check passed, and its age is counted from its first attempt, so a run made again later doesn’t count as a new night. The night’s jobs aren’t held to the 20 minutes, since no pull request waits for them. In the one full run read so far, started by hand on 4 November 2026, the census jobs took 22 min 31 s to 37 min 11 s.
The check on the least-squares fit, cargo xtask fit, takes longer than any other
(the flight fit). Its report rests on 6,538 fits of synthetic flights: the
first 1,300 of sets A and B each; the wind’s flights, those of each set’s first 1,500 flights with a
track logger that aren’t among the 1,300 (1,262 of set A’s, 1,276 of set B’s); and set A’s first
200 again with each of seven kinds of pure noise in place of their logs. Then it tests that each
fitted value’s 90% interval holds the truth as often as a 90% interval should. It also makes 2,654
fits of the calibration set, 9,192 in all, to check the
shares (the two factors on a standard error that make each interval, how it
works) against those stored in the code, and the
Bayesian option’s posterior on each fit of sets A and B
with something to fit. By least squares alone it took more than an hour in one Linux job, and the
posteriors make the whole about seven times as long, so CI runs it each night on Linux in 16 jobs
side by side:
- Each job fits a 16th of the flights (
fit --part K/16, with K from 1 to 16): every 16th flight, from the Kth. It saves its fits for the last job. - The last job,
fit intervals, puts the 16 back together. It refuses a part missing or there twice, parts of two different splits, and any flight not fitted exactly once. - Then it runs the check as on a platform other than the one that wrote the report
(
--other-platform; the fit’s decision record, section 7). A count may differ from the committed report by 5, whether of flights, posteriors or failed draws, and the draws made, 500 to a posterior, by 5 posteriors’ worth, 2,500. A figure, and each share fitted on the calibration set, may differ by 5% of the larger of the two values or 0.002, whichever allows more. The slice is held in its words, as above, not by these allowances.
A flight’s fit depends on that flight alone, not on what its thread or machine fitted before it. A test holds that to the bit. On a Mac, three parts put back together left no number of the report different. On Linux, eight printed the same summary of differences from the committed report as one job (the decision record’s amendment, section 7).
Where each part of the fit’s check runs (the time budget):
| Where | Command | What it holds |
|---|---|---|
| A pull request, on all five platforms | fit --slice --other-platform --part K/N, part K of N: N is 3 on Linux, Linux on ARM and Windows on ARM, 4 on macos-latest and 6 on windows-latest | The slice’s 444 fits, each line in its words (a calibration fit’s lines carry no side, so only its first line’s words can differ), the Bayesian option’s posterior among them; the committed report’s verdicts, as its stored bands give them; its stored shares against the code’s |
| The gate, before each merge | fit --slice | The same, each line byte for byte |
| Each night, on Linux | fit --part K/16, then fit --check --other-platform --parts | All 9,192 fits: the report and the shares within the allowances above, the slice in its words |
| By hand, on the Mac that writes the report | fit --check | The whole report to the last digit, and the shares to the code’s three figures |
Each platform fits the slice in parts, in jobs of their own: part K of N fits every Nth fit of the slice’s, from the Kth. By least squares alone one job took 20 min 3 s on windows-latest with nothing cached, over the 20 minutes a job may take, and the Bayesian option’s posteriors took the slice from 79 s to 335 s on the maintainer’s 10-core Mac (the Bayesian option’s decisions, section 9). Each of the slice’s fits of sets A and B with something to fit carries its posterior: how many draws it made and how many failed, how many equal draws the 400 it reads are worth, and each parameter’s 5% and 95% points and median, with the side its truth falls on where the report counts it.
The slice is the same 444 fits every time: part 1 of 21 of each run, its 1st, 22nd and 43rd fit and on. A change that moves only fits outside it, and by less than the night’s allowances (a count by 5 flights or fewer), is found only by the check by hand (issue #1177).
In the same reports job, validate --check ends by holding the committed reports to the accuracy census accepted last
(the regression check,
its decision).
Each number the harness’s report, the real flights’ and both OpenRocket reports hold HPR Sim to is a
row (the census). The check fails when:
- a row moves by more than its slack, 0.1% of its scale, in either direction;
- a row changes its standing, or comes or goes;
- a group’s reference changes.
Regenerating the report isn’t enough to carry such a change in. It takes
cargo xtask census --accept --reason "<why>", and the reason is committed with it. That’s what
holds a predicted-mode number, whose 3% is only a target, to where it was.
CI never runs RocketPy. So it shows that HPR Sim still reproduces the committed report. It doesn’t show that the stored references are still what RocketPy produces. A change in RocketPy or in a generator shows up only when a person regenerates the references.
- Locally:
scripts/regenerate-references.sh, a bash script for macOS and Linux. It needsuv0.12 or later and a one-timecargo xtask refs fetch python rocketpy. It runsrocket_mass.py,cargo xtask designs,recovery.pyandflight.py, in that order, thencargo xtask validate --check, and rewrites the report only if that check fails. It overwrites files undervalidation/in the working tree (git checkout validationundoes it) and lists what changed. It took about 40 s on the Mac it was measured on, after the fetch. - On GitHub: the Regenerate references workflow (
regenerate-references.yml). Only someone with write access can start it, from the Actions tab or withgh workflow run regenerate-references.yml. It starts only from a branch that has the workflow (GitHub dispatches only workflows the default branch has). It runs the same script on an arm64 Mac, like the one the committed references came from, and uploads the diff as thereferences-diffartifact. Its token can read the repository and nothing more, so it can’t commit.
Another machine’s floating point can move the regenerated fixtures’ last digits. A fixture that moved at all makes the report be rewritten too. The first run on GitHub’s Mac did that. The descents moved by at most 3.6e-11 of each value. The whole flights’ largest move was a landing height of 2e-8 m shifting by 3e-9 m, and no printed metric changed.
So the script prints, for each fixture, how many values moved and the largest relative move. Read that before the diff. Either way the result is a diff to read, not a new reference. Committing it is a decision a PR has to argue. That’s a Loft lesson: a reference regenerated whenever a check failed ended up following the simulator it was meant to check.
Whole flights
The whole-flight cases (validation/cases/flight-*.toml) fly RocketPy’s examples
from the pad to the ground, in the same-drag mode. HPR Sim flies the reference’s declared
through Simulation::with_drag_table, on the reference area the reference records.
The metrics are measured as RocketPy defines them, at the center of dry mass
(Loft’s lesson). The rail exit is when the forward button reaches the top of the rail.
The maxima depart from RocketPy’s on purpose. RocketPy takes them at its solution’s points, and HPR Sim finds each peak between its solver’s steps as well. A peak read only at the steps moves with the step sequence, which differs across platforms (how peaks are found in both modes). That can only raise HPR Sim’s reading: against its old step-end reading, it rose by at most 6.3e-5 of itself. RocketPy’s own shortfall isn’t measured.
The first run found a difference in the input, not the model. The transcribed designs corrected
the thrust for ambient pressure with a sea-level stand-in, which RocketPy’s examples never do
(reference_pressure=None). The designs now say None, the reference records the motor RocketPy
flew, and the harness checks HPR Sim’s against it. Heights are measured from the dry center of
mass’s height at launch, since RocketPy’s starts at the ground. The rail exit is taken at
RocketPy’s effective_1rl.
Every scored metric agrees within its gate: 3% or tighter (above). Since RocketPy’s equations were corrected, that includes every drift but seven (report; the path in wind). One is NDRT 2020’s apogee drift. The rest are those of the three rockets that leave the rail slowly for the wind they meet: Prometheus 2022, Juno III and Bella Lui.
The whole-flight references fly RocketPy 1.13.0 with two corrections to its equations, both
merged upstream and neither released (the turn into the wind).
validation/oracles/rocketpy/corrections.py applies them, and each fixture’s corrections records
them. PR #1188 (merged, unreleased) corrects the nozzle’s jet-damping lever. PR #1196 (for
issue #1186; merged on November 16, 2026, unreleased) corrects the sign of the center-of-mass and
nozzle vectors in u_dot_generalized.
As released, RocketPy took its moments during the burn about a mirrored point. It lay as far forward of the dry center of mass as the center of mass is behind it. That made it turn into the wind too far, which was most of issue #50. The corrected function is RocketPy’s own source with PR #1196’s three edits. On RocketPy 1.13.0 each edit must match once, so a RocketPy that has moved stops the generator. A source that already carries all three is flown as it is.
wind_response.py flies every case as released and corrected. With HPR Sim’s rail release, body
lift and thin fins added, it lands within 1.3% of HPR Sim’s drifts in wind
(the path in wind). HPR Sim’s body lift has been Jorgensen’s since
the crossflow-lift milestone. Drop the corrections when RocketPy releases them.
That fix is worth stating, because it’s what comparing like for like means in practice. HPR Sim’s default gravity is the full normal-gravity vector. Above the ellipsoid, it leans a few parts in toward the equator. RocketPy applies gravity to the vertical axis alone.
The difference is 5.2e-4 m of northward drift over an 800 m (2,625 ft) descent. That’s invisible
in every metric that matters, but it swamps the one 20 µm number that doesn’t. HPR Sim ships
GravityModel::VerticalTaylor as RocketPy’s own formula for like-for-like comparisons. The suite
flies that, and the metric comes to −1.8% (the harness, issue #27,
docs/physics/recovery.md).
The committed report carries no timestamp, so a number that moves shows up in the diff. A --fast
run writes latest-fast.{md,json} instead, which isn’t committed. A partial report never stands
in for the whole suite’s record.
Predicted mode
The predicted-* cases fly the same six examples with HPR Sim’s own aerodynamics
(mode = "predicted"; each code’s own drag). Their reference,
validation/fixtures/flight/rocketpy-whole-flight-own-drag.json, is RocketPy flying each example’s
own drag, as RocketPy 1.13.0 flies the example (flight.py --own-drag). The curves stay in
refs/, and the reference records each one’s path and SHA-256 (the drag decision). Each
mode refuses the other’s reference.
Each predicted metric keeps the RocketPy comparisons’ 3% as a target, not a gate
(predicted mode). Its verdict is within target or outside target. It sits in the
report’s own Predicted mode section and never fails the run. Neither code’s drag is the truth,
so a miss is a measurement to explain. Each case file explains its own.
Of the 102 predicted metrics, 75 are within target. The apogees are −7.280% (Prometheus 2022), +0.601% (Calisto), +1.278% (Bella Lui), +2.951% (Juno III), +10.113% (Valetudo) and +10.302% (NDRT 2020) (report). In the last two, HPR Sim’s drag is well below the example’s, which also moves their times and drifts. Juno III’s and Bella Lui’s drifts in wind differ as in same-drag mode (the path in wind).
Since HPR Sim’s drag reached past Mach 1 (its sources), Prometheus 2022 flies through Mach 1 on it. Its peak Mach is +1.069% from RocketPy’s (report), with 9 of its 17 metrics within target. HPR Sim’s coasting drag rises toward Mach 0.8, where the example’s falls, so it coasts lower (case file). HPR Sim’s drag is for the designs as transcribed, whose fin edges and finishes are placeholders where the examples record none. Predicted mode flies at rtol = atol = 1e-11, so its report reproduces across platforms (predicted mode).
Real flights
cargo xtask real-flights [--check] flies seven of RocketPy’s documented rockets with HPR Sim’s
own aerodynamics (logged flights, how they’re compared). They’re Bella Lui,
NDRT 2020, Prometheus, Juno III, Cavour, Genesis and Lince. Each flies on its example’s own thrust
file, from its rail and site, in the ERA5 file and hour its notebook reads. It’s compared with its
team’s altitude log: the apogee, and the RMS of the height over the ascent. Both clocks are aligned
where each trace first reaches 30 m (98 ft).
The command then flies the five public flights whose predictions were merged first (below) and compares each with its log at the apogee (the errors, the decision). The report holds all 12, and its means are over all 12.
HPR Sim’s height is read as the log’s barometric altimeter reads the air: the standard
atmosphere’s altitude of the pressure of the air it flew in, less the start’s. Each log of the seven compared first is read up to its apogee,
stopping before the recovery’s pressure transients; each predicted flight’s is read by the rule
merged with its prediction. The logs, thrust files and weather files are
read from the pinned checkouts under refs/ and never committed. The report,
validation/reports/real-flights.{json,md}, commits only the numbers and each file’s SHA-256. Each
of the seven is flown again on its example’s own drag as a diagnostic.
The mean absolute apogee error is reported against the 5% target of the principles above, not
gated. Among the seven compared first, a flight outside 5% must carry an explanation that’s a
checked claim, and one inside must not. drag says the flight on the example’s drag is within the target, and any on the recorded
thrust file isn’t. thrust is for an example that reshapes its thrust file. The flight on the
file as recorded is within the target, and the one on the example’s drag isn’t.
CI has no refs/, so it holds the committed report to itself
(hpr_validate::tests::real_flight_cases_report_apogee_and_trace_rms). It holds the summary to
the rows, each percentage to its meters, and the words and each flight’s inputs to the code’s. It
holds the committed files read to their digests, the page to the data, and each explanation to its
numbers. Where the checkout is, --check flies it again.
Today the mean absolute error is 8.88% over 12 flights, outside the target, and 6.06% over the seven compared first. Five of the seven are outside 5%: NDRT 2020, Prometheus, Cavour and Genesis consistent with HPR Sim’s drag, and Juno III with its motor’s impulse. Four of the five predicted first are outside 5% too, with no explanation claimed. Seven of the 12 altimeters’ kinds are assumed barometric (evidence rows G21 and G39). With those seven read as heights instead, the mean is 9.01%.
Public flights predicted first
cargo xtask public-predictions [--check] flies the listed public real flights whose predictions
merged before their logs were compared, each from its record alone
(the EuRoC 2022 predictions,
why they merge first).
Today they’re Astra, Andromeda and Erebus 11, and both flights of Macie XL
(the Macie XL predictions). It writes each one’s inputs with their sources, the
rule its log’s apogee is read by, and the predicted apogee to
validation/reports/public-predictions.{json,md}. It hashes each log, to pin the file, and never
parses one. The report has no field for a measured apogee or an error.
The three fly in one ERA5 file that is netCDF-4.
validation/oracles/netcdf/euroc_2022.py converts it as the
ERA5 page says, into the gitignored refs/. It fails
unless the four fields keep their values bit for bit and RocketPy reads the same levels from both
files at each flight’s site and hour. validation/fixtures/weather/euroc-2022-conversion.json
holds both files’ SHA-256 and the levels RocketPy read. A prediction flies the converted file only
if it has the recorded SHA-256 and HPR Sim reads those levels from it: the same pressures, and
every other value within 1e-12 of its size (1e-12 outright for a value under 1).
--check flies the predictions again and fails when one differs from the committed one. The
code’s list of merged apogees (MERGED) keeps each flight’s, as a reading and as a height, to
the digit the page prints. The writers and CI refuse a prediction that has moved from it, unless
the code’s list of revisions (REVISIONS) gives the number flown now and the reason. The
real-flights report then shows the new number beside the merged one, with both errors. That list
is empty today. CI, without the checkout, also holds the
committed predictions to the code’s list of flights, to the committed designs’ and the design fixture’s digests, to their
page, and to the file’s own text: a key for an error or a measured value fails.
The comparison is the real-flights report’s
(hpr_validate::tests::real_flights_print_each_merged_prediction_beside_its_error). Each log’s
apogee is read by the rule merged with its prediction, written as code in
hpr_validate::predicted_first and held to the merged words by a test. The log must be the file
whose SHA-256 the predictions hold. CI holds the committed report’s five rows to MERGED, to the
committed predictions’ digests and tags, and to their own meters. It fails a report that drops
one of the five, or that moves a prediction with no revision.
The two Macie XL flights are read from a design file, not built from an example. The lock file
(validation/refs.lock.toml) pins their repository under refs/public-flights/ (cargo xtask refs fetch rocketry-files). Each is flown as the stored simulation the repository names for it,
from the file as OpenRocket 24.12 saved it. A flight is refused if that simulation lacks its rod,
wind or site, or was run in another atmosphere or wind model. It is also refused if it would fly a
curve file other than the one the table gives for the design’s digest
(crates/hpr-motor/data/openrocket-curves.json, written by cargo xtask ork-curves). CI holds
their committed rows to the lock’s pin, to that table and to the code’s list.
Simulators and papers
The simulators HPR Sim is compared with, and the papers its models come from.
Reference simulators (oracles)
| tool | use | license | where | notes |
|---|---|---|---|---|
| RocketPy 1.13.0 (PyPI, 2026-07-22) | primary code-to-code oracle; headless Python | MIT | https://github.com/RocketPy-Team/RocketPy | Install in a uv venv under refs/. Whole flights fly it with upstream PRs #1188 and #1196 applied (validation/oracles/rocketpy/corrections.py, the path in wind). Acceptance tests to mirror: tests/acceptance/test_{bella_lui,ndrt_2020,prometheus}_rocket.py. Example apogees are in docs/examples/index.rst |
| OpenRocket 24.12 jar | second oracle (run only, never read its source) | GPL-3.0 | https://github.com/openrocket/openrocket/releases/download/release-24.12/OpenRocket-24.12.jar | Needs Java 17 exactly: it refuses 21 with “Supported version(s): 17”. brew install openjdk@17 is keg-only, so /usr/libexec/java_home will not list it; refs doctor scans the Homebrew kegs and takes it. The OpenRocket comparisons drive it through JPype. |
RocketSerializer (66d8ca8, after 0.2.0) | .ork to RocketPy converter; a second reader of the same files | MIT | https://github.com/RocketPy-Team/RocketSerializer | Pinned, with the environment it runs in, by validation/oracles/rocketserializer/requirements.txt. validation/oracles/rocketserializer/geometry.py calls its extractors one by one on each design and asks OpenRocket 24.12 for the same numbers; cargo xtask ork holds HPR Sim’s nose cone, transitions, fin sets, stations and body radius to both (the cross-check, three readers): the current 2026-09-23 survey compares 1,171 numbers over 71 designs, none where HPR Sim is apart from both, and every one of HPR Sim’s also OpenRocket’s. It runs in its own environment, refs/venv-rs, installed with --no-deps so that its orhelper dependency (GPL-2.0) is never installed; the record for Loft’s public demo designs is validation/fixtures/ork/rocketserializer-loft-demo.json, checked in CI by xtask’s rocketserializer_agrees_on_the_loft_demos |
| RASAero II 1.0.2.0 | Windows-only freeware; no automation | closed | https://www.rasaero.com/dl_software_ii.htm | Use only the exports that ship with RocketPy data. The transonic normal force also reads the full Calisto export of RocketPy’s first commit (, and CP to Mach 25; rocketpy-calisto-rasaero-2018 in the lock) for the normal force against Mach (its decision). Only Calisto’s (data/rockets/calisto/powerOffDragCurve.csv) is traceable to a RASAero II export; Juno III’s, Cavour’s and Valetudo’s are labeled RASAero but are 3-decimal tables with no input file, and Valetudo’s disagrees with its own OpenRocket export by 44%. The drag milestone compares HPR Sim’s subsonic with all four at Mach 0.3 (its decision), and the RASAero comparison every 0.05 from Mach 0.1 to 2.0, by band (the gap by band; results in docs/physics/aero.md) |
| JSBSim | optional generic 6-DOF cross-check | LGPL-2.1 | https://github.com/JSBSim-Team/jsbsim | low priority |
| CamPyRoS | dormant; includes Martlet 4 RASAero data | GPL-3.0 | https://github.com/cuspaceflight/CamPyRoS | Run-only if used at all |
| Missile DATCOM | do not use (ITAR) | n/a | n/a | n/a |
OpenRocket jar. One probe runs it headless, with empty motor and preset databases bound in place of the graphical ones: validation/oracles/openrocket/automatic_radius.py → validation/fixtures/ork/openrocket-automatic-radius.json, the radius OpenRocket gives an automatic body radius with nothing to take (0.025 m (0.082 ft); OpenRocket’s default), held by hpr_io::ork::tests::a_radius_with_nothing_to_take_is_openrockets_default; validation/oracles/openrocket/mass.py → the structure mass, center of mass and inertias of every design OpenRocket opens, which cargo xtask ork holds HPR Sim’s to (structure mass, its decision; the public record is openrocket-mass-loft-demo.json); and every body radius it settles on in the 17 jar examples and the parachute catalog, which cargo xtask ork holds HPR Sim’s to (67 of 67 agree). The GPL-2.0 orhelper wrapper was dropped from the environment rather than imported. 17 example .ork files are in the jar under datafiles/examples/ (use them locally, don’t commit them; only numbers computed from them, such as the body radii in the automatic-radius fixture, are committed)
Primary physics sources (download to refs/papers/)
- Barrowman 1967 thesis (NTRS 20010047838): https://ntrs.nasa.gov/api/citations/20010047838/downloads/20010047838.pdf
- Barrowman 1966 report: https://www.apogeerockets.com/downloads/barrowman_report.pdf
That copy lacks printed pp. 39–50, the worked examples. The complete scan is
https://www.nakka-rocketry.net/articles/Barrowman.NARAM-8.pdf, bound with Barrowman’s Centuri
TIR-33 (1970). Its five worked examples (Testbed II, Aerobee 350, Javelin, Recruiter, Arcon-Hi)
are level-2 references for and CP. They’re in
validation/fixtures/aero/barrowman-worked-examples.json, checked within 1% byhpr_aero::tests::barrowman_worked_examples(normal force and CP,docs/physics/aero.md). Four pass on HPR Sim’s own model. The Recruiter’s six-fin slopes pass only with TIR-33’s own six-fin rule substituted. With HPR Sim’s rule (MIL-HDBK-762, the subsonic normal force), they’re +3.4% (fins) and +2.9% (total). - Niskanen 2009 OpenRocket thesis (CC BY-NC-ND; read for methods only, don’t copy):
https://github.com/openrocket/openrocket/releases/download/Development_of_an_Open_Source_model_rocket_simulation-thesis-v20090520/Development_of_an_Open_Source_model_rocket_simulation-thesis-v20090520.pdf - OpenRocket technical documentation v13.05 (CC BY-SA):
https://github.com/openrocket/openrocket/releases/download/OpenRocket_technical_documentation-v13.05/OpenRocket_technical_documentation-v13.05.pdf - Karney’s geodesics (pinned as
karney-2013-algorithms-for-geodesicsandkarney-geodtest): C. F. F. Karney, Algorithms for geodesics, arXiv:1109.4448v2. His CC0 Test set for geodesics, doi:10.5281/zenodo.32156, has 500,000 WGS 84 geodesics. Every 500th line and the 21 mirror lines are committed, andvalidation/reports/geodesics.mdholds the whole set’s errors. - GeoTIFF elevation (pinned as
ogc-19-008r4-geotiffandusgs-3dep-1-n33w107): the OGC GeoTIFF Standard 1.1, and the USGS 3DEP 1-arc-second tile n33w107 (public domain). Its fixtures and whole-tile reading by rasterio 1.5.2 (GDAL 3.12.2), the outside reader, are incrates/hpr-io/tests/fixtures/geotiff/(validation/oracles/geotiff/dem.py; the reader’s design). - ThrustCurve.org’s API (https://www.thrustcurve.org/info/api.html): two public-domain curve
files, recorded October 1, 2026, and three makers’ searches, recorded unchanged October 29,
2026, in
crates/hpr-net/tests/fixtures/replay/. The searches hold 663 records; each solid motor’s equals the record in the October 28 snapshothpr-motorships. Thethrustcurve-standin-*files beside them are invented answers, for the on-demand fetch’s cases the real records lack.validation/reports/thrustcurve-join.mdholds the in-stock motors’ match to them (why the match is by name only; why the records are used). - OpenRocket’s parts catalog (pinned as
openrocket-database, Apache-2.0): its 16.orcfiles, bundled incrates/hpr-io/data/openrocket-database/. OpenRocket 24.12 read every part, each file with its stated masses removed, and 37 probe files. Its readings are incrates/hpr-io/tests/fixtures/orc/openrocket-presets.json(validation/oracles/openrocket/orc_presets.py; the departures and their causes). What OpenRocket builds from each part and from 6 probe parts is incrates/hpr/tests/fixtures/orc/openrocket-built.json(validation/oracles/openrocket/orc_built.py). For each part, that’s its mass, center of mass and the dimensions the file leaves unsaid.crates/hpr/tests/catalog_openrocket.rsholds the builder’s parts to it (catalog parts). - US Standard Atmosphere 1976:
https://ntrs.nasa.gov/api/citations/19770009539/downloads/19770009539.pdf. Python cross-checks:
ambiance(Apache-2.0),pyatmos(MIT). - NASA sounding-rocket stability tests: NASA TN D-4013 (NTRS 19670020050, Mach 0.6–1.2) and
TN D-4014 (NTRS 19670020031, Mach 1.5–4.63), on half-scale Arcas Robin models. Their plotted
normal force, center of pressure and model dimensions are read into
validation/fixtures/aero/arcas-robin-wind-tunnel.jsonwith figure and page. They’re the level-3 reference for the normal force through Mach 1, checked byhpr_aero::tests::normal_force_against_mach(its decision). Their forebody axial force (drag without the base), fins on and off (TN D-4013 Figs. 11–12, TN D-4014 Figs. 5–6), is in the same file. It’s the level-3 reference for the drag through Mach 1 (its decision), compared invalidation/fixtures/aero/drag-vs-mach.jsonand checked byhpr_aero::tests::drag_against_mach. Of 44 rows, 2 are within the 10% target set before measuring, HPR Sim reading high (docs/physics/aero.md). Their roll effectiveness (TN D-4014 Fig. 14) is for roll and damping. - Hermes A-3A free flights with the motor burning: H. H. Jackson, NACA RM SL55F15 (1955),
NTRS 20010057623, pinned as
naca-rm-sl55f15-jackson-1955. Its Fig. 20 gives the base drag with the motor burning and coasting, its error believed to be under ±0.005. Below Mach 0.8 it is read by pixels (validation/oracles/naca/hermes_base_drag.py) intovalidation/fixtures/aero/hermes-a3a-base-drag.json, with the model’s sizes. It is the measured reference for the base term of the part below Mach 0.8 by term.cargo xtask aerowrites HPR Sim’s base drag on it tovalidation/fixtures/aero/base-drag-under-power.json. Its tests (xtask/src/aero_base_power/tests.rs) hold which way each rule errs. Under power HPR Sim’s rule as it flies reads low. Power off it reads high, by less since M1.14i3 changed the base behind a boattail (the base under power, against a measured flight). - Stoney’s base drag of a conical afterbody: NASA TR R-100 (1961), printed p. 11. From tunnel data, the cylinder’s base drag times on the largest cross-section. HPR Sim’s base behind a boattail below Mach 0.8 keeps of the flat-base value by it (M1.14i3, the base model).
- Stoney, zero-lift drag of bodies of revolution: NASA TR R-100 (1961), NTRS 19630004995.
Figure 12’s nose pressure-drag curves at fineness 3 are read into
hpr_aero::nose_dragas the model’s own data, not as a reference. Niskanen’s appendix B uses them the same way. The figure’s 3:1 cone checks Niskanen’s closed-form cone (transonic drag, Stoney’s curves). - Galejs, “Wind instability”: https://www.argoshpr.ch/j3/articles/pdf/sentinel39-galejs.pdf
- MIL-HDBK-762 (design of aerodynamically stabilized free rockets):
https://archive.org/details/MILHDBK762DesignOfAerodynamicallyStabilizedFreeRockets. Its sample
drag calculation (Table 5-4, pp. 5-58 to 5-66, for the rocket of Fig. 5-155) is transcribed into
validation/fixtures/aero/mil-hdbk-762-sample-drag.json. It gives a whole rocket’s drag, term by term, from Mach 0.5 to 3.2 with every input known. It’s a calculation by the handbook’s methods, not a measurement, so it’s a code-to-code reference. It’s compared invalidation/fixtures/aero/drag-vs-mach.jsonand checked byhpr_aero::tests::drag_against_mil_hdbk_762_sample(drag against RASAero II, the sample calculation). Of 12 rows, 6 are within 10%. HPR Sim reads +12.3% to +31.9% high from Mach 0.9 to 1.2. It reads 6% to 10% low from Mach 1.6, and 10.3% low at Mach 0.5 (docs/physics/aero.md). - D. J. Martin’s NACA TN 4197 (1958), NTRS 19930085030, for fin flutter. NTRS serves it with a
436-byte header before
%PDF, and the lock pins the bytes as served. - T. W. Knacke’s Parachute Recovery Systems Design Manual, NWC TP 6575 (1991), DTIC ADA247666, for parachute inflation. DTIC refused automated downloads, so the lock uses archive.org’s mirror of the DTIC copy. It’s a contractor report. DTIC stamps it for public release, but the title page limits distribution to US Government personnel. So cite it and never redistribute it.
- The Descriptive Geometry of Nose Cones (1996), by G. A. Crowell Sr., is cited but not pinned.
The only copy found is a plain-http mirror
(
servidor.demec.ufpr.br/CFD/bibliografia/aerodinamica/Crowell_1996.pdf), with no license stated. Its curves are checked by closed forms and byvalidation/oracles/design/shapes.py→validation/fixtures/design/shape-integrals.json(mpmath, 40 digits, 22 noses and transitions). Every filled volume, centroid, moment and area agrees to 1e-12 relative. Walls:validation/oracles/design/walls.py→validation/fixtures/design/wall-integrals.json(20 walls, 25 digits): volume, centroid and moments agree to 1e-10 (part shapes,docs/physics/shapes.md). - Material densities: USDA Forest Products Laboratory, Wood Handbook FPL-GTR-190 (2010),
pinned as
fpl-gtr-190-wood-handbook. Manufacturers’ data sheets and military specifications are cited per value with URLs inhpr_design::materials(part materials,docs/physics/mass.md). - An index of further references: https://wiki.openrocket.info/Resources
- There’s no legitimate free copy of Topics in Advanced Model Rocketry. Don’t use pirated copies.
Reference data
The flight logs, motor data, recovery tests, design formats and weather sources the checks draw on.
Real flight data
Most of it lives in the RocketPy repo (MIT; its notebooks record each team’s permission), under
data/rockets/.
| flight | files | notes |
|---|---|---|
| Bella Lui 2020 (EPFL) | EPFL_Bella_Lui/bella_lui_flight_data_filtered.csv | time, z, v |
| NDRT 2020 (Notre Dame) | NDRT_2020/ndrt_2020_flight_data.csv | accel in g, altitude in ft AGL. RocketPy sim 1,296.77 m (4,254.5 ft) vs measured 1,316.75 m (4,320.0 ft, the log’s highest reading is 1,320.4 m (4,332 ft)) |
| Prometheus 2022 (Western Engineering, SA Cup; not Cal Poly) | prometheus/*TeleMetrum.csv, *TeleMega.csv | raw AltOS CSV with GPS; also our AltOS importer test |
| Juno III 2023 (Projeto Jupiter, SA Cup) | juno3/{cots_altimeter,cots_GNSS,srad_telemetry}.csv | RRC3 log |
| Andromeda, Astra, Erebus 11 (EuRoC 2022) | andromeda/flight_data.csv, astra/flight_data.csv, erebus11/flight_data_filtered.csv | time and altitude: t(s), alt(ft), vz(ft/s), alt(m), vz(m/s); t, alt, lat, lon; alt, t |
| Halcyon (Aerospace Team Graz) | astg/altimeter_halcyon.csv, astg/gnss_halcyon.csv | |
| Genesis, Cavour (PoliTo), Camões, Lince | genesis/, polito/, camoes/, lince/ | |
| Hedy 2025 (TU Wien) | hedy/cats_tust/*.csv | CATS logs with IMU |
| Valkyrie 2025 | valkyrie/flightInfo_merged.csv | |
| Valetudo, Defiance | apogee only (no time series) | Defiance sim 9,238.01 m (30,308.4 ft) vs measured 9,308.32 m (30,539.1 ft) |
Matching ERA5 netCDF files for NDRT, Bella Lui, Spaceport America
2018/2023 and EuRoC 2022/2023/2025 are in data/weather/*.nc, and a NASADEM tile is in
data/sites/. They make excellent offline test fixtures for the weather-file readers.
Other sources:
- Altus Metrum AltOS (GPL-2.0 software; format docs at
https://altusmetrum.org/AltOS/doc/altusmetrum.html):
.eeprom/.telemfiles and CSV export. - DOFPro archive (https://dofpro.org/RCK/fltdata/): PerfectFlite
.pf2, Raven.FIPa, AIM.xtraand CSV. No license is stated, so fetch these and don’t commit them. - Eggtimer has a telemetry spec PDF on eggtimerrocketry.com.
- No official sample files were found for Featherweight and PerfectFlite. Mark them “needs samples”.
nrdptel/loft-fixtures(private): 38 files from OpenRocket, RockSim, RASAero, RocketPy and SpaceCAD. Since one fixture repository, it’s read from a byte-exact copy of the commit Loft used,37251476e5cfee330c88aa94cf0dd58f93370ccd. The copy isimported/loft-fixtures/in the private flight collection (below). ItsCHECKSUMS.sha256manifest is still pinned at sha256d909aeae6e063b629a161ba36dcc0f8b51e45313997789c8ecbc71e342971510. Many.orkfiles carry stored OpenRocket simulation results, so they’re a free code-to-code reference now that the.orkimporter exists. Never commit these files (rule 4 in CONTRIBUTING.md).nrdptel/debrief-fixtures(private): flight logs gathered for Debrief, 62 files in its manifest (commit722f07cd5d9d8595b31c64e2964fb7fbd5e751e7). Since the same change, it’s read from its byte-exact copyimported/debrief-fixtures/in the private flight collection (below). The logs come from about 30 flights of team, certification and sport rockets, recorded by altimeters of a dozen makes. None is a flight of aloft-fixturesdesign (the finding). Never commit these files (rule 4 in CONTRIBUTING.md).nrdptel/hpr-sim-fixtures(private): 468 real flights gathered for this project. Each is a design paired with what its source says of that flight, and each flight’s notes list its gaps. In the 89 of tier A, the source itself ties the design as flown to a numeric barometric log. Each of those has the exact motor, date, site and the day’s ERA5 weather. It’s pinned at commit7268bcd036a0e79f75ecb6ee2896327722fb8ab3, with aCHECKSUMS.sha256manifest of 9,557 files. Since that change it’s the only fixture repository, itsimported/holding the two above.cargo xtask fixture-flightsflies its 83 tier-A.orkflights in HPR Sim and OpenRocket. Of them, 60 are compared with their logged apogees, rechecked against the collection’s catalog. On the 68 both fly, the gap between the two is split by cause: thrust, mass, drag and other, with the tangent-ogive nose’s pressure drag sized inside the drag on the 5 flights past Mach 1 that have a tangent-ogive nose. The collection’s files may not be redistributed, so only aggregate statistics are published, crediting the sources collectively (report, how; the decision that adds it). A result derived from its ERA5 files also carries the Copernicus attribution and the ERA5 citation itsLICENSING.mdgives. Never commit these files (rule 4 in CONTRIBUTING.md).nrdptel/fusionspace-loft(MIT, Neer’s):- Eight demo
.ork/.rkt/.CDX1fixtures infixtures/src/(as XML). - A RocketPy cross-check (
fixtures/rocketpy-cross-check.json,scripts/rocketpy/). - A candid limitations log (
app/docs/limitations/page.tsx). - The known importer bugs listed in Loft’s notes and
BACKLOG.md:.CDX1parts ignore<Location>and.orkautoradii are lost on round trip. Stage-boundary auto-radius resolution is wrong too.
- Eight demo
Motor data
| source | what | license | notes |
|---|---|---|---|
ThrustCurve.org API v1 (/api/v1/{metadata,search,download}.json) | motor metadata and simfiles | spec is ISC; data license per file (PD, free, other, or none; “free” can be GPL) | Cache results and give attribution. search.json?maxResults=10000 returns every motor (1,156 on 2026-09-17), out-of-production and hybrid ones included, so filter to solids; availability=all is ignored. On 2026-09-17, of 1,712 solid-motor files, 554 were PD, and 196 of those matched the stored statistics within 1%; on 2026-10-28, 1,706 files, 589 PD, and 412 of the 1,701 indexed pass. The solid-motor milestone bundled 32; since M5.7b1 the whole solid catalog of a 2026-10-28 snapshot is compiled in (crates/hpr-motor/data/thrustcurve/, validation/oracles/thrustcurve/snapshot.py, the bundled catalog; survey in docs/research/thrustcurve-data.md) |
RASP .eng spec | https://www.thrustcurve.org/info/raspformat.html (thrustcurve-rasp-format) | n/a | implicit (0,0) first point; ends at zero thrust. Reader and writer: docs/format/eng.md |
RockSim .rse spec | https://www.thrustcurve.org/thirdparty/RockSim%20Engine%20File%20Format.pdf | n/a | XML; real files disagree with the guide on names and units. Reader and writer: docs/format/rse.md |
| ThrustCurve.org statistics code | simulate/analyze/analyze.js at commit 577afa6 (thrustcurve3-analyze) | ISC | validation/oracles/thrustcurve/analyze_stats.js runs it unchanged on every file stored as passing (412) → validation/fixtures/motor/thrustcurve-analyze-stats.json; HPR Sim’s impulse, burn window and thrusts agree to 3e-15, with the code’s 50 µs merge also turned off on the 8 files it merges (ADR-304); --recount recounts the passing files from the raw snapshot (solid motors) |
RocketPy SolidMotor | mass, centers and inertia vs time for BATES grains | MIT | validation/oracles/rocketpy/solid_motor.py → validation/fixtures/motor/rocketpy-solid-motor.json (three bundled curves). Total mass and both inertias agree within 7.9e-5 relative, the center of mass within 5.9e-6 of the motor length; propellant quantities within 1e-4 of their ignition values (solid motors; scales in docs/physics/motor.md) |
RocketPy Rocket with a motor | total mass, center of mass and inertia vs time for twelve example rockets (Calisto at two motor positions), Prometheus’s with a GenericMotor | MIT (notebooks and tests only; Valkyrie’s data-file inputs are left out) | validation/oracles/rocketpy/rocket_mass.py → validation/fixtures/design/rocketpy-rocket-mass.json: each example’s own inputs, with a bundled public-domain curve near its thrust file’s impulse in place of that file (Andromeda’s is the catalog motor its notebook names) (the design tree). HPR Sim’s designs (validation/designs/) agree at RocketPy’s LSODA knots within 8e-10 (grain propellant mass 2.5e-9), and between knots within 1.4e-5 in mass, 4.0e-6 of the length in center and 2.6e-5 in inertia, RocketPy’s resampling; dry values to 3.5e-16. Camões, whose motor would test nothing the others don’t, is not a case; Cavour is, for its drag curve, and Genesis and Lince for their logged flights (real flights), as Astra, Andromeda and Erebus 11 are (the EuRoC 2022 predictions) (design tree, drag, docs/physics/design.md) |
broofa/thrustcurve-db | JSON snapshot including thrust samples | ISC (code) | handy offline seed; check the data terms per curve |
| openrocket/motor-database | weekly SQLite mirror | GPL-3.0 | run-only reference; don’t bundle |
| motor.fusionspace.co API v1 | live US stock and prices (AeroTech, Cesaroni, Loki) | CC BY 4.0, credit “Motor stock data from motor.fusionspace.co” | https://motor.fusionspace.co/api/v1/{meta,motors,in-stock,vendors}.json, /motors/{mfr}/{designation}.json (/ becomes ~), /openapi.json. Refreshed hourly, CORS-open, no key. Prices are in integer cents. schema_version is 1. Docs: https://github.com/nrdptel/Hobby-Rocket-Motor-Finder/blob/main/docs/api.md |
| Certification | certOrg field in ThrustCurve | n/a | no machine-readable NAR/TRA/CAR lists |
Recovery
| source | what | license | notes |
|---|---|---|---|
RocketPy Flight parachute phase | descent rate, descent time and drift for five example rockets (Calisto, Valetudo, NDRT 2020, Prometheus 2022, Juno III) | MIT | validation/oracles/rocketpy/recovery.py → validation/fixtures/recovery/rocketpy-descent.json, replayed by hpr_sim::recovery::tests::descent_matches_rocketpy_examples (figures under Parachute phase below). |
RocketPy Flight from the pad | apogee and time to it, maximum velocity, Mach and acceleration, rail-exit velocity, burnout altitude and velocity, and the trajectory, for the same five example rockets and Bella Lui | MIT | validation/oracles/rocketpy/flight.py → validation/fixtures/flight/rocketpy-whole-flight.json, the same-drag reference the whole-flight comparison scores HPR Sim against (details under From the pad below). |
| Knacke’s canopy tables | drag coefficients on the nominal area, canopy fill constants, drag-area growth exponents and opening-force coefficients | no clear terms: cited, never redistributed | transcribed into hpr_sim::recovery::CanopyType with the printed page at each accessor, and pinned by hpr_sim::recovery::tests::default_canopy_cd_carries_its_citation (which also fixes HPR Sim’s default as the middle of each printed range) |
Parachute phase. HPR Sim and RocketPy both start from the same declared post-burnout state with the first device open, the same drag areas, triggers and declared wind, RocketPy’s noise zeroed, and (since issue #27) RocketPy’s own gravity model, compared as a vector rather than a magnitude. Agreement: descent time within 0.71%, impact descent rate within 0.03%, drift magnitude within 0.28% in the four cases with wind (Valetudo’s still-air 0.19 m (0.62 ft), from the Earth’s rotation alone, −0.89%), the worst single drift component 2.86% (NDRT’s 49 m (161 ft) south of a 327 m (1,073 ft) drift, where RocketPy’s added mass is 15.9 kg against a 20.8 kg rocket), and the deployment heights of the later devices within 0.17% (RocketPy’s trigger sampling). The oracle runs at rtol = atol = 1e-8; at 1e-6 every compared metric moves by at most 3.5e-6 (its one larger entry, 2.1e-3, is on Valetudo’s 20 µm north drift component, which the parachute milestone did not compare; the harness measures it, and reading 28x high there is what found the gravity-model difference in the harness’s decision, issue #27). Parachutes; docs/physics/recovery.md
From the pad.
- The drag is declared by the generator as a constant and handed to RocketPy’s
power_off_dragandpower_on_drag: RocketPy’s own exports carry their own terms and are never committed (the drag decision), and a Mach curve invented here would be an uncited drag model inside the reference (Loft’s invented curve). Same-drag mode scores the equations of motion, not the aerodynamics. - Everything but each example’s rail comes from the mass fixture by way of
recovery.py; Bella Lui, added in the whole-flight comparison because Prometheus could not be scored until the transonic normal force, declares its site and wind inflight.pyitself (its example’s weather is an ERA5 file). Each case records the parachutes it flew, so the harness reads everything from the reference (like for like). - Reproducible byte for byte; the loose run at rtol = atol = 1e-6 (RocketPy’s default rtol) moves every metric by at most 3.9e-3.
max_time_stepis bounded at 0.05 s: without it, thrust(0) = 0 and the generator’s 6,000 smax_timelet LSODA step over the whole burn and no case leaves the rail (issue #33). - Recorded gap until the transonic normal force: Prometheus peaks at Mach 1.013, which HPR Sim refused until its normal force passed Mach 1 (its decision); since then it flies and is scored, its drifts reported as body lift.
max_accelerationis the whole flight’s, which for NDRT and Prometheus is the parachute, so a power-on maximum is recorded beside it.- The flight script; scored in the whole-flight comparison (what is compared): five cases pass every scored metric within 3%; Prometheus was a known gap until the transonic normal force.
- Since the turn-into-wind fix RocketPy flies with the upstream corrections to its equations (
corrections.py, the path in wind): the largest scored whole-flight difference is +1.783% in height, speed and acceleration and, since body lift took Jorgensen’s size (crossflow lift, its decision), −1.811% in a drift (Valetudo’s landing), and eight metrics are argued as not scored, five of them drifts in wind that HPR Sim’s body lift and rail release account for (wind_response.py); the transonic normal force adds Prometheus’s two drifts and its main opening, eleven in all. - The trajectory is the
series, 120 rows of time since ignition, height and speed of the center of dry mass, which the time-series check compares (the RMS): HPR Sim’s height and speed at the same times, from the shared ignition clock with no fitted shift, until HPR Sim lands, as a root mean square held to 3% of the reference’s apogee and max speed (1% and 0.5% in the six flights with no written model difference, since the decision that tightened them). All eighteen same-drag RMS pass (height 0.09 to 35.4 m (0.30 to 116 ft), speed 0.02 to 1.55 m/s (0.066 to 5.1 ft/s), since Jorgensen’s body lift; the largest are Prometheus’s)
Streamers and tumble
These are the sources for streamer and tumble recovery.
| source | what | license | notes |
|---|---|---|---|
| C. Kidwell, Streamer Duration Optimization, NAR R&D, NARAM-43 (2001) | free-drop descent rates and per-streamer masses for sixteen 4 in × 40 in streamers over 20.1 m (66 ft) | no terms stated: cited, never redistributed | the measurement both streamer models are checked against, recomputed in hpr_sim::recovery::tests::streamer_models_against_kidwells_drop_tests with his normalization to a notional 5 g weight and his distance-over-time rates compared against the same average from the closed-form fall. His unpleated crêpe streamer descends at 2.80 m/s (9.2 ft/s), a of 0.155 on the planform area: Carruthers and Filippone’s correlation gives +9%, the OpenRocket technical documentation’s appendix C +88%. His pleated streamers descend slower than either model, and HPR Sim models no pleats |
| A. C. Carruthers and A. Filippone, J. Aircraft 42(4), 2005 | wind-tunnel drag of cotton streamers clamped at the luff, 3.3 to 30, 6 to 18.9 m/s (20 to 62 ft/s) | paywalled; the authors’ post-print states no terms: cited, never redistributed | HPR Sim’s default streamer model: all three of its fitted curves, eq. 1 ( at 0.075 m²), eq. 2 ( at 0.025 m²) and the trend line printed on Figure 3 ( at 0.05 m², which the text does not repeat as an equation), pinned by streamer_models_reproduce_their_printed_equations. HPR Sim interpolates between neighbors in and holds the end curve outside; blending only the two equations reads 18% low at |
| OpenRocket technical documentation v13.05 | appendix C’s streamer correlation, §3.5’s tumbling model with its fin efficiency table, and Table 3.3’s five drop-test models | CC BY-SA | all transcribed with their printed pages and pinned by tests. Replaying Table 3.3 through HPR Sim’s reading of §3.5 (the_tumble_model_against_its_own_drop_tests) gives −5.8%, −5.4%, −7.2%, +19.0% and −10.0%, not the 3 to 14% the documentation claims for its own fit: the finless tube wants a body coefficient near 0.79 where the model prints 0.56, and the text pins neither area convention. The fit covers 6.8 to 160 g at 5 to 6.6 m/s (16 to 22 ft/s), so a high-power body tumbling is an extrapolation (docs/physics/recovery.md) |
Design formats
| format | spec status | notes |
|---|---|---|
OpenRocket .ork | zip containing rocket.ork XML (or gz, or raw XML). No XSD. | Docs: https://openrocket.readthedocs.io/en/latest/dev_guide/file_specification.html and fileformat.txt. Schema 1.9 = OR 23.09; 1.10 = 24.12; 1.11 (26.xx, documented) adds embedded .rse, CSV lookup tables, gravity model and preview.png. Build the importer from the docs and sample files, not from OR’s Java |
OpenRocket .orc | parts DB XML | openrocket/openrocket-database is Apache-2.0. It can be bundled with notices (Loft did this; 3,445 parts) |
RockSim .rkt | XML | RockSim ships RockSim_Xml_Doc.txt. PWrInSpace/rkt_format (MIT) is a readable parser |
RASAero .CDX1 | XML, no public spec | Work from sample files only (clean room) |
RocketPy .rpy | JSON tied to Python class signatures | rocketpy/utilities.py, _encoders.py (MIT) |
Open Rocket Document (.ord) | dead since 2016 | GPL; reference the idea only |
Environment data
| source | notes |
|---|---|
| Open-Meteo | Data CC BY 4.0 (attribution required). Free non-commercial tier: <10k calls/day. Pressure-level winds (for example wind_speed_850hPa) come from the forecast and historical-forecast APIs; the ERA5 archive API has no pressure levels. There’s an elevation API. The server can be self-hosted |
| NOAA GFS / RAP | open data; AWS noaa-gfs-bdp-pds, NOMADS grib filter, UCAR THREDDS (RocketPy uses these) |
| ERA5 pressure levels | CC-BY; needs a CDS account (the maintainer’s call if we want live access); reading user-provided .nc files offline is the priority |
| U. Wyoming soundings | https://weather.uwyo.edu/wsgi/sounding?datetime=YYYY-MM-DD%20HH:00:00&id=<stn>&type=TEXT:CSV&src=FM35 (or src=BUFR); read by hpr_net::wyoming (how soundings are read). The site states no terms (checked 2026-09-30); only U.S. stations’ soundings, U.S. government works, are committed as fixtures. The legacy interface is retired |
| WMM2025 | public domain; valid to the end of 2029 (magnetic declination for headings) |
| Copernicus DEM GLO-30/90, NASADEM | free; COG on S3; for terrain and landing elevation |
| Gravity | Somigliana/WGS84 formula (what RocketPy uses); EGM2008 is optional later |
Rust crates
The crates surveyed for the workspace: which to use, which to avoid, and where none exists.
Rust crates checked September 16, 2026 (use as a starting point; re-check before adding)
- Mature and active:
- Math and numerics: glam 0.33, nalgebra 0.35, faer 0.24, rayon 1.12.
- Serialization and files: serde, schemars 1.2, quick-xml 0.42, roxmltree 0.21, zip 8.6, csv 1.4.
- Bindings: pyo3 0.29 + maturin 1.15, wasm-bindgen 0.2.128 + wasm-pack 0.15, uniffi 0.32.
- UI candidates: tauri 2.11, bevy 0.19, wgpu 30.
- Testing: proptest 1.11, insta 1.48, criterion 0.8.
- Networking and storage: reqwest 0.13, ureq 3.4, rusqlite 0.40.
- Geo and data: geo 0.33, world_magnetic_model, polars 0.55, arrow/parquet 60.
- ODE and optimization:
- diffsol 0.16 and ode_solvers 0.6: cross-checks only.
- argmin 0.11 and egobox 0.37.
cmaes0.2.2 has low activity.
- Weather files:
grib0.18 (GRIB2, pure Rust) decodes tof32, so HPR Sim reads GRIB2 with its own decoder. It reads netCDF classic with its own reader too, from Unidata’s spec (ERA5 from netCDF classic). A netCDF-4 (HDF5) file is converted, not read. - Avoid serde_yaml (deprecated), serde_yml (unmaintained), hdf5 (abandoned; use hdf5-metno if needed), nav-types (stale) and slint (GPL/commercial).
- No Rust crate exists for OpenRocket, ThrustCurve or model-rocket simulation, and ISA crates are tiny. Write USSA76 in-house.