Accuracy

This page gathers every check hpr-sim has passed so far, and every known gap, in words and numbers. Start with the bottom line: when both codes fly the same drag (same-drag), hpr’s whole flights match RocketPy’s in height, speed and time, and in where they land without wind. In wind they agree for a rocket that leaves the rail fast. For one that leaves it slowly they differ, in large part because hpr includes a sideways force on the body that RocketPy leaves out. With each code’s own drag (predicted), hpr’s heights differ from RocketPy’s by −7.280% to +10.302% (report), the larger gaps where its drag differs most from the example’s. Against the logs of seven real flights, hpr’s apogees miss by 6.04% on average, outside the 5% target, and by −8.90% to +10.40% one by one (real flights, report); four of the five misses past 5% are consistent with hpr’s drag, and one with the motor’s impulse. Four of those seven altimeters’ kinds are assumed, and none is calibrated. Against 55 more flights from a private collection, hpr’s apogees are +9.83% above the logs on average and miss by 13.96% (mean absolute), also outside the target; OpenRocket’s are +9.00% above (private collection, report).

What has been checked so far:

• each model on its own, against exact answers, its published source and, in places, RocketPy, an open-source flight simulator;
• the descent under a parachute, against RocketPy, for five rockets;
• whole flights from the pad to the ground, against RocketPy, for six rockets flown with one declared drag coefficient, one of them past Mach 1: heights, speeds and times agree, and so does the path, except for rockets that leave the rail slowly in a wind;
• the same flights with each code’s own drag, reported against a target rather than gated, the one past Mach 1 included;
• seven real flights, flown in the weather of their day and compared with their altitude logs: the apogee and the climb to it (real flights);
• 55 more real flights of a private collection, flown by hpr and OpenRocket in the weather of their day and compared with their logged apogees as aggregates (private collection, report);
• the normal force and center of pressure from Mach 0.6 to 4.63, against NASA’s wind-tunnel tests of a sounding rocket, and against RASAero II, another code (fixture);
• drag from Mach 0.6 to 4.63 against the same wind-tunnel tests, the forebody only (Aerodynamics);
• a boattail’s own drag and the base pressure behind it, from Mach 0.3 to 3.24, against measured boattails in six NACA and NASA reports (drag fixture);
• the roll that canted fins give, from Mach 1.5 to 4.63, against NASA’s Arcas Robin wind-tunnel tests, and the roll damping from Mach 1.5 to 3 against the Basic Finner’s, a standard finned test body (roll fixture);
• drag from Mach 0.1 to 2.0 against the curves labelled RASAero II in RocketPy’s example rockets (Aerodynamics), and from Mach 0.5 to 3.2 against a worked example in MIL-HDBK-762, the U.S. Army’s handbook for designing unguided rockets (Aerodynamics);
• the readings hpr analyze takes from a flight log, against an invented log whose every reading is known, each within the bound its rounding and filter allow (Flight-log readings).

Every number here links to the page or file it comes from. Checking a claim shows how to follow one back to its source and its test, and how the site keeps the two in step.

The census

In short: the census counts the numbers the validation reports hold hpr to, once each, and says what each group was compared with, how, how many flights it holds and how fast they flew. It is also a check: CI fails when any of those numbers moves, better or worse, until the change is accepted with a written reason. A code-to-code line measures how closely hpr agrees with another simulator, not which of the two is right; only the real flights are measurements.

Reading the table.

• Compared with names the reference and its version (census): RocketPy, “patched” where RocketPy 1.13.0 runs with two fixes from RocketPy’s own pull requests, which correct the point it takes the burn’s turning moments about (see whole flights against RocketPy), OpenRocket, or the teams’ altimeter logs.
• Kind says whether both programs flew the same inputs, each flew its own model, or hpr was compared with a measurement.
• Held to is what each report holds its numbers to (gate and target). A gate fails the run when a number falls outside it. A target is reported: missing it never fails the run. The OpenRocket comparisons have neither, only a line past which an apogee needs a written cause.
• Flights (speed) classes each flight by its largest Mach number: subsonic below 0.8, transonic from 0.8 to 1.2, supersonic above 1.2 (census). For the harness’s flights that is RocketPy’s largest Mach number, for OpenRocket’s flights OpenRocket’s, and for the logged flights hpr’s own, since a log has none. A configuration an OpenRocket report lists and hpr doesn’t fly yet is counted as “not flown”, with the report’s reason.

What it counts. Each of these is one row of the census (census):

• every metric of every case in the harness’s report, and each known gap;
• each real flight’s apogee and the RMS of its climb;
• each OpenRocket flight’s apogee, largest speed, stability margin, mass at launch and at rod clearance, and center of mass there, and each configuration not flown.

It leaves out the figures the reports give to explain a difference rather than to measure one, such as a real flight’s apogee on its team’s own drag.

The check. The census accepted last is committed, with a page of its own (census). cargo xtask validate --check, which CI runs on macOS, Windows and Linux, holds every row of the committed reports to it. To run it yourself, clone the repository and run cargo xtask validate --check. It fails when:

• a row’s difference moves by more than its slack, in either direction;
• a row’s standing changes, for instance a miss that starts meeting its target;
• a row comes or goes, for instance a flight hpr used to refuse and now flies;
• a group’s reference changes, such as a new version of OpenRocket.

A row’s slack is 0.1% of its scale, and for a harness row never less than the harness’s reproduction bound, 2e-6 in the metric’s own unit or 1e-7 of the value, whichever is larger. The scale is the row’s own tolerance where it has one, and otherwise the bar of its kind: 3% of its reference for a harness metric not scored, 5% for an OpenRocket apogee or largest speed, 1% for an OpenRocket mass, 0.5 calibres for a stability margin or center of mass, 5% for a logged apogee, and 3% of the apogee for a logged climb’s RMS, the bound the RocketPy comparisons hold a whole flight’s height RMS to (census). For example, a 3% tolerance on a 1000 m apogee allows 30 m, and the census lets the difference move by 0.03 m before it fails.

So the census holds a number to where it was, not to its target. A flight on each code’s own drag, whose 3% is only a target, is held that way too (census): hpr’s own aerodynamics can’t drift unseen inside the target.

Accepting a change. cargo xtask census --accept --reason "<why>" writes the new census and the table above. The reason and the list of what changed go into the census page, so a worse number can still merge, but only in writing, in the change that brings it. An improvement has to be accepted too; otherwise it could slip back later without anyone seeing.

How far to trust it. The census adds no evidence of its own: it is exactly as good as the reports it counts. CI flies the harness’s RocketPy comparisons again on every change. The OpenRocket and real-flight reports need files that CI doesn’t have, so CI holds their committed numbers, and a change to the code that would move them is caught only when someone runs them again and commits the result.

How to read the numbers

• Powers of ten. Very small and very large numbers are written the way programs print them. The number after the e says how many places the decimal point moves, to the left when it is negative. So 1e-12 is a millionth of a millionth, a 1 in the twelfth decimal place, and 1e6 is a million. Both appear in the two Frames rows of the results table below.
• Absolute differences carry a unit: they say how far apart two values are, in that unit. Geodesy’s round trips return heights within 2e-8 m, twenty billionths of a meter.
• Relative differences are marked relative: the difference as a fraction of the value it is compared with. Gravity within 2e-14 relative means within two parts in a hundred million million. A percentage is a relative difference counted in hundredths.
• Signs. A signed difference is hpr’s value less the one it is compared with, over that one. A plus means hpr’s value is the larger in size, a minus the smaller.

Four kinds of evidence

A model can be checked in four ways, from the weakest to the strongest evidence that it matches reality. They are set out in the project’s validation plan.

The first three check the code. Only the fourth checks the physics against the world. Seven flights have been compared so far, each as a whole: the apogee and the climb to it, not each model on its own (real flights). Besides them, two recovery models are checked against published drop tests (Recovery), and the normal force against NASA’s wind-tunnel tests of the Arcas Robin sounding rocket (Aerodynamics): measurements, but not flights.

Where each model stands

A tick means the model has been checked that way; a “no” means it hasn’t yet. In the descents only means RocketPy’s air density and wind were compared with hpr’s at just the 23 heights its parachute descents sample, as part of that comparison, and nowhere else (Recovery).

Results by model

The headline results, one check to a row. Each model page opens with In short, and its verification section lists every test and its tolerance, how far a result may be from its reference and still pass.

The descent under a parachute, against RocketPy

This is one of the two comparisons the validation harness runs; the other is whole flights. The harness is the program behind cargo xtask validate, which flies every validation case and writes the committed report.

Five of RocketPy’s example rockets are flown down in both codes, set up the same way:

• the same starting state near apogee, with the first parachute opening at once;
• the same drag areas, deployment triggers and wind;
• the random noise RocketPy can add to each parachute switched off, so its runs repeat exactly;
• RocketPy’s gravity formula, and its way of interpolating the wind (by its east and north components), in place of hpr’s own defaults, to compare like with like.

The committed validation report gives the six numbers below for each descent. All of them were scored and all are within tolerance; the largest difference is +2.865%.

Each metric must agree within 3% of RocketPy’s value, with no absolute floor (a fixed allowance, in meters or seconds, that would pass any smaller difference). Each case file argues why, for example NDRT’s. The metrics:

• descent_time_s: the time from the shared start to landing.
• impact_speed_m_s: the vertical speed at landing; the wind adds to the speed over the ground.
• mean_descent_rate_m_s: the start’s height over the descent time, so it repeats the descent time in another form.
• drift_m, drift_east_m and drift_north_m: how far the rocket lands from where the descent started, not from the pad, and that distance’s east and north parts. A drift to the south or west is negative.

A difference is hpr’s value less RocketPy’s, over RocketPy’s. So a positive one means hpr’s value is larger in size, in the same direction: NDRT drifts south, and hpr carries it further south.

Every result of the report, as hpr’s difference from RocketPy:

Each case is named after the RocketPy example it flies. Three names carry more:

• descent-calisto-tests-motor-at-minus-1.373 is Calisto as RocketPy’s own tests build it, with the motor at −1.373 m in RocketPy’s coordinates, where its getting-started notebook puts it at −1.255 m (notes on RocketPy’s example rockets).
• descent-ndrt-2020-nose-to-tail is the NDRT 2020 rocket, which RocketPy’s example measures from the nose toward the tail (notes on RocketPy’s example rockets).
• descent-prometheus-2022-generic-motor is Prometheus 2022, whose motor RocketPy describes with its generic-motor model, which treats the propellant as a solid cylinder (notes on RocketPy’s example rockets, Recovery).

The Valetudo case flies RocketPy’s own Valetudo example, not the flight on Getting started. From the shared start, 800 m above the ground, it falls in still air under the example’s one drogue, with RocketPy’s drag area of 0.4537 m², and lands at 17.627 m/s. Getting started flies the same airframe from the pad, with its own drogue, a main parachute and a 5 m/s wind (case file, Recovery).

In still air, Valetudo’s drift, 0.19 m, comes only from the Earth’s rotation (the Coriolis acceleration), and its north part is 19 µm. So a small difference there is a large fraction (Recovery).

The largest gap, NDRT’s north drift, most likely comes from added mass: RocketPy counts the air a canopy drags along, 15.9 kg for NDRT’s main against the rocket’s 20.8 kg, and hpr has no such term, so the two respond differently as the canopy opens (Recovery). That explanation fits the size of the gap, but no test has isolated it yet.

What this shows: the two codes agree on the physics of a descent. It says nothing about whether either matches a real parachute on a real day.

Whole flights against RocketPy

Six of RocketPy’s example rockets are flown from the pad to the ground in both codes: Calisto, Valetudo, NDRT 2020, Juno III, Bella Lui and Prometheus 2022. They are set up the same way (ADR-021, the whole-flight comparison):

• one declared drag coefficient, a constant 0.5 (case file), on the same reference area;
• the example’s launch rail, site, parachutes and motor, with the thrust curve flown as measured and no correction for the thinner air at the site, as RocketPy’s examples fly it;
• RocketPy’s gravity formula, standard atmosphere and frictionless rail, and a declared wind;
• the random noise RocketPy can add to each parachute switched off.

This is same-drag mode. It checks the equations of motion, the motor and the air, not the drag. hpr’s own drag is compared below.

In short: how high, how fast and how long agree, and so does where the rocket goes, except for rockets that leave the rail slowly in a wind. The heights, speeds, times and accelerations of six flights, one of them past Mach 1, and of three of them again in calm air, agree within the 3% of each case’s gate (case file); the largest difference is +1.783% (report). Here still air is an example flown with no wind (Valetudo’s), and calm air a windy case flown again with its wind switched off. The apogee and landing points agree too, within 2.2%, in every flight without wind and for Calisto in wind (ADR-026). Juno III and Bella Lui leave the rail slowly in the wind, at a steep angle to the airflow. There hpr’s body lift, which RocketPy leaves out, its later release from the rail and, for Juno III, its simpler fin model put their drifts 10.195% to 38.158% from RocketPy’s. Prometheus 2022’s differ by −7.292% and +4.505%, from body lift and the rail release. NDRT 2020’s apogee drift differs by −4.333%, mostly from the rail release. These seven drifts are reported, not scored. So the landing offset that M2.1 asks for is met except where the two codes’ models differ.

Each of fifteen numbers per flight must agree within 3% of RocketPy’s, with no absolute floor, or say in its case file why it is not scored. Each case file argues why, for example Juno III’s. Two more numbers compare the whole trace; they are explained after the tables.

The numbers are measured as RocketPy defines them, with one exception. Each code’s solver advances the flight in time steps and keeps the state at each step’s end. RocketPy takes each maximum (top speed, top Mach, top acceleration) only at those step ends. hpr also searches between its own step ends for the true peak, so that its number does not depend on where its solver happened to step. That search can only raise a maximum. Against hpr’s old step-end readings it raised them by at most 6.3e-5 of themselves (NDRT 2020’s top speed). How much RocketPy’s own step ends miss was not measured. Either way it is far inside the 3% gate (ADR-023, the decision that also sets how peaks are found in both modes).

The definitions:

• apogee_agl_m and apogee_time_s: the highest point, and when.
• flight_time_s: the time from ignition to landing.
• max_speed_m_s and max_mach: the top speed over the ground, and the top Mach number.
• rail_exit_speed_m_s and rail_exit_time_s: when the forward rail button reaches the top of the rail, and the speed then. hpr’s own rail-exit event waits for the last button, so the comparison finds RocketPy’s instant instead.
• burnout_altitude_agl_m and burnout_speed_m_s: at the end of the thrust curve.
• impact_speed_m_s: the vertical speed at landing.
• max_acceleration_power_on_m_s2: the largest acceleration while the motor burns.
• max_acceleration_m_s2 and max_acceleration_time_s: the largest over the whole flight, and when. For NDRT 2020 that is its main parachute opening, not a flight load (case file).
• apogee_drift_m and landing_drift_m: how far from the pad, along the ground, the apogee and the landing point are.

Speeds and accelerations are those of the rocket’s center of dry mass, the point RocketPy’s flight follows; hpr’s own output follows the center of mass of the loaded rocket. Heights are measured from where that point starts, as RocketPy’s are. A difference is hpr’s value less RocketPy’s, over RocketPy’s.

The validation report scores all but eleven of the numbers of the nine flights (the six, and Juno III, Calisto and Bella Lui again in calm air), and all of the scored ones are within tolerance. The eleven are measured and reported but not scored, each for a reason written in its case file (below). Every result of the report, as hpr’s difference from RocketPy:

The last two numbers compare the whole trace, not one point of it. The series height RMS (series_height_rms_m) is the root mean square of hpr’s height less RocketPy’s: square each difference, average the squares, and take the square root. The series speed RMS (series_speed_rms_m_s) is the same for speed. Both follow the center of mass without propellant, at RocketPy’s 120 series times, from ignition until hpr lands. Both codes’ clocks start at ignition on the rail, so no time shift is fitted: a fitted shift would hide a real difference in the burn or on the rail (case file). The center of mass without propellant is the point RocketPy’s series records. Every time counts the same, so the long descent weighs most; a difference during the burn shows in the burnout and top-speed numbers instead.

Exact agreement would give 0, so these two are given in meters and meters per second, not as a percentage. Each is held to 3% of RocketPy’s apogee (for height) or top speed (for speed). That is M2.1’s 3% for one number, applied to the whole trace (case file).

All nine flights pass, each well inside its bound. The largest height RMS is Prometheus 2022’s, 35.350931 m against its 110.3 m bound, about a third of it; its apogee is also the furthest off, +1.208%. Body lift accounts for that too: RocketPy flown with hpr’s body lift and rail release reaches 3723.8 m, against hpr’s 3723.6 (case file). Juno III’s is 14.550623 m against 78.4 m, about a fifth, and the other seven are at an eighth of theirs or less. The speed RMS runs from 0.022685 to 1.553509 m/s (report).

What the two codes still do differently, and what it moves:

• In wind: body lift, the rail release and Juno III’s fins. A rocket that leaves the rail slowly in a wind meets the airflow at a steep angle: Juno III leaves at 18 m/s in an 8.5 m/s wind, 26° off it (ADR-026). Three things differ there.

  • hpr’s normal force includes body lift, which grows with the square of that angle; RocketPy’s does not. Much of it acts ahead of the rocket’s center of mass, the nose’s above all, so it moves the center of pressure forward and weakens the moment that turns the rocket into the wind: hpr turns into it less.
  • hpr keeps the rocket guided until its last rail button leaves the rail; RocketPy frees it at the first.
  • Juno III’s example gives its fins an airfoil lift curve, which RocketPy uses and hpr cannot model. RocketPy’s fin slope is 7.6% steeper than hpr’s flat-plate one (ADR-026).

  Juno III’s apogee is 245.3 m from the pad in hpr and 396.6 m in RocketPy (−38.158%). Adding hpr’s choices to RocketPy one at a time moves RocketPy’s to 360.7 m with hpr’s rail release, 286.5 m with its body lift too, and 248.3 m with its fin slope as well (ADR-026, measured by wind_response.py). Every windy drift lands within 1.3% of hpr’s the same way. Bella Lui’s drifts are −10.195% and −21.686%, Prometheus 2022’s −7.292% and +4.505% (within 0.1% of hpr’s once RocketPy has its body lift and rail release; case file), and NDRT 2020’s apogee drift −4.333%, mostly its rail release. These seven are reported but not scored, as measured differences between the models. Every other drift is scored and passes: Calisto’s in wind, Valetudo’s in still air, NDRT 2020’s landing, and all six in calm air (report, case file).

• RocketPy’s own equations, corrected. RocketPy 1.13.0 takes the turning moments during the burn about the wrong point: as far in front of the rocket’s center of dry mass as the real center of mass is behind it. That makes its rockets too stable while the motor burns, so they turn into the wind too far. The fix is proposed in a pull request to RocketPy, still open, built on one that is merged but not yet released. RocketPy 1.13.0 as installed still has the error; the comparison applies both fixes (ADR-026). Without them, Juno III’s apogee drift was 582.4 m, and hpr’s drifts in wind were up to −60.8% short of RocketPy’s at apogee and +151% beyond it at landing (the question of issue #50).

• On the rail, hpr keeps the terms for the center of mass moving inside the body as the propellant burns, and RocketPy’s rail equation leaves them out. At a sharp ignition spike, with thrust and mass the same to five digits, hpr’s acceleration is 1.2 to 1.3 m/s² higher. That is Bella Lui’s +1.783%, whose peak is 7 ms after ignition (report, case file).

• Calisto’s two peaks. Calisto’s acceleration peaks twice, 0.9% apart: on the rail at 0.05 s and at 1.568 s. The same rail terms make hpr’s first peak the higher, so max_acceleration_time_s moves from one peak to the other (−96.811%); it is reported but not scored. The peak’s size is scored, but its +0.099% compares two instants; at 0.05 s hpr is 1.05% higher (report, case file).

• The main opening. RocketPy adds the air a canopy drags along (added mass), and hpr has none. So NDRT’s peak deceleration as its main opens is +83.059% in hpr, and Prometheus 2022’s +19.062%, reported but not scored. Their times are scored, since both codes put them where the main opens (report, case file).

Prometheus 2022 flies through Mach 1. RocketPy’s flight peaks at Mach 1.013 and hpr’s at 1.010371 (−0.235%). Until M1.8a hpr stopped any flight at Mach 1, and the case was a known gap; with the normal force carried past Mach 1 (Aerodynamics) it flies on its drag table to the ground. Its scored numbers agree within 1.208% (report, case file). This flight is a light test of the transonic normal force: no committed check measures its angle of attack there, but a local probe found it below 0.11 degrees from Mach 0.8 to 1.2 (case file).

What this shows: with the drag given, the two codes agree on how high, how fast and how long a rocket flies, and on where it goes, except for rockets that leave the rail slowly in a wind, where their models differ. M2.1’s landing offset is met everywhere else (ADR-026). Which code is nearer the truth for those is for real flights to say; the real flights so far compare heights, not drift. Nothing here says anything about hpr’s own drag, which the next section compares, or about a real flight. The comparison with OpenRocket is on its own page (hpr’s flights against OpenRocket’s), and the real flights are below.

Whole flights with each code’s own drag

The same six flights again, in predicted mode: hpr flies its own drag, from each design’s shape, where same-drag mode gives it the declared one; both modes use hpr’s own normal force, so only the drag differs. RocketPy flies the drag each of its examples ships, as RocketPy 1.13.0 flies the example: a drag curve for Calisto, Valetudo and Juno III, a function of Mach for Prometheus 2022 (case file), a constant for NDRT 2020 (0.44, case file) and Bella Lui (0.43, case file). Everything else is set up as in the same-drag flights above (ADR-023, the predicted-mode comparison).

In short: hpr’s heights are within 3% of RocketPy’s for Calisto (−0.609%), Bella Lui (+0.971%) and Juno III (+2.097%), well above for Valetudo (+10.113%) and NDRT 2020 (+10.302%), where its drag is well below the example’s, and below for Prometheus 2022 (−7.280%), where its drag is above the example’s through the coast (report). These are results, not a pass or fail. Neither code’s drag is the truth: each example’s drag came from RASAero, OpenRocket or its team’s own estimate. So each number is compared with the same 3% as the same-drag flights (M2.1, the validation milestone), but only as a target. A miss is reported and explained in its case file (Valetudo’s and NDRT 2020’s, for example), and does not fail the test suite. The report is committed, so any number that moves shows up in review.

Every predicted result of the report, as hpr’s difference from RocketPy:

The whole-trace numbers, in meters and meters per second, defined as for the same-drag flights above. Valetudo’s, NDRT 2020’s and Prometheus 2022’s height RMS are outside the target, and so is NDRT 2020’s speed RMS, for the same reason as their apogees: hpr’s own drag differs from those examples’ drag. Each bound is 3% of that case’s own RocketPy apogee or top speed, so it differs from the same-drag bound: Juno III’s 54.699661 m is inside its 83.9 m here (report).

Why the misses, largest first:

• Valetudo and NDRT 2020 fly high: the drag. hpr’s drag coefficient at Mach 0.3 is −47.0% from Valetudo’s table, a hand-edited table 1.44 times the drag of the OpenRocket export for the same rocket (Aerodynamics). For NDRT 2020 it is 0.318 against the example’s constant 0.44 (case file). These drags are compared at Mach 0.3 only. Flown on the same drag, the apogees agree with RocketPy’s to +0.112% and +0.064% (report). Less drag also means a later apogee, a longer descent and further to drift, which moves their times and drifts too.
• hpr’s drag here is for the design as transcribed. Where RocketPy’s examples say nothing, the designs’ fin thickness and edges and their surface finish are placeholders, so these results compare hpr’s drag for those designs, not for the rockets as built. For Valetudo, the rocket’s own OpenRocket finish and launch lugs take hpr’s drag coefficient from 0.5566 to 0.714 (Aerodynamics). So a miss here is not a gap for hpr to close toward the example’s drag.
• The drifts of Juno III and Bella Lui in wind: hpr’s body lift and rail release, and Juno III’s fin slope, as in same-drag mode (ADR-026).
• Prometheus 2022 flies low: the drag again, the other way. It passes Mach 1 on hpr’s own drag since M1.8b1, the drag through Mach 1, peaking at Mach 1.060 against RocketPy’s 1.048. Its coasting drag rises to about 0.49 at Mach 0.8, where the example’s falls to 0.30, so hpr peaks −7.280% low and sooner, and its drifts and times follow. Flown on the same drag the apogees agree to +1.208% (report, case file).
• NDRT 2020’s and Prometheus 2022’s peak deceleration at their main openings, +83.059% and +19.062%, are the added-mass difference explained above. Their times move +9.646% and −6.903% with the apogee (report, case file).

What this shows: with its own drag, hpr’s heights differ from RocketPy’s by −7.280% to +10.302% (report), and the larger gaps are the two drags differing, not the flight. It does not say which drag is right; the real flights below start to, one rocket at a time.

Real flights

This section covers M2.3b, RocketPy’s logged flights (ADR-082, the decision). In short: hpr flew seven rockets whose teams logged their flights, in the weather of the day. Read the way each log’s altimeter reads the air, hpr’s apogees miss the logs’ by 6.04% on average, outside the 5% target; with its sign the mean is −0.25%, so these seven show no bias high or low. Five miss by more than 5%. Each has an explanation checked against the report’s numbers: four are consistent with hpr’s drag, and one with the motor’s impulse (report). Four of the seven altimeters’ kinds are assumed, none is calibrated, and the designs’ fin edges are guesses, so read the numbers as those seven flights’, not as a bound on every rocket.

What is flown. RocketPy’s documentation flies more than a dozen rockets against their teams’ logs. hpr flies seven of them the way a user would: the design built from the example’s masses and shapes, hpr’s own aerodynamics, and the example’s own thrust file, read as RocketPy reads it, to the same total impulse. It flies from the example’s launch rail and site, in the weather of the launch hour from the example’s ERA5 file, a reanalysis of the atmosphere (ERA5 weather files). Genesis and Lince were added to the public designs for this.

What is left out, and why. The sample is the documented flights hpr can fly today:

Juno III flies its team’s own motor too, but its design was already public, and hpr flies the thrust file as it would any other: nothing of the motor is modeled (ADR-082).

The private designs add none: none of them is the rocket of a flight in the private collection of logs, so none has a log to compare with (ADR-083). A private flight collection added on 2026-10-04 pairs designs with their flights’ logs; its 55 compared flights are below.

Reading the logs. Every log here comes from a barometric altimeter, or is assumed to. Such an altimeter turns pressure into the standard atmosphere’s altitude. On a day warmer than the standard it reads less than the height climbed, 6.5% less on a day 20 K warmer (worked example), and more on a cold one. Two logs record their pressure, and their heights are that reading, to 0.195 m and 1.321 m (report). So hpr’s height is read the same way, from the ERA5 pressure at its center of mass. The table gives hpr’s apogee both ways. The reading moves it from −7.9% (Juno III, in June at Spaceport America) to +1.7% (NDRT 2020, in February) (report, ADR-082).

The kind of four altimeters is assumed rather than known; each row of the report gives its evidence. Reading all seven as heights would give a mean of 4.47%, but three logs are known to be barometric. Reading only the four assumed ones as heights gives 6.63%, so the target is missed either way. Read that way, Lince (+7.99%) would miss by more than 5% with no checked explanation, and Genesis would not (report, ADR-082).

Two logs also carry satellite (GNSS) heights, a geometric reference. Their barometric apogees are 0.943 and 0.935 of the satellite ones, and hpr’s conversion makes its own apogee 0.932 and 0.921 of its height (report). That is the same direction and nearly the same size, 1 to 2 points lower on both, on the side of both flights’ misses. Juno III’s log is cut up to 20 m below its apogee, which would put its own ratio as high as 0.941 (ADR-082).

Three logs are cut by hand just before a pressure transient at their apogee, where the reading jumps. Juno III’s rises 62 m in 0.3 s as it levels off, and the team’s reported apogee is that spike. At the cut its own velocity column still reads 17.5 m/s up, so its apogee may be 10 m to 20 m low (report).

What is compared.

• The apogee: the log’s highest reading, against hpr’s highest point read the same way. A plus means hpr flies higher.
• The climb: the root mean square (RMS) of hpr’s height less the log’s over the ascent, the report’s trace RMS. A log’s clock starts when its altimeter says so, not at ignition, so both clocks are set to zero where each first reaches 30 m. The RMS runs from there to the first of the two apogees (report). The descent is not compared: which parachute opened, and when, was the team’s.

The logs, thrust files and weather files are other people’s data, so they stay out of the repository. cargo xtask real-flights reads them from a pinned copy of RocketPy (fetched with cargo xtask refs fetch rocketpy) and commits only the numbers (report).

¹ Flown in the weather of the same day a year later, 2023, as RocketPy’s example flies it: no file of the flight’s day is available (report).

The mean absolute apogee error is 6.04%, against the 5% target of the validation plan (gate and target). The largest climb RMS is Juno III’s, 7.26% of its apogee (report). No target is set on the climb. The census counts each climb against a bar of 3% of its apogee, the bound the RocketPy comparisons hold a height RMS to; Bella Lui and Lince are within it (census).

The last column is a diagnostic, not a prediction. It flies each flight again with hpr’s drag replaced by the drag the example’s RocketPy notebook specifies: the team’s estimate, a table, a curve from RASAero II or a CFD analysis, or a constant the notebook gives no source for. When the error falls inside 5%, the miss is consistent with hpr’s drag. Neither drag is the truth, and a team may have tuned its drag to this very flight. On the teams’ drag the mean absolute error is 3.50% (report). Where a notebook reshapes its thrust file to a stated burn time and total impulse, as Juno III’s does, a second diagnostic flies the file as recorded.

The five flights past 5%. Each explanation is a claim the report checks against its own numbers. A change to hpr that makes one false fails cargo xtask real-flights --check, which runs only where the pinned RocketPy copy is. CI checks each claim against the committed numbers (ADR-082).

• NDRT 2020, +10.40%: consistent with hpr’s drag. On the team’s constant drag coefficient, 0.44, the apogee is +0.17% (report). hpr’s own drag is lower, as it was against RocketPy flying the same constant.
• Prometheus, −8.90%: consistent with hpr’s drag. On the team’s drag table the apogee is +0.45% (report). The barometric reading uses the temperatures of 24 June 2023, a year after the flight. Against the satellite heights, hpr’s conversion reads 1 to 2 points below the altimeter both here and on Juno III, which flew in its own day’s weather, so the wrong day’s share of the miss can’t be told apart.
• Juno III, −7.24%: consistent with the motor’s impulse. The notebook reshapes the team’s own motor curve to 8800 N s, 4.9% less than the file. On the file as recorded (9251.7 N s, its negative end read as zero) the apogee is +1.13%, while on the team’s drag it is −9.05% (report).
• Cavour, +5.63%: consistent with hpr’s drag. On the curves the team labels RASAero II the apogee is −2.29% (report). hpr’s drag is below those curves, 8.3% at Mach 0.3 with the motor off and 18.3% with it burning (Aerodynamics).
• Genesis, −5.85%: consistent with hpr’s drag. On the team’s curves the apogee is −0.08% (report).

These are consistent explanations, not proofs: the teams’ drags, and the impulse a notebook sets, are estimates too. Lince, inside the target on hpr’s drag, is −12.20% on its team’s; that is not investigated (report).

How far to trust it. The altimeters are not calibrated here: a barometer’s error, the filter of the four that are filtered, and the assumed kind of four of them all sit in the reference. Drift and landing are not compared, nor speeds. hpr’s designs of these rockets have placeholder fin edges and surface finish, which move its drag.

Real flights of the private collection

This covers M2.3c1, the logged apogees of a private collection (ADR-184, the decision). In short: 55 real flights, each a design paired with the log of the same flight, were flown by hpr and by OpenRocket in the weather of their day. Both over-predict: hpr’s apogees are +9.83% above the logs on average (mean absolute 13.96%), OpenRocket’s +9.00% (13.08%). hpr and OpenRocket agree with each other within 5% on 53 of the 55 (report). Neither meets the 5% target. hpr and OpenRocket agree with each other far better than with the logs, so the gap is not a difference between the two codes; what causes it is not shown here. The flights’ owners allow only aggregate statistics, so no flight is named here, and the logs’ readings were taken by hand from free text.

What is flown. The collection pairs each design as flown with its own flight’s log, the motor, date, site and the ERA5 weather of the day (ADR-151). Of its 89 best-documented (tier A) flights, 83 have an OpenRocket .ork design (report). hpr flies the whole ERA5 profile of the launch hour: temperature, pressure and wind at every level. OpenRocket 24.12 can take only a temperature and pressure at the pad, with the standard atmosphere above, so it gets those, and the same wind every 50 m. Both fly OpenRocket’s curve for the motor the file names, from the same rail, with no parachute opened, so each apogee is the climb’s. A third row flies hpr in OpenRocket’s air, which shows how much of the difference between the codes is the atmosphere.

What each log says. Every log here is a barometric altimeter’s. Such an altimeter turns pressure into the standard atmosphere’s altitude and subtracts the pad’s, so on a warm day it reads less than the height climbed: 6.5% less on a day 20 K warmer than the standard (worked example). The comparison turns each reading back into a height through the day’s ERA5 air. Across these flights the heights came out 1.0361 times the readings on average, from 0.9601 to 1.0777 times (report). Where a log’s highest value was an ejection charge’s pressure spike, the reading before the charge was taken; 24 of the 83 readings differ from the collection’s own figure by more than 0.5%, each with its reason recorded (ADR-184).

Each error is the simulated apogee less the logged one, over the logged one, in percent, so a positive error is a prediction above the log. The mean absolute error averages the errors without their signs. The last row is hpr’s apogee less OpenRocket’s, over OpenRocket’s, so a positive value means hpr flies higher. “Within 5%” and “within 10%” count the flights whose error is strictly smaller than that, either way (report).

Early deployments. On 19 of the 55, a parachute charge fired or the rocket separated before the highest reading, while it was still climbing (report). The readers’ notes put each at under 1.5 s before the peak and a few meters of climb, so the apogee barely moves (ADR-184). Without them, over 36 flights, hpr is +5.88% (mean absolute 11.94%) and OpenRocket +5.29% (11.24%). The two sets differ in which rockets they hold more than in what the early charges cost.

What is not flown, and why. Of the 83, hpr flies 61, and each cause of the rest has an open issue (report). Most are small reading problems in hpr’s .ork importer that OpenRocket accepts: a fin tab a few tens of microns past its root (6 flights, #357), a fin outline with a repeated point (3, #358), rail buttons spaced forward (1, #359), unread surface finishes (3, #360), two override flags read as one (1, #361), and a part in an off-axis inner tube (2, #181). Three fly motors whose curve OpenRocket’s database lacks (#362). In three more the collection itself falls short: two designs don’t hold the flown motor (#363) and one flight’s day has no weather file (#364). OpenRocket flies 79, missing the motor in one (#362).

How far to trust it. The readings were taken from free text and logs by hand, and checked for form, not cross-checked flight by flight by a second reader. Of the 83 flights, 26 have no known launch hour and fly at local noon (report); the altimeters are not calibrated; the designs are what their fliers drew, whose masses some fliers measured and some did not. Both codes over-predicting alike is common in hobby rocketry, where the real airframe carries rail buttons, paint and joints a design leaves out, but this comparison does not show which. The six tier-A flights in other formats wait for M3.4 to M3.6, and the climb traces for M2.3c2.

Sources. The flights are published by university rocketry teams, rocketry courses and hobbyists on GitHub, team websites and The Rocketry Forum. The weather is ERA5, generated using Copernicus Climate Change Service information 2026, and contains modified Copernicus Climate Change Service information 2026; neither the European Commission nor ECMWF is responsible for any use made of it. The report gives the full attribution and the ERA5 citations.

Known gaps

These are the largest known differences and missing pieces. Each model page’s In short lists the rest.

• hpr’s own drag in a whole flight. Its heights are +10.113% and +10.302% above RocketPy’s for Valetudo and NDRT 2020, where its drag is well below the examples’, and −7.280% below for Prometheus 2022, where it is above (report). Against real flights, four of the five apogees more than 5% from their logs are consistent with hpr’s drag: NDRT 2020 +10.40% and Cavour +5.63%, Prometheus −8.90% and Genesis −5.85% (real flights, real-flight report).
• Drag faster than sound reads high against NASA’s wind tunnel, above all with fins: with the fins on, +39.4% at Mach 1.5 to +154.0% at 4.63. The fins take a blunt leading edge’s formula, and nothing models a thin, sharp fin’s own wave drag. Niskanen’s cone, which ogives share, reads 45% to 105% above a measured cone through the rise near Mach 1 (Aerodynamics).
• A steep boattail’s drag reads high in a thick boundary layer: 16° boattails +26.4% to +54.2% from Mach 1.0 to 1.28, and the Arcas Robin’s 15° boattail puts its forebody, fins off, +13.5% to +24.1% high from Mach 1.5 and +20.3% to +50.8% from Mach 1.0 to 1.2. No cited correction exists in the sources used (issue #72; Aerodynamics).
• Drag past Mach 1.6 reads low against RASAero II’s Calisto, to −14.9% at Mach 2, with the fins and finish the Mach 0.3 check declares; other plausible fins bring most rows within 10%. Part of it is hpr’s body, which reads 6% to 10% low faster than sound against MIL-HDBK-762’s worked example as well (Aerodynamics).
• Roll: the forcing high near Mach 1.5, the damping low, nothing measured below Mach 1.5. The roll forcing from canted fins reads +47.8% at Mach 1.5 and +14.3% to +17.8% at 1.8 against NASA’s wind tunnel, where linear theory’s load climbs toward Mach 1 faster than the fins’ does; the roll damping reads 5.9% to 16.2% low against the Basic Finner’s. Nothing measured checks either below Mach 1.5 (Aerodynamics).
• A flared rocket’s supersonic normal force rests on one measured flare. A conical flare flies the shock-expansion method since M1.8e17, which moves the center of pressure of a test rocket with a 10° flare forward by 0.089 to 0.238 calibres against the model it had before, growing with Mach number. The one measurement beside it is NASA TN D-4865’s model 2, an 18.5° flare on a 2.75° cone, and it is not that rocket (Aerodynamics). No other flare angle has been checked, and the reading a flare steeper than its corner’s limit gets has been checked against nothing at all. A flare shallow enough to reduce its own element (a few thousandths of a degree on that rocket) is read by the older generalized method instead, which no measurement checks either, and which leaves a step where the corner’s pressure crosses its tangent cone’s (Aerodynamics). On a body with a short shoulder that crossing is not near-flat at all (0.7° to 4.6°) and the step reaches +4.3% of the body’s normal force and 0.19 calibres; its exact size for any conical flare is on that page.
• Some shapes fall back to slender-body theory faster than sound, and read more stable. Past Mach 1.2, a body with a step in its radius (#87), a flare behind a boattail too long for its wake (#120), a pointed tip steeper than 30° (#121) or a vertical tip steeper than its cap’s handover keeps slender-body theory for the whole body. The sizes are measured at Mach 3 and 4° on two test bodies: −8.65%, −27.5%, −7.7% and −7.0% in normal force, with the center of pressure 1.03, 0.29, 0.81 and 0.64 calibres aft, so the body reads more stable than it is. The flare’s is measured on a finless body, so its share is of a body’s normal force alone; the other three are on a straight rocket with four fins, so the two kinds of share don’t compare (Aerodynamics). No size inside the core band, below Mach 2.5, is pinned yet. They are first in M1.14d, supersonic accuracy, and in M1.14h above Mach 2.5.
• The normal force near and far past Mach 1. Against NASA’s wind tunnel, between Mach 0.8 and 1.2 hpr’s slope runs up to +27.1% high and its center of pressure up to 2.36 calibres off. From Mach 1.5 up its slope holds to within 9.4% (fixture, Aerodynamics) and its center of pressure to 0.53 calibres, which misses the half-calibre target on the long model at Mach 1.8 and 2.3, where the body alone reads 15% to 19% above the tunnel (Aerodynamics: body lift).
• Tube fins’ center of pressure is unmeasured, and OpenRocket’s differs. hpr’s is 0.42 to 3.0 calibres forward of OpenRocket 24.12’s on 14 probe designs up to Mach 0.5, and 1.07 on its Tube fin rocket, whose margin hpr gives as 0.79 calibres to OpenRocket’s 1.87. Neither code has been checked against a measured tube-fin rocket; hpr leaves out the body’s interference, which slender-body theory predicts (#234), and its tube-fin drag probably reads low (#228; tube fins). Check a tube-fin design in both programs and treat the smaller margin as the more cautious estimate, not a bound.
• Drag against the RASAero curves at Mach 0.3 is within 10% in four of seven cases, with the fins and surface finish guessed, because the curves don’t record them. Cavour power-on is −18.3%, cause open. Valetudo’s −47.0% and −50.4% are against a table 1.44 times the drag in the OpenRocket export for the same rocket (Aerodynamics).
• Six fins. The normal-force slope of Barrowman’s six-fin Recruiter is +2.87% above his printed value, and +3.42% on the fins alone, mostly because hpr uses a different six-fin rule (Aerodynamics).
• Tumbling is −10 to +19% off its source’s own drop tests, and is used far outside the fit behind it. That fit comes from small models falling at 5.0 to 6.6 m/s; if Valetudo came down tumbling, with nothing deployed, hpr would bring it down at 36 m/s. The default streamer model reads +58% fast on a pleated streamer (Recovery).
• Opening loads, the force on the rocket as a canopy opens, are no safe bound either way. With a filling time, hpr leaves out the brief rise of drag above its steady value while the canopy fills. Opening at once, it ignores how a light rocket slows while the canopy fills. The deployment speed can itself read high: a separated body falls with no drag until its device opens (Recovery).
• No added mass under a canopy, the likely cause of the 2.86% drift difference above (Recovery), and the cause of NDRT’s +83.059% and Prometheus 2022’s +19.062% peaks as their mains open in the whole flight (report, case file).
• Body lift in wind. A slow rocket leaves the rail at a steep angle to a crosswind, and there hpr’s body lift, which RocketPy leaves out, is the largest reason its drift differs: Juno III’s apogee drift is −38.158% against RocketPy’s (report). How much body lift a rocket body makes is itself uncertain. hpr takes it from Jorgensen’s crossflow term (Aerodynamics), whose factor is about 0.9 for these rockets at low speed. Flown in RocketPy with hpr’s rail release and fins, that puts Juno III’s apogee 248.3 m from the pad, against hpr’s own 245.3 m (case file). In the same runs, Galejs’s constant K, which hpr used before, gives 240.2 m at 1.0, 231.1 m at 1.1 and 194.1 m at 1.5, across its source’s range, and the drift would be 328.0 m with no body lift at all (ADR-026). Only real flights can say which is right, and the real flights so far compare heights, not drift.
• Airfoil fins. hpr’s fins use the flat-plate lift slope. It cannot model an airfoil lift curve such as the one Juno III’s example gives its fins, which makes RocketPy’s fin slope 7.6% steeper (ADR-026).
• Turbulence is an aircraft model, unvalidated for rockets, and no flight uses it yet (Turbulence).
• Wall and fin mass may follow different conventions from OpenRocket’s, which its documentation doesn’t state; six are measured so far (Mass properties). Measuring a nose cone’s wall thickness straight out from the axis, rather than square to its surface, changes the wall’s volume by 1.4% on a cone three calibres long (Shapes).