Print the guide
This page prints the whole guide, its 79 chapters one after another, each from a new sheet.
Printed to a PDF file, the guide can be read offline, at the launch site too.
The browser’s own Print command prints it as well: Ctrl+P, or Command+P on a Mac; on many phones, Share and then Print. On screen this page shows only the cover, because every chapter at once would load slowly and answer a tap slowly on a phone. Each chapter is also a page of its own, listed in the sidebar.
Start here
What FusionSpace HPR and its flight simulator, FusionSpace HPR · Sim, do today, and how to read this site.
FusionSpace HPR is a suite of open-source tools I’m building for hobby and high-power rockets. Its first product, FusionSpace HPR · Sim (HPR Sim for short), is a flight simulator. The first release is out, but HPR Sim isn’t ready to rely on yet. A flight analyzer, a competition kit and an app are planned (Decisions and the roadmap). This site explains what the simulator models, where each model comes from, and how well each one has been checked. I wrote it for a rocketeer who knows some physics and some code, but not this project.
What the simulator is
HPR Sim (called hpr-sim before release 0.1) simulates a rocket’s flight from the launch rail to landing. It’s a 6-DOF simulator: it follows all six degrees of freedom, the rocket’s position along three axes and its rotation about three. Meanwhile the motor burns, and the rocket’s mass, center of gravity and inertia (how hard it is to turn) change.
I made it a Rust library first, meant to be built into other programs, as
RocketPy is. RocketPy is an open-source rocket flight simulator, written in
Python and used as a Python library. HPR Sim has a Python package too (Python), and a
graphical app is planned. It reads OpenRocket .ork design files today.
The command-line tool, hpr, flies a .ork or a rocket’s JSON. It looks up and converts motor
files, searches vendors’ motor stock and prices, and re-runs the validation. It also reads an
altimeter’s flight log and fetches a launch day’s weather (The command line).
HPR Sim is the simulator’s guide. A tour of HPR Sim shows
it working on a small rocket and a public flight, and
Compared with other simulators sets it beside OpenRocket, RocketPy and
RASAero II.
I built it to be checked, too. Every model cites a published source, and tests pin every model. The simulator is compared with RocketPy, OpenRocket and the logs of real flights, and the results are committed to the repository.
For now it covers only commercial off-the-shelf solid rocket motors (COTS motors), the kind you buy from a manufacturer. That stays true until the first app.
Release 0.1.0 came out on October 8, 2026. Install its files as Install a release says, or build it from source. How a release is built says what a release holds and how each of its files is checked. The changelog says what 0.1.0 does, how far to trust it, and its known gaps. Among them are the open issues that make a number look safer than it is.
Releases come at product boundaries, and I don’t promise dates (Phase 8, releases). Plan says what each one holds and how likely each goal is:
- 0.1, the simulator: the library, the command line and the Python package, with Monte Carlo dispersion from the command line and Python. It waited on the logged flights’ apogees and named fixes (release 0.1). It shipped with its known limits listed. Among them is drag that reads high above Mach 0.8, so the apogee there reads low.
- 0.2, the flight analyzer: it reads the common altimeters’ logs on their own, with no design file. Then it compares a log with its simulation, which works today, and fits the rocket’s drag from it, which is still to come.
- 0.3, accuracy and diagnosis: the simulator measured against logged flights and improved, and a flight’s likely faults ranked from its log.
- 0.4, the competition kit: rules presets for Student Launch, IREC and others, and an optimizer. It adds the numbers a submission asks for, ejection-charge sizing, and RASAero and RocketPy files.
- 0.5, an app preview, on the desktop and in a web browser. Open a design or a log, fly it and replay it in 3D, with the simulated flight drawn as a “ghost” beside the real one.
- 1.0, the app, with its design editor.
After 1.0, new product lines come one at a time, in an order that may still change. First comes designing your own solid motors, then parachutes. Then a pad-day mode on your phone: the day’s forecast, the best launch hour, drift on the field and a flight card. Then flight computers and trackers. Hybrids and liquids come last (the second-pass plan).
What works today
These parts are built and tested. Each page gives its sources, and most say what they leave out.
The pages, the program’s messages and the library’s names use US spelling for the words the style guide checks. Some saved forms held a British-spelled key: a landing ellipse, a design-check finding, a laid-out rocket and a few more. They still read the old key but write the new one, so an older build may not read what this one saves. Design files never held one and are unchanged (US names).
Earth
Gravity follows WGS 84, the model of the Earth’s shape and gravity that GPS uses, and varies with latitude and height. The Earth’s rotation is in the flight too. HPR Sim works with launch-site coordinates and gives the distance and bearing between two places. A site’s elevation is looked up online or read from a GeoTIFF file. The detail is in Frames, Geodesy, Gravity and A launch site’s elevation.
Air
The air is the 1976 US Standard Atmosphere up to 86 km (282,152 ft), with temperature offsets and humidity. Or it’s a sounding, a measured or forecast profile of pressure, temperature and wind against height. A sounding can be a real day’s weather from an ERA5 file, an Open-Meteo forecast, a weather balloon, or NOAA’s GFS and RAP forecasts. The detail is in Atmosphere, ERA5 weather files, Launch-day weather, Weather-balloon soundings and NOAA forecasts: GFS and RAP.
Wind
Wind profiles can be constant, layered, power-law or logarithmic. Turbulence, random gusts, comes from a random-number generator started from a seed, a number you choose. The same seed gives exactly the same gusts every time on the same platform (operating system and processor). The detail is in Wind and Turbulence.
Motors
HPR Sim reads .eng and .rse thrust curves, and follows a motor’s
thrust, mass, center of gravity and inertia through the burn.
It carries a copy of ThrustCurve.org’s whole catalog of solid motors, taken October 28, 2026: 1,004
motors and 1,701 of their 1,706 files (the whole catalog
says why five are left out). By name it flies the 924 motors with a file that reads, offline, each
file checked against ThrustCurve.org’s figures, and the 412 that pass held to ThrustCurve.org’s own statistics code
(how). One it lacks is fetched from there by name and cached, so it flies offline after that
(motors on demand). hpr motors update caches the motors and
files ThrustCurve.org’s records show as added since the copy was taken
(newer motors gives its limits). Stock and prices come from
motor.fusionspace.co. The detail is in Solid motors,
.eng files, .rse files and
Motor stock and prices.
The rocket
A rocket is built from nose cones, body tubes, transitions (tapered sections between tubes of different diameters), fins and other parts, each with its material. HPR Sim works out the whole rocket’s mass properties and checks the design. Everyday fits warn, and only what can’t be built is refused (design checks that match reality). A packed part drawn wider than its bore warns. So does a part that fits a cone’s wide end but meets its wall where it narrows. The detail is in Design tree, Shapes and Mass properties.
Aerodynamics
HPR Sim finds the center of pressure, where the aerodynamic
force acts. Its distance behind the center of gravity is the
stability margin. HPR Sim also finds drag and the
normal force. That’s the sideways force when the rocket flies at an
angle to the airflow, its angle of attack. For small angles of attack, both
run from Mach 0 to 5. Both are checked against a wind tunnel from Mach
0.6 to 4.63, and the drag reads high at most speeds. A part’s own drag coefficient, stated in a
.ork file, flies as OpenRocket flies it
(A part’s stated drag coefficient). OpenRocket’s
Base drag hack example relies on that. With recovery in both programs, it flies within 4.52% of
OpenRocket’s apogee on two of its three motors. On the third it’s 7.80% high, which misses the 5%
bar (the table). The detail is in
Aerodynamics.
Flight
A flight runs from the launch rail through powered flight and the coast to apogee. It takes an adaptive time step and marks events such as burnout and apogee. The detail is in Rigid-body flight and Time integration. To size a difference from another program, a flight in the Rust library can also take that program’s thrust, and its mass and center of mass, as numbers against time in place of its own. Only a validation test uses it so far; no command takes it (Thrust and mass from another program).
A body with only a mass and an inertia, no design and no motor, flies eight of NASA’s check cases against the histories other flight codes published: a sphere dropped with and without drag, in still air and in wind, a sphere shot from sea level, and a tumbling brick with and without damping. HPR Sim differs from those codes by more than they differ from each other in six: by 19.51 mm (0.77 in) of altitude after 30 s, because its gravity model holds terms theirs drops; by up to 0.01633 deg/s of turn rate, because its rotational equations leave the Earth’s rotation out; and by up to 105.0 mm (4.1 in) of a dragged sphere’s position, against one code whose air is denser than the standard atmosphere. Each named difference, sized on its own, brings its difference inside the codes’ spread at each code’s largest difference; for that one code it does so without explaining the gap. The two shots come out inside the spread as flown (A free body against NASA’s check cases).
Recovery
Parachutes, streamers and tumbling bring a
rocket down, and HPR Sim gives the drift they carry it downwind. A rocket can
separate into bodies that each descend on their own. A .ork file’s
parachutes and streamers fly as OpenRocket flies them, in hpr sim too. HPR Sim’s landing speed is
within 0.021% of OpenRocket’s on 50 of its 53 example flights, and within 0.12% on all 53
(Recovery). hpr sim also flies a .ork’s powered
separations, one or several, though a dropped booster’s landing is rough
(powered separation in hpr sim). Staged flights and a
payload’s drop are below.
Design files
HPR Sim opens an OpenRocket .ork file, zipped, gzipped or plain XML, and reads the whole design.
That’s the stages, the parts on and inside them, the motor configurations, when parachutes open,
and the simulations OpenRocket stored. The airframe’s shape is cross-checked against
OpenRocket and against RocketSerializer, a second program that reads .ork files. The parts’
positions are checked against OpenRocket alone (.ork design files). Its mass and center of gravity are checked against
OpenRocket 24.12 (Mass properties). Pods and fins on a
nose cone are read, weighed and flown (Pods). So are parallel stages on a
rocket of one stage on the axis (Parallel stages). Three results on OpenRocket’s examples with these parts stand apart. A pod
example’s sustainer reads 37.93% below OpenRocket’s apogee; it turns over before apogee in both
programs. OpenRocket aborts its own flight of that example’s first configuration, so that one is
compared only up to the abort. And on two pod examples the stability margin reads about 0.07 calibers high, the flattering side. A part HPR Sim can’t shape honestly is left out with a
warning.
hpr sim flies 136 of the 170 motor configurations in the reference library and OpenRocket’s
examples as saved, 54 of OpenRocket’s 56 among them. It flies 25 more with
--accept-design-errors, and the other 9 are refused: 3 for a hybrid motor, 3 for a motor with
no curve, and 3 for other reasons
(How many configurations hpr sim flies).
A design writes back out as a .ork that reads back as the same design. It can also be kept as a
.hpr file in the HPR design format, which TypeScript and Python programs read
with generated types. OpenRocket’s parts catalog is built in: 16 .orc files with 3,449 makers’
parts. The builder makes a rocket of its parts
(Parts from a catalog, .orc parts catalogs).
The detail is in .ork design files.
Flight logs
hpr analyze, Python and the library read a flight log on its own, with no design file
(Reading a flight log). From any logger’s barometric altitude or
pressure, they take liftoff, apogee, the top speed, landing, the flight time and the descent under
each canopy. An accelerometer along the rocket’s axis adds the top acceleration and burnout.
Without one, burnout is a floor, the top speed’s time less its bound. Each
reading is within a bound held on the synthetic flights’ tuning set, or withheld with the reason
the log can’t support it (Flight-log readings). The synthetic flights’
census holds 2,200 simulated flights, each with its logger’s log and its known truth (Synthetic
flights). In the library, twelve readings also state a 90% interval:
liftoff, the apogee’s height and time, the top speed, landing, the flight time, the mean descent rate,
the top acceleration, burnout, each canopy’s rate and the main’s opening. Each passes a two-sided test
on synthetic flights held apart from the 2,000 its points were fitted on; the top speed only below
227.7 m/s (747 ft/s), on 286 readings on each set, where the height’s have 820 and 845. A floor, whose truth
may lie any amount above it, states a lower end in its place, tested on that test’s lower tail; a
clipped top’s on tops written near a clip imposed on the log. The misses of the
height, the top speed and the rates of descent fall on the coldest and warmest days, a warm day reading
low; the times lean by logger, and the top acceleration most. So a waiver goes by the apogee plus its
bound, a fin’s margin by the top speed plus its bound, and a load by the top acceleration plus its
bound, unless the reading is a floor, which has no upper figure (The
90% intervals; not yet checked on a real flight,
evidence row G34). The library’s smoother fuses a log’s barometer, accelerometer
and GNSS receiver into the height and vertical speed at every sample, each with a 90% interval. At
four moments of each synthetic flight with a barometer, the three sets’ intervals hold between 94.2%
and 99.4% of the truths, and two logger cells 88.7% and 89.2%, which the check allows. Those sets
were seen while its rules were set. It isn’t yet checked against a real flight’s (The
smoother).
hpr compare sets a log against a simulation of it: how far the logged height and speed lie from the
simulated, phase by phase, and each reading beside the simulation’s, read the same way
(Comparing a flight with its simulation). It reports the gap and fits nothing.
In the library, a least-squares fit goes further: it fits the drag, the impulse,
a constant wind and the mass to a log, each with a 90% interval that passes its test on the synthetic
flights (the wind’s on logs with a track), on sets seen while its model was chosen. No hpr command runs it yet, and no real flight has checked its intervals.
A Bayesian option gives a second kind of interval from the same fit; it doesn’t pass its test yet, so use the least-squares ones.
The library also predicts apogee from a log cut after burnout, on a barometer’s log whose climb stays under 227.7 m/s (747 ft/s). It is run on 7 of the 12 public flights, those compared along their climb. It predicts 2 of the 7, too few to say whether it beats the forward simulation: Bella Lui at +1.2% (forward +1.1%) and NDRT 2020 at −3.6% (forward +10.4%), both cut after the burn. The other 5 reach that speed before a cut (the report). In the private collection it predicts the 21 flights it can cut and fit, the slower ones: 36 others reach that speed before a cut. It reads each log up to the cut, which the forward simulation doesn’t. Its mean absolute apogee error is 3.17% against the forward simulation’s 9.37% on the 12 flights of the calibration half. On the 9 held out from later model choices (but not blind), it is 3.60% against 16.75%. Without the flights that deployed something before apogee, it is 3.00% against 10.12% on the calibration half’s 8 and 3.08% against 10.40% on the held-out half’s 3, too few for an interval (the errors). The scoreboard lists it as accuracy.from-boost.
The library reads each format into one record, every column kept on its own clock. The formats
come from PerfectFlite (.pf2 files), AltOS, Featherweight’s Raven and Blue Raven, Missile Works’ RRC3 and RTx,
and Eggtimer. Others come from AltimeterCloud, Entacore AIM, AerospaceNU, Silicdyne, the ARTS2,
the R-DAS, AltiMAX and MARSA. A phone app’s log, GPS tracks, a course’s Teensy logger and one
team’s radio telemetry packets are read too. So are zip archives and Excel workbooks. A table no reader knows is read by the
units its header states, or by a column mapping you write. Binary records are read by a layout
you write (Reading your own logger). That’s shown so far on one invented
flight’s files (evidence row G11, your own logger). Flight logs
covers each layout and how it was checked, and
the notes below give some readers’ checks.
Monte Carlo
A Monte Carlo run flies one rocket many times, with its mass, drag, motor, wind, rail and recovery
delays scattered. It’s seeded, so a run repeats exactly. It gives the spread of the apogee, the
landing or any number a flight reports, with failed flights counted. It runs from Rust or
hpr mc, staged flights included, and exports every flight as CSV. For a design
without staging, Python gets the flights as NumPy arrays. Python’s numbers are the library’s to the
bit on one platform, with both built in release mode (Monte Carlo dispersion).
Optimization
Three optimizers search for the design that makes a result best. CMA-ES tunes a design’s numbers, such as a ballast mass or a body length. It also picks from choices such as a motor or a catalog nose cone, within limits such as a minimum stability margin. NSGA-II weighs two goals against each other, such as apogee against stability. EGO, efficient global optimization, is for models so slow that only tens of evaluations can be afforded. Each is held to test functions whose answers are known, and CMA-ES and NSGA-II also to outside implementations. On a rocket, an answer is only as good as HPR Sim’s flight models. They run from Rust only, and competition rule files aren’t built yet (Optimization).
Python
The hpr package builds the rocket, motor, site and flight from Python, returns the recording as
NumPy arrays, and reads a design from a file. It runs Monte Carlo too, its flights as NumPy arrays.
Install it with pip install fusionspace-hpr from PyPI, or build it from source. It has no
staging. A design read from a file flies its stored parachutes with recovery=True, but most .ork
configurations are refused, as they don’t fly as written (Python).
Evidence
What backs each claim is a register of the gaps these pages state in what backs a file reader, a model or a check. Each row gives the kind of evidence behind a claim, the kind that would settle it, and the open issue waiting for a real sample. The build fails a gap stated in one of its listed phrases with no row, though a gap worded otherwise passes (the evidence register).
What doesn’t work yet
These are the gaps you’re most likely to meet. Each model page lists what its own model leaves out, and What backs each claim lists the gaps the pages state, with the issue that waits for each one’s evidence.
Speed and angle of attack
Drag near and past Mach 1 is lightly checked. Since the drag buildup through Mach 1 was built, a flight on HPR Sim’s own drag flies from Mach 0 to 5. One that reaches Mach 5, the top of the models, stops with an error.
Near and above the speed of sound, the transonic and supersonic speeds, the drag is Niskanen’s 2009 method. It’s semi-empirical: formulas fitted to measurements. Against NASA’s wind-tunnel tests of the Arcas Robin sounding rocket, from Mach 0.6 to 4.63, it reads high at most speeds. It’s highest with fins past Mach 1 (Aerodynamics). So for a rocket that goes past Mach 1, expect HPR Sim’s apogee to come out low rather than high. Its base drag, on the flat aft end, has been compared with three references. The first is MIL-HDBK-762’s worked example, a handbook calculation from Mach 0.5 to 3.2. The second is Love’s correlation of measured bases. The base drag reads high from Mach 0.8 to 1.2 against the first, and low from Mach 1.5 against the second. Between Mach 1.2 and 1.5 the sign is unmeasured (issue 68, the base drag’s error; the handbook’s calculation). Below Mach 0.8 the third, one long-boattailed NACA missile model’s measured flight, checks it coasting and with the motor burning: coasting it reads high, and under power the rule as flown reads low (the base under power).
It’s also been compared with RASAero II’s drag near Mach 1, and that comparison isn’t within the 10% target everywhere. Accuracy has the cases and errors. A drag table from another tool can replace HPR Sim’s own drag (Aerodynamics).
The normal force still has gaps near Mach 1 and on some supersonic bodies. The current body and Arcas Robin comparisons, with their measured error ranges, are in Aerodynamics and Accuracy.
HPR Sim’s models are for small angles of attack: its accuracy work assumes 15° or less (the operating envelope). Nothing models stall, the loss of lift at a large angle of attack, yet a flight uses the same models at every angle. So results near rail exit in a strong crosswind, and near apogee, are the least trustworthy.
Staging, two-stage rockets, clusters and air starts
Staging is new, and it’s checked against OpenRocket on OpenRocket’s own examples. Each motor lights at its own time, an air start included. A sustainer flies on after dropping its booster, which lands on its own (Staging). Tests check the bookkeeping. OpenRocket’s two-stage, three-stage, cluster and air-start examples make 15 flights in all. Each is within 5% of OpenRocket’s apogee and largest speed. In OpenRocket’s flights of five of them, three of the cluster’s and two of the three-stage example’s, the parachute opened before apogee. Those five apogees are compared with OpenRocket’s flight with no parachute (a two-stage and a cluster design against OpenRocket; several separations; results).
A .ork file’s ignition settings and every powered separation are read, from the tail forward
(several separations). A powered separation has a time known
before the flight. At that time a motor ahead of it is still burning or yet to light, and none
behind it is. A separation at its own stage’s first burnout may drop that stage’s other motors
while they still burn, if they lit strictly before the split. OpenRocket does the same
(a stage’s first burnout).
The ignitions come with the rocket. Your program passes the separation to the flight, with a
recovery device on each part, since HPR Sim refuses the flight without them. hpr sim does the
same for you (Separation). The example
ork_two_stage.rs
does both. A lone separation with nothing ahead of it left to burn, such as a payload’s, is read
too. hpr sim flies it when the payload’s own device opens at the split
(a payload’s split). One beside another separation, or at or
after apogee beside another, isn’t flown
(which configurations fly).
A cluster, several motors burning side by side, flies, whether they share
one mount of several tubes or each has its own. HPR Sim adds up their thrust and mass, and a motor
off the rocket’s center line adds a turning moment. You can set a motor that fails to light, and
the rocket then turns as a hand calculation says (Clusters). A
.ork file’s cluster flies with a motor in every tube.
A rocket can separate into parts for recovery once the aft part’s motors have burnt out.
Effects left out
These are left out of a flight, or approximated:
- tip-off, the rocket pitching as it leaves the rail. Its cost is measured with RocketPy’s. The Rust library flies a tip-off phase when asked. It is held to RocketPy’s in still air, and not yet in a crosswind on HPR Sim’s own normal force. On the real flights it moves each apogee by under 1%. It moves each set’s mean error by a tenth of a point or less (what it moves). Flying it by default is planned;
- thrust misalignment, a motor pushing slightly off the rocket’s axis;
- turbulence: the model exists, but a flight doesn’t use it. No milestone plans these last two yet, though turbulence has an open issue of its own, #39;
- the shock load when a parachute opens, and the canopy’s overshoot of its steady drag (Recovery);
- the internal momentum of the burning propellant, counted twice, as RocketPy counts it. A thrust curve measured on a test stand already includes its effect, and the equations of motion add it again. On Valetudo, the rocket that Getting started flies, it adds 21 N to the push at liftoff. It changes the burnout speed by at most 0.05 m/s (0.2 ft/s) (Rigid-body flight).
Outputs and ways to use it
-
Output files. Exporting a flight writes a recording as CSV, JSON or Parquet (Parquet recordings), and the flight path with its landings as GeoJSON or KML for a map. Flight metrics gives a flight’s peaks and its stability margin from the rail exit to apogee. For a rocket with a fin set of one or two fins, that’s the weakest direction’s margin (issue 329, one- and two-fin sets). It also gives the optimum ejection delay and the landing’s latitude and longitude. Fin flutter gives the fins’ flutter speed and margin.
-
Where an export comes from. A CSV’s header gives each column’s unit in brackets (
time [s]).hpr sim’s JSON recording carries the motor catalog’s as-of date and how far to trust the numbers. So does the small filehpr simandhpr mcwrite beside a CSV (provenance on the exports). So do GeoJSON, KML, Parquet and the--plotfigure (provenance on every export). A catalog motor thathpr convertwrites says the catalog’s date. A weather profile thathpr weather --outputsaves says whether it’s measured, a forecast or a reanalysis, and how far to trust it (provenance on the other files). -
It reads what you type, and says what to do when it can’t. It reads numbers as you’d write them by hand:
--elevation 1,280is 1,280 m (4,199 ft). A comma it can’t read as a thousands separator, such as3,9, is asked about. A refused option is named with its value, its unit and an example. For a file that isn’t there, it names the closest file in the same folder (typing numbers; errors and typed numbers). Every refusal ends with ahelp:line that says what to do. A fetch that waits on the network says on the terminal what it’s waiting for (next steps and waits). -
hpr simflies a design and plots its flight. It flies a.orkfile or an HPR design file and exports its recording (The command line). With--plotit draws the flight’s altitude, speed and acceleration against time, as an SVG in the FusionSpace chart style. Events are marked and listed in a table, and a title block closes it. The panels’ heights are chosen so their slopes run near 45° (banked). The numbers it draws go in a CSV beside it (Plotting the flight; plots; their style; balloons, banking, title block and data). -
hpr simreads by name. Its readout leads with the static margin, and the center of gravity and center of pressure it came from. Then come the apogee, the rail exit speed, the ejection delay and the descent speed under open parachutes. Each height and speed is in SI, with feet or feet per second in parentheses (units). It ends with how far to trust it, from 60 logged flights (how far to trust a result). It calls configurations and parts by name, such as[C6-5]for a configuration the file leaves unnamed (readable output). It flies a.orkfile’s parachutes and streamers, and its powered separations, one or several (powered separation inhpr sim; several separations). It also flies a payload dropped with nothing left to burn, when its own parachute opens at the split (a payload’s split). A rocket’s.jsoncarries no parachute. A Rust program flies separations and parachutes. Getting started flies a first rocket, and The builder builds and flies one of your own in a few calls. A Python program flies the parachutes of a rocket it builds part by part, or a design file’s withrecovery=True, but no staging (Python). -
Not every
.orkfile’s motors fly offline. HPR Sim reads a.orkfile (.orkdesign files), but a file rarely carries its motors’ curves. On the file’s curves and the bundled catalog, 154 of the 170 motor configurations of the reference library and OpenRocket’s examples fly, beforehpr sim’s design checks (the counts).hpr simlooks for a missing curve on ThrustCurve.org and keeps what it finds. After that one fetch, 136 of the 170 fly as saved, 25 more with--accept-design-errors, and 9 are refused (how many fly). Its parachutes and streamers fly as OpenRocket flies them (Recovery).hpr sim --motorflies one with a motor you give (The command line). -
Monte Carlo runs give the apogee’s spread and landing ellipses, from Rust, the command line or Python. A Monte Carlo run flies a rocket many times with its mass, drag, motor, wind and rail scattered. It’s seeded and reproducible (Monte Carlo dispersion), and it draws the ellipse its landings fall in (Landing ellipses).
hpr mcruns one on any designhpr simflies, and exports every flight as CSV. For a design without staging,hpr.MonteCarloreturns the same flights to Python as NumPy arrays, but not the ellipses (Python). Morris screening and Sobol’ indices rank which inputs matter most (Sensitivity analysis). CMA-ES finds the values of a design’s numbers that hit a target. For example, it finds the ballast and body length for a 3,048 m (10,000 ft) apogee with a chosen margin. CMA-ES also chooses a motor and a nose cone within a competition’s limits, and NSGA-II weighs apogee against stability (Optimization). Their answers are only as good as HPR Sim’s flight models. Competition rule files aren’t built yet. There’s no app yet: it’s on the roadmap. -
A damaged file gets an error, or a value from what was left, on the damage the tests try. Each reader is tried on cut, changed and arbitrary bytes, for a crash or a hang (Damaged files).
-
The flight-log analyzer gives readings within bounds; twelve state intervals, and the smoother gives a health card.
hpr analyzeand the Python package read a flight log on its own, with no design file and no simulation. They use its format’s reader, or the column mapping or record layout you write for your own logger (Reading your own logger). They give liftoff, apogee, the top speed, landing, the flight time and the descent under each canopy. From an accelerometer along the rocket’s axis they also give the top acceleration and burnout. Burnout and each leg of the descent came with the rest of the readings. Each reading comes within a stated bound, or is withheld with the reason the log can’t support it (Reading a flight log). A GPS track gives no reading, and a board’s three axes give no top acceleration. Two logs of one flight, or one logger to a stage, go on one timeline by a shared liftoff and read side by side, never averaged (two logs of one flight).--ghostwrites the logs’ paths for a viewer, as JSON, CZML or glTF (ghost files). Likehpr weatherandhpr motors show, it ends with how far to trust its figures (units and trust notes on every readout).Here are notes on some of the readers. Most say what the reader was checked against:
- AltOS’s raw downloads, the
.eepromfiles of the board’s own log, match AltosUI’s exports on every value converted to SI, in all 9 samples that have one. One export’s acceleration, zeroed at +1 g, is counted apart (AltOS raw downloads, the layout). - The ARTS2’s
.odfis in units from its own calibration, and holds the same records as its raw CSV. It agrees with DataAnalyzer’s export in all 3 samples: the acceleration within half a count, the barometric altitude in order only (ARTS2 raw data, the layout). - The words of Missile Works’ RTx GPS tracker’s
.rtxfile are decoded from the files. They agree with mDACS’s CSV and text exports on every fix but the last, which the exports leave out, in all 5 samples. Every field agrees in 4, and positions and altitudes in the fifth (Missile Works’ RTx, the layout). - A table from a logger no other reader knows is read only as far as its header states its units, each unit held to the column’s name and values. Of the 31 sample tables, 224 columns are read in a stated unit, and the rest kept as written (tables read by their headers, the layout).
- GPX 1.0 and 1.1 files: each value of three invented files equals an independent reader’s (GPX tracks, the layout, the register’s row on GPX).
- A zip archive of a flight’s files is unpacked to read each one (archives and two readers’ variants).
- An Excel workbook’s sheets are each read as a file. Every cell of the 16 sample workbooks agrees with an independent reader’s (Excel workbooks, the layout).
- Eggtimer and RRC3 exports saved by a European locale’s spreadsheet are read, with decimal commas tested on invented files. In the survey, six team tables are read by the column mapping RocketPy states for them (mappings a publisher states, the mappings).
- A team flight computer’s binary records, from a raw file or a console capture’s base64, are read by a layout the caller states. Every field of the 5 sample files matches the team’s own decoded table (binary records by a stated layout, the layout).
- A Blue Raven’s USB download keeps only the records whose CRC checks, each held to its stated length, and reads the fields its manual lists. Every value of the 2 sample files matches the survey’s own decoding (the Blue Raven’s USB download, the layout).
- Every value of the 8 sample files from a course’s Teensy data logger matches the survey’s own decoding (a course’s Teensy data logger, the layout). Each unit no line states is held to the flight’s physics: the barometer’s altitude to its pressure by the BMP180’s formula, 1 g at rest, the time to apogee.
- A team’s radio telemetry packets are read as its flight computer logged them, as a receiver heard them, and inside an RTF document. Every packet a receiver or an export holds that the onboard log also holds matches the log’s, field for field (radio packets, the layout).
- A Raven FIP export pasted into a workbook with its header missing is read under a stated
header (workbooks with a reading beside,
the layouts). The two sample
sheets match the
.FIPaof the same flight, sample by sample. Every cell of the sample AltiMAX.xlsexport is checked by an outside reader, and each of its heights follows its pressure by the standard atmosphere’s formula. - A MARSA altimeter’s download is read in feet and g. Its units are held to an AltOS board’s in the same flight, the apogee 0.981 and 0.986 times its. AltOS’s radio telemetry decoded to a table is read by its header, and a table cut from an AltOS export by AltOS’s state numbers. An AltOS export a spreadsheet re-saved keeps each formula as text (altimeters’ other text, the layouts).
- A table whose header states too little, or that has none, is read by a column mapping. The sample tables’ mappings each hold every unit to a physical check (tables by mapping, the layout).
The layouts read covers each format. The first readers came with the record, a survey and three families and RRC3, Eggtimer and Blue Raven CSV. GPS tracks, text loggers and club layouts followed. Every sample log in a layout HPR Sim knows is read. The formats with no sample, such as CATS’s, are listed as needing samples (the register’s row on these formats).
hpr comparesets a log against a simulation of it, and fitting drag and impulse to the log is planned (a flight against its simulation). - AltOS’s raw downloads, the
Accuracy so far
Accuracy gathers every result so far, gaps included. The accuracy work aims first at the flights most rocketeers make, the core band: up to Mach 2.5. It assumes angles of attack of 15° or less. The wider envelope runs to Mach 3.5, at any angle (the operating envelope). So far, whole flights are checked mostly below about Mach 1.15.
Faster flights still fly, and they say so. A flight carries a flag when it goes beyond the validated range, at a high angle of attack, outside the core band or beyond the envelope (the envelope flags). A flight that meets a known error in HPR Sim’s drag, its stability or the flight’s path warns by its issue number (the lists). The warnings came in steps: drag, stability, four more and a flight unstable under power, and the flight’s path. A flight whose static margin falls below zero while a motor burns says its apogee isn’t a prediction. The results so far:
-
Whole flights match RocketPy’s in height, speed and time when both codes fly the same drag. Six of RocketPy’s example rockets agree within 3% on apogee, speeds, burnout and flight time (the whole-flight cases). So does where they go, except for rockets that leave the rail slowly in a wind. There, three things move HPR Sim’s drift: its body lift, which RocketPy leaves out, its later release from the rail, and for one rocket its simpler fin model. They put the apogee’s drift −4.333% to −38.158% from RocketPy’s, and the landing’s −21.686% to +36.678% (report; Accuracy). With HPR Sim’s own drag, against RocketPy flying the drag its examples ship, HPR Sim’s heights differ from RocketPy’s by −7.280% to +10.302% (report). The larger gaps are where the two drags differ most. HPR Sim’s drag is well below the example’s for two rockets. It’s above it at high speed for Prometheus 2022, which flies through Mach 1 (Accuracy).
-
Against 12 public real flights, HPR Sim’s apogees miss by 8.88% on average, outside the 5% target (the register’s row on these misses). One by one they miss by −29.16% to +10.40%. HPR Sim’s height is read the way each log’s barometric altimeter reads the air. Seven of the 12 altimeters are assumed to be barometric. Four are from the seven flights compared first (the register’s row on those altimeters), and three from EuRoC 2022 (the register’s row on those three). Drift and speed aren’t compared yet (real flights, report).
-
Against 60 more real flights, from a private collection, HPR Sim and OpenRocket both over-predict the logged apogee. HPR Sim does by 8.01% on average and OpenRocket by 6.72%, and they agree with each other within 5% on 59 of them. Neither meets the 5% target. Each flight was rechecked against the collection’s own catalog of its sources (the collection rechecked). On the 68 flights both fly, the gap between the two codes is split by cause, and drag is the largest part on 61 (the split). By Mach number, the largest share of that drag difference, in mean absolute value, is below Mach 0.8 (the bands). The largest term in that share is the base drag, four fifths of it while the motor burns (by term). On a NACA missile model’s measured flight below Mach 0.8, HPR Sim’s rule leaves no base drag under power, too little. Coasting, behind its long boattail, HPR Sim read the base 5 to 8 times the measured; it now keeps of the flat-base value behind a boattail, on Stoney’s rule, and reads 3.0 to 5.1 times (the base under power). On the 5 that only just pass Mach 1 (1.06 on average) with a tangent-ogive nose, flying OpenRocket’s nose pressure drag in HPR Sim lifts its apogee by 1.28% of OpenRocket’s on average. That sizes a difference between the codes, not which is right (the nose’s line). The flights’ owners allow only aggregate numbers (private collection, report).
-
The scoreboard sets HPR Sim beside OpenRocket and RocketPy, axis by axis, each number read from these reports. It opens with how many of its cells are measured. Where HPR Sim and another tool both are, it says which is ahead, and each cell nothing measures yet names the milestone that will. CI fails when one of HPR Sim’s numbers there gets worse, unless a decision record accepts it (the scoreboard’s milestone; Accuracy; scoreboard).
-
The scoreboard counts the steps to a first answer: opening a design’s
.orkfile, flying it and getting its landing spread. HPR Sim takes 2 commands or 10 lines of Python, from files a test runs. Neither OpenRocket nor RocketPy does all three from the.orkfile. OpenRocket 24.12 opens and flies one in 7 clicks but has no Monte Carlo, and RocketPy reads no.orkfile (steps to a first answer; Accuracy). -
The descent under a parachute matches RocketPy’s. The comparison flies the descents of five of RocketPy’s example rockets in both codes:
- Each starts from the same state near apogee, with the first parachute opening at once.
- Both codes get the same drag areas and wind.
- RocketPy’s parachutes can add random noise, which would make each run differ; it’s switched off.
- HPR Sim uses RocketPy’s formula for gravity. It also uses RocketPy’s way of interpolating the wind, that is, of working out the wind between the heights it’s given.
Six numbers are compared for each rocket. They’re the descent time, the mean descent rate, the descent rate at landing, and the drift in total, to the east and to the north. All 30 agree with RocketPy’s within 3%; the largest difference is +2.865%. That shows the two codes agree on the descent physics, not that either matches a real flight. The committed validation report has every number, and Recovery explains the comparison.
-
Each model is tested on its own: against exact answers, and against its source’s tables or worked examples where it prints them. Several parts are also tested against RocketPy. Each test states its tolerance. The largest known gaps:
- The drag was checked at Mach 0.3 against other programs’ curves (below), and from Mach 0.6 to 4.63 against NASA’s Arcas Robin wind tunnel. There it reads high at most speeds, most of all with fins past Mach 1. 2 of 44 measurements are within the 10% target set before measuring (Aerodynamics). The normal force and center of pressure were checked at Mach 0 against Barrowman’s worked examples. From Mach 0.6 to 4.63, against the same wind tunnel, they miss at Mach 0.8, 0.9, 0.95 and 1.2 on the short model, and at 0.9, 1.0, 1.2, 1.8 and 2.3 on the long one. Where the center of pressure misses up to Mach 1.2, it reads 0.67 to 2.36 calibers aft of the tunnel’s, the flattering side for the margin; the short model’s miss at 1.2 is on lift alone. At 1.8 and 2.3 the long model’s center of pressure reads 0.52 to 0.53 calibers forward, the cautious side. From Mach 2.96 up, both are within target. Aerodynamics reports the current comparison and its measured range.
- The drag was compared with drag curves that come with RocketPy’s example rockets, labeled as RASAero II’s (another rocket aerodynamics program). The curves don’t record the fins’ edges or the surface finish, so HPR Sim’s copies of the designs follow a declared guess. HPR Sim is within 10% in two of the seven cases.
- HPR Sim’s drag is 18% low for Cavour, another of RocketPy’s examples, while its motor burns (power-on drag). The cause isn’t known yet.
- HPR Sim’s drag is 47% to 50% below Valetudo’s example curve. Valetudo is the rocket that Getting started flies. Its references disagree with each other, though. At Mach 0.3 the example curve gives a drag coefficient of 1.05, 1.44 times the 0.728 in an OpenRocket file of the same rocket. Given that file’s own surface finish and launch lugs, HPR Sim gives 0.714, 1.9% under the file’s 0.728 (Aerodynamics).
- The Recruiter is a six-fin model rocket that J. S. Barrowman works through in his 1970 report Centuri TIR-33. HPR Sim follows his method for the normal force. For the Recruiter, HPR Sim’s normal-force slope, how fast the sideways force grows with angle of attack, is 2.87% above his printed value. On the fins alone it’s 3.42% above. Most of that comes from a different rule for six fins (Aerodynamics).
- Tumbling drag is −10 to +19% off its source’s own drop tests. A separated body falls with no drag until its parachute opens. So the parachute can open at a higher speed than it would for real (Recovery).
-
You can check it yourself. Getting started shows how. Run a program that shows how much the drag moves the apogee, or trace any number with Checking a claim. Or compare HPR Sim’s apogee by hand with your own altimeter’s or another simulator’s.
Reading these pages
New here? Getting started builds HPR Sim and flies a first rocket. How a flight is simulated follows a flight from the pad to the ground, linking the page for each model on the way.
Have an OpenRocket design? Three how-to guides take it through hpr on the command line:
Fly your .ork, Pick a motor and
Check stability for a certification flight.
Want the physics behind a number? Rocketry explained holds guides that explain it, each figure drawn from HPR Sim’s own results:
- Trusting a simulation: how far a simulated apogee has been from real flights, and which way it errs.
- Stability in flight: how the center of pressure moves with speed and angle, against a wind tunnel.
- When fins flutter: what a flutter speed means, and which errors flatter it.
- Drag through the speed of sound: how drag climbs near Mach 1, what the finish adds, and which way HPR Sim’s drag errs against a wind tunnel.
Each model page opens with In short: what it models, its sources, how well it is validated and what it leaves out. Below that, it names the code that implements the model, the sources it follows and the tests that pin it.
Sources are cited by a short key in square brackets, such as [N09] for Niskanen’s 2009 thesis on model rocket simulation. The full reference is near the top of the page.
Equations are typeset as a textbook sets them, here and on GitHub. The code’s documentation writes them in plain text. For example, once its drag balances its weight, a rocket under a parachute falls at the steady speed
where is its mass, gravity, the air’s density and the parachute’s drag area (Recovery).
Terms are defined in the Glossary. Checking a claim shows how to trace any number to its source, its test and its validation.
The code itself is documented in the API reference, which Rust’s documentation tool generates from the source. It lists every public type and function. Each crate’s front page links back to the pages here that explain its models.
Three kinds of label link to the project’s records on GitHub, which Decisions and the roadmap introduces:
- A milestone, such as M1.8, is a step of the roadmap, the ordered plan of work.
- A decision record, such as ADR-011, explains a significant choice and the alternatives that were considered. All of them are in the decision log.
- A Loft lesson, such as Loft lesson L15, is a mistake found in Loft, the project that came before HPR Sim. A test here guards against it, or will once its milestone ships. They’re listed in Lessons from Loft.
Every page’s source is a Markdown file in the repository’s
docs/ folder. The pencil icon
at the top of a page opens its source in GitHub’s editor, where you can propose a fix.
Under each page’s title, one sentence in larger gray type says what the page covers. Each of its two to six sections starts under a thick rule in the text’s color.
The header and the theme switch
The theme switch, Auto, Light, Dark and Field, sits in the header before the print and edit buttons on a window 960 px wide or wider. On a narrower one it’s at the top of the table of contents, and on a phone it’s behind the menu button. Auto follows your system’s light or dark setting. Field is the design system’s theme for reading outdoors, at the pad. It differs from Light in three ways: a white page instead of a gray one, darker secondary text, and stronger rules (Field in the switch). It prints the same as Light. A choice you make is kept in your browser, for this site only. Each button’s tooltip says what its theme looks like, or what it’s for.
With the keyboard, Tab reaches every button in the header. On a phone, Enter or Space on the menu button, the three-line icon named Toggle Table of Contents, opens the table of contents and moves to its first control, the theme switch.
The footer
Each page but the print page (the whole guide on one page, below) ends with one line: the FusionSpace mark and the name FusionSpace HPR, Version and the last release’s number, Issued and the date of the commit the site is built from, a chip with the site’s status, and About HPR Sim, a link back to this page. The version and the date can be weeks apart. The chip reads In preparation while the pages describe work after the last release, and Released when they describe a release as it shipped. The title block at the end of this page is the site’s about box: it says what each entry means, and writes the status in capitals, as a drawing’s title block does.
Printing
A page prints in the light theme’s colors, whichever theme you read it in, without the table of
contents or the buttons. Each link’s address follows it in parentheses. For another site that’s
the whole address, and for a page of this one it’s the path from the page, such as
cli.html#units. The line with the version and date closes the page, without the footer’s link
to this page. The printer icon at the top,
Print the guide, opens a cover with a Print the guide button, which prints every chapter one
after another, then the whole title block. That runs long, since it
holds every chapter and its links’ addresses. Printed to a PDF file, the guide reads offline.
Title block
The table below is the site’s title block. It’s the box in an engineering drawing’s corner that
says what a document is, who issued it, when, and which sources it rests on. Its fields follow ISO
7200, the standard for drawings’ title blocks. Its entries describe the whole site and this
version of HPR Sim. The line at the foot of every page but the print page takes the version, the date and the status
from it. The printed guide ends with the whole block, its own title added as “Page” after the
site’s. FS-ACHERNAR · SW · TOOL 001 is HPR Sim’s number in the register of FusionSpace, the
family of tools it belongs to: Achernar, the simulator’s internal name, then software tool 1.
| Field | Entry |
|---|---|
| Owner | FusionSpace |
| Title | FusionSpace HPR · Sim: a flight simulator for hobby and high-power rockets, and its documentation |
| Designation | FS-ACHERNAR · SW · TOOL 001 |
| Version | 0.1.0, released 2026-10-08 (what it holds); the site is built from the repository’s main branch, which may be ahead of it |
| Date of issue | 2026-11-21 |
| Status | IN PREPARATION: these pages describe the next release as the main branch holds it, so a page may describe what 0.1.0 lacks; how far to trust each result is in Accuracy so far |
| Units | SI (meters, kilograms, seconds) first. Every command’s text adds US units in parentheses: feet after heights and distances, feet per second after speeds, miles per hour after the wind, °F after the air’s temperature, g after an acceleration and inches after stations along the rocket and a motor’s size; hpr motors show adds ounces or pounds. The plot gives a second scale in feet, feet per second and g. This site’s pages, unlike the program’s output, keep a motor’s nominal size in millimeters alone, as motors are named (a 54 mm motor); every other height, distance, size and speed on them gives its US units in brackets, checked as conversions (house style). JSON and exported files stay SI (units) |
| Data | Thrust curves: ThrustCurve.org’s solid motors, catalog captured 2026-10-28, the date flight reports give (as of 2026-10-28). Atmosphere: U.S. Standard Atmosphere 1976, or a sounding or forecast you supply or fetch (weather). Magnetic field: WMM2025. Accuracy: the committed validation report. Every source and its terms: third-party notices. |
| Fonts | Archivo and Cascadia Mono, SIL Open Font License 1.1, served from this site; no page asks another server for anything |
Getting started
Install HPR Sim, fly a first rocket from the rail to the ground with a short Rust program, and learn to change it.
This page takes you from nothing to a first simulated flight. You install Rust, build HPR Sim, and run a short program. It flies a rocket from the launch rail to the ground and prints what happened. Then the page walks through that program, so you can change it and fly your own variations. It needs some Rust, but no knowledge of this project.
The drag and the drift in a wind are the least certain numbers it prints (Accuracy of these numbers).
Setting up
Install a release, or gather what you need to build HPR Sim yourself.
Install a release
Release 0.1.0 is out. Each part installs without a copy of the repository. The rest of this page builds HPR Sim from the repository instead, which works too.
Release 0.1 has files for Linux on x86-64, Macs with Apple silicon, and Windows on x86-64. From release 0.2 there are also files for Linux on 64-bit ARM and Windows on ARM. Intel Macs aren’t built yet (issue #438).
- A package manager installs the command line,
hpr, and keeps it up to date, or you can download it yourself. Packages for winget and conda-forge are planned (issue #434). Whichever way you install it, the command ishpr.hpr --versionshows the install worked: it printsFusionSpace HPRand the version. The command line documents its commands.- Homebrew, on a Mac with Apple silicon or on Linux on x86-64, and on Linux on 64-bit ARM
from release 0.2:
brew install nrdptel/tap/fusionspace-hpr. Naming the tap in full adds it, so there’s no separatebrew tapstep.brew upgradetakes each new release. - Scoop, on Windows on x86-64, and on Windows on ARM from release 0.2:
scoop bucket add fusionspace https://github.com/nrdptel/scoop-bucketonce, thenscoop install fusionspace/fusionspace-hpr.scoop update fusionspace-hprtakes each new release. - cargo binstall, with Rust and cargo-binstall
installed:
cargo binstall fusionspace-hpr-clidownloads the release’s archive instead of compiling. Where it finds no archive, it compiles the crate, ascargo installdoes. That happens for releases before 0.2, whose crate on crates.io lacks the lines that point it at the archives. It happens on an Intel Mac too, until issue #438. - By hand. Download the archive for your system from
the releases page, unpack it, and
put
hpron your path. Each is namedfusionspace-hpr-<version>-<system>, and the package managers install the same files. - From source, anywhere else, or with Rust installed:
cargo install fusionspace-hpr-cli --lockedbuilds it.
- Homebrew, on a Mac with Apple silicon or on Linux on x86-64, and on Linux on 64-bit ARM
from release 0.2:
- The Python package installs with
pip install fusionspace-hpr, and it imports asfusionspace.hpr:from fusionspace import hpr. One wheel serves CPython 3.10 and later on each of those systems (3.11 on Windows on ARM, its oldest). Elsewhere pip builds it from source, which needs Rust (Python). - For your own Rust program,
cargo add fusionspace-hpradds the library’s front-door crate. A program uses it ashpr(use hpr::Rocket;), and it re-exports the others (The builder; the API reference).
Each archive and wheel holds the project’s two licenses and the license texts of everything compiled into it. How a release is built lists the files and the checks each passed. The changelog says what 0.1.0 does, how far to trust it, and its known gaps.
Three cautions for the downloaded archives:
-
macOS may say it can’t check
hprfor malicious software, since the program isn’t notarized by Apple. To allow it, runxattr -d com.apple.quarantine hprin the folder you unpacked it into. This applies to an archive downloaded in a web browser. Homebrew doesn’t mark a formula’s download for that check, so anhprit installs runs as it is. -
The Linux files are for x86-64 and need the GNU C library (glibc) 2.17 or later. Run
ldd --version: its first line ends in your glibc’s version. By their glibc, that means RHEL and CentOS 7, Debian 8, Ubuntu 14.04 and anything newer. The release’s checks run on a CentOS 7 image, and the others aren’t run one by one.On an older glibc the program stops with
version 'GLIBC_2.xx' not found. There, or on a distribution built on musl such as Alpine, build from source.cargo install fusionspace-hpr-cli --lockedbuilds the command line (What you need), and pip builds the Python package. Homebrew and cargo binstall install the same program on Linux, so the same floor applies to them. -
On Windows, release 0.2’s
hpr.exeruns on a clean Windows, since the C runtime is built into it. Release 0.1.0’s needs Microsoft’s Visual C++ Redistributable, a free package of runtime libraries. If Windows saysVCRUNTIME140.dllwas not found, install the Redistributable for 0.1.0’s x86-64 build withwinget install Microsoft.VCRedist.2015+.x64. With Scoop,scoop bucket add extrasthenscoop install vcredist2022does the same.extrasis Scoop’s own bucket, separate from thefusionspaceone above.
What you need
- Rust, through rustup, Rust’s installer. The repository pins the version
it’s built with (in
rust-toolchain.toml), and rustup installs that version the first time you build. - Your system’s C build tools, which Rust uses to link programs. You may have them already:
- On Windows, the Microsoft C++ build tools, from Visual Studio. The rustup installer checks for them and says how to get them.
- On macOS, Apple’s command-line developer tools. If
gitorccis missing, install them withxcode-select --install; they include Git. - On Linux, a C compiler such as
gcc, which most distributions have. On Debian and Ubuntu it comes with thebuild-essentialpackage.
- Git, to fetch the code.
- A network connection the first time, to download Rust and the libraries the simulator uses. After that, everything here works offline, on macOS, Windows and Linux.
Nothing else: no Python, Java or other simulator.
Your first flight
Build HPR Sim, fly the example rocket, and read what it printed and how accurate those numbers are.
Build it and fly
git clone https://github.com/nrdptel/fusionspace-eridanus.git
cd fusionspace-eridanus
cargo run --example first_flight -p fusionspace-hpr-sim
The first run compiles the simulator and its libraries, which takes a few minutes; later runs
start at once. The last command runs the program
crates/hpr-sim/examples/first_flight.rs.
In that command, --example first_flight names the program. -p fusionspace-hpr-sim (short for
--package) names the crate that holds it, one of the repository’s Rust
packages: the crate that flies the rocket. Code calls it hpr_sim (use hpr_sim::…). Every
fusionspace-hpr* package keeps its short name in code (the crates). The
program prints this:
Valetudo on a K400C: 9.67 kg at liftoff, a 3 m rail, 5 m/s of wind from 270°
Not yet validated: see the Accuracy page before trusting these numbers.
event time (s) CG height (m) speed (m/s)
liftoff 0.00 0.9 0.0
rail exit 0.37 3.9 16.2
burnout 3.26 216.0 111.0
apogee 13.83 778.7 6.4
drogue charge fires 13.83 778.7 6.4
drogue opens 14.33 777.6 7.7
main charge fires 39.23 150.0 27.0
main opens 40.23 123.5 27.0
landing 58.93 0.0 8.1
Apogee: 778.7 m (2555 ft) above the pad, 88.7 m from it at a bearing of 270°, at 13.83 s
Top speed: 112.3 m/s (Mach 0.34), at 3.0 s
Rail exit: 16.2 m/s
Landing: 90.2 m from the pad at a bearing of 90°, falling at 6.4 m/s, at 58.93 s
The heights are the center of gravity’s, above the launch site. Flight metrics gives the peaks, the stability margin through the climb, the best ejection delay and the landing’s latitude and longitude. Its example flies this rocket with one parachute.
You should see exactly these numbers. The project’s automated checks (CI, for continuous
integration) run the program on macOS, Windows and Linux on every change. They fail if it prints
anything but what is committed in
first_flight.output.txt,
the file quoted above.
What it printed
The rocket is Valetudo, which Projeto Jupiter, a student team at the University of São Paulo, flew in 2019. RocketPy, another open-source simulator, uses it as an example, and a copy of it is one of the project’s example rockets.
Its motor isn’t a real K400C. It keeps the size and mass of the motor in RocketPy’s example, and takes the thrust curve of a K400C in place of the original’s. The K400C is a commercial motor (motor designation) whose curve the simulator bundles. Like RocketPy’s example, HPR Sim flies the curve as it was measured. It adds no thrust for the thinner air at the site, 1,400 m (4,593 ft) above sea level.
The rocket launches from a 3 m (9.8 ft) vertical rail. A 5 m/s (11 mph) wind blows from the west at every height. The rocket comes down on a drogue and a main parachute.
The table lists the flight’s events in order:
| column | meaning |
|---|---|
| time | seconds since the motor ignited |
| CG height | the height of the rocket’s center of gravity above the launch pad. It starts at 0.9 m (3.0 ft), not 0: the rocket stands on the rail with its aft end at the rail’s foot, and its center of gravity is 0.9 m (3.0 ft) above that |
| speed | the center of gravity’s speed over the ground, not through the air |
And the events:
| event | what happens |
|---|---|
| liftoff | the push up the rail first beats the weight and the rail’s friction (zero here): the rocket starts to move (liftoff) |
| rail exit | the last rail button, one of the small studs that slide in the rail’s slot, leaves the top of the rail, and the rocket flies free (rail exit) |
| burnout | the motor’s thrust curve ends (burnout) |
| apogee | the highest point, where the rocket stops climbing (apogee) |
| drogue charge fires | the drogue is set to fire at apogee |
| drogue opens | half a second later, the drogue’s lines are stretched and it takes effect (deployment) |
| main charge fires | the rocket falls past 150 m (492 ft) above the pad, the main’s setting |
| main opens | a second later, the main takes effect |
| landing | the center of gravity reaches the ground |
Liftoff comes 1.6 milliseconds after ignition, when the thrust is only 73 N against 95 N of weight. Most of the rest of the push, 21 N, comes from the propellant’s internal momentum. That’s the propellant and gas moving inside the motor as it burns.
- A thrust curve measured on a test stand already includes that effect. The simulator’s equations of motion add it again, so it’s counted twice.
- HPR Sim does this on purpose, as RocketPy does, so that the two codes can be compared like for like. It’s a known approximation, listed with the other gaps on Start here.
- It’s small here: it changes the burnout speed by at most 0.05 m/s (0.2 ft/s) (Rigid-body flight).
The speed is over the ground, so it includes the drift. At apogee the rocket is still moving sideways at 6.4 m/s (21 ft/s). At landing it falls at 6.4 m/s (21 ft/s) while the 5 m/s (11 mph) wind carries it east. That’s 8.1 m/s (27 ft/s) in all ().
Below the table:
- Apogee is the highest point, in meters and feet, and where it was: 88.7 m (291 ft) from the pad at a bearing of 270°. A bearing is a direction clockwise from north, so 270° is due west.
- Top speed is the fastest the rocket went, over the ground, with its Mach number. The Mach number is the rocket’s speed through the air as a fraction of the speed of sound. The top speed comes just before burnout, once the dwindling thrust no longer beats the drag and the weight.
- Rail exit is the speed as the rocket leaves the rail. The slower it is in a crosswind, the larger the angle of attack just after it. That’s where the simulator’s models are least trustworthy (see what is left out). The simulator sets no minimum rail-exit speed and doesn’t judge whether this one is enough. That call is your range safety officer’s.
- Landing is where the rocket came down, 90.2 m (296 ft) due east of the pad, and how fast it was falling. The rocket weathercocks: it turns into the wind as it climbs, so its apogee is west of the pad. It then drifts east under its parachutes, past the pad.
Accuracy of these numbers
-
Heights, speeds and times match RocketPy’s, given the same drag. Both codes flew five of RocketPy’s example rockets, this airframe among them, from the pad to the ground with one declared drag coefficient. They agree within 3% on how high, how fast and how long (the whole-flight comparison). That checks the equations of motion, the motor and the air, not the drag.
-
Where it goes in wind is the least certain number. This airframe was compared with RocketPy only in still air, where its drifts agree within 3%.
Here it leaves the rail at 16.2 m/s (53 ft/s) in a 5 m/s (11 mph) wind, at a steep angle to the airflow. At such angles, HPR Sim’s drifts for two of RocketPy’s rockets are 10 to 38% from RocketPy’s (Accuracy). HPR Sim’s body lift and its later release from the rail put them there. Body lift is a sideways push on the body that RocketPy leaves out. How much body lift a body makes is itself uncertain.
So this example’s apogee drift, 88.7 m (291 ft) upwind, and its landing point are the least trustworthy numbers it prints. Drift and landing haven’t been compared with any real flight yet (real flights compare heights).
-
The thrust is likely a little low for this site. HPR Sim flies the curve as measured, to match RocketPy’s example. A motor fired on a test stand near sea level gives somewhat more thrust in the thinner air at 1,400 m (4,593 ft). With the simulator’s correction for that, which assumes a sea-level test, this flight reached 874 m (2,867 ft).
Motor files don’t say where the curve was measured, so neither number is certain. Treat 779 m (2,556 ft) as a little low (Solid motors).
-
The drag is the largest doubt. HPR Sim computes the drag coefficient from the rocket’s shape and surface. For this design it’s 0.5566 at Mach 0.3, coasting with the motor burnt out (power-off drag). That’s with rail buttons and a mirror-smooth surface finish (0 µm of roughness; a rougher surface adds skin-friction drag).
- That’s 23.5% under the 0.728 in the rocket’s own OpenRocket file.
- With that file’s rougher finish (60 µm) and its two launch lugs, HPR Sim gives 0.714, 1.9% under it. Launch lugs are short tubes on the outside of the body that ride along the rail, like rail buttons.
- The drag curve in RocketPy’s example says 1.05, which the comparison leaves unexplained (Aerodynamics). Flown on that curve, RocketPy’s flight peaks 10% lower than HPR Sim’s on its own drag (Accuracy).
A second program,
drag_what_if.rs, flies the same rocket with each of the other two values in place of HPR Sim’s drag. Each value is held at every Mach number. Run it the same way:cargo run --example drag_what_if -p fusionspace-hpr-simIt prints this, and CI checks that on every change, as it does for the first program:
Valetudo's apogee under three drag models, from a 3 m rail in 5 m/s of wind drag coefficient apogee (m) hpr's own, from the design 778.7 0.728, from the rocket's OpenRocket file 753.3 1.05, from RocketPy's example curve 711.5For this rocket, the three drag values on record move the apogee from 778.7 m (2,555 ft) to 711.5 m (2,334 ft), 8.6% lower. That’s a spread, not a bound:
- It shows how much this rocket’s apogee depends on its drag. It doesn’t say how far the simulator’s apogee is from the truth.
- Three values don’t fence in the true drag: it could lie outside them.
- HPR Sim’s drag has been checked against reference drag curves at Mach 0.3 only. It’s within 10% in two of seven cases, 10.3% and 11.5% low for two boattailed ones, 18% low for another rocket with its motor burning, and 47% to 50% low against this rocket’s own curve, the 1.05 above (Accuracy).
- Another rocket, or this one on another motor, has its own spread.
So 779 m (2,556 ft) is this design’s answer, and with more drag the same design would peak lower. The rocket that flew had a different motor, so none of these is a prediction of its flight.
-
The parachutes are simple. Each opens fully the moment its lines stretch. There’s no filling time and no drag overshoot, the canopy’s drag briefly rising above its steady value as it fills. So the opening load the simulator reports is no safe bound either way. Each canopy’s drag coefficient is the middle of the range printed for its type in Knacke’s Parachute Recovery Systems Design Manual, a standard handbook (Recovery).
-
The descent is the best-checked part. Its check gives both codes the same start near apogee, opens the first parachute at once and uses RocketPy’s formula for gravity. On those terms, HPR Sim’s descent agrees with RocketPy’s within 3% for five rockets (Recovery).
This example opens the drogue after half a second and uses HPR Sim’s own gravity. Its landing point also depends on where the apogee is. On each code’s own drag, the apogee differs from RocketPy’s by 10% for this rocket.
Checking it yourself
You don’t have to take these numbers on trust. Four ways to test them:
-
To see how much the drag matters, run
drag_what_if, as above. To try other drag coefficients, change the values in its list of them and run it again. -
To trace a number to its source, use Checking a claim. It follows any number on this site back to the published source of its model, the test that pins it, and any comparison with another program.
-
To compare with a flight of your own, by hand, build your rocket as Your own rocket does, with the motor you flew. Solid motors shows how to read its thrust-curve file. Set the rail and the wind to match the day, and set HPR Sim’s apogee beside your altimeter’s.
HPR Sim’s apogee is the height of the rocket’s center of gravity above the pad. Most hobby altimeters measure air pressure and turn it into height with the standard atmosphere. So on a day warmer or colder than standard, they read off by roughly 3 to 4% of the height for every 10 °C of difference. Give the simulator the day’s temperature too:
Ussa76::with_offsetshifts the standard atmosphere, andEnvironment::newtakes it.The analyzer,
hpr analyze, reads your altimeter’s log, in any of the layouts it reads. From its barometric altitude or pressure, it takes the flight’s apogee, liftoff, top speed and landing (Reading a flight log). Each comes within a stated bound, or is withheld by name. A GPS track alone gives no readings.hpr comparesets a log against a simulation of it (Comparing a flight with its simulation). -
To compare with another simulator, by hand, enter the same rocket, motor, rail and wind in OpenRocket or RocketPy, and compare the apogee. Give both the same surface finish and rail guides. For this rocket, the OpenRocket file’s finish and launch lugs take HPR Sim’s drag coefficient from 0.5566 to 0.714, as above. HPR Sim reads OpenRocket’s
.orkfiles too (OpenRocket import; Fly your.ork).
The project compared whole flights against RocketPy with the drag given to both codes, and with each code’s own drag.
Reading the code
Walk through the program line by line, then change it and fly again.
The program, step by step
This is the whole program. It’s also the file CI runs, line for line.
//! A first flight: a rocket with a drogue and a main parachute, flown from the launch rail to the
//! ground, with a summary of what happened.
//!
//! Run it from anywhere in the repository:
//!
//! ```text
//! cargo run --example first_flight -p fusionspace-hpr-sim
//! ```
//!
//! The documentation site's *Getting started* page (`docs/getting-started.md`) walks through it.
//! What it prints is kept next to it in `first_flight.output.txt`, and CI checks that the two
//! still agree (`cargo xtask examples --check`).
#![allow(
clippy::print_stdout,
reason = "the project's lints forbid printing in library code, and this program exists to print"
)]
use std::error::Error;
use hpr_atmos::ConstantWind;
use hpr_core::DVec3;
use hpr_core::geodesy::Geodetic;
use hpr_design::Rocket;
use hpr_sim::{
CanopyType, Device, DeviceDrag, Environment, EventKind, FlightSettings, FlightStep, Observer,
Rail, SimError, Simulation, Termination, Trigger,
};
fn main() -> Result<(), Box<dyn Error>> {
// The rocket: Valetudo, which Projeto Jupiter (University of São Paulo) flew in 2019 and
// RocketPy uses as an example. The design file describes its parts, materials and motor; the
// motor keeps the example's size and mass, with a bundled K400C thrust curve.
let rocket: Rocket = serde_json::from_str(include_str!(
"../../../validation/designs/rocketpy-valetudo.json"
))?;
// Where and in what weather: a site in New Mexico 1,400 m up, the 1976 US Standard
// Atmosphere, and a steady wind from the west (270°) at every height.
let site = Geodetic::from_degrees(32.99, -106.97, 1400.0)?;
let wind_speed_m_s = 5.0;
let wind_from_deg = 270.0_f64;
let environment = Environment::standard(site)?.with_wind(ConstantWind::new(
wind_speed_m_s,
wind_from_deg.to_radians(),
)?);
// A vertical launch rail.
let rail_length_m = 3.0;
let rail = Rail::vertical(rail_length_m);
// The flight: the design's configuration "example" (its K400C), the default settings, and
// dual deployment. The drogue opens half a second after apogee; the main opens a second after
// the rocket falls past 150 m above the ground, and the drogue stays attached.
let simulation = Simulation::new(
&rocket,
"example",
environment,
rail,
FlightSettings::default(),
)?
.with_recovery(vec![
Device::new(
"drogue",
DeviceDrag::canopy(CanopyType::FlatCircular, 0.6),
Trigger::Apogee,
)
.with_lag_s(0.5),
Device::new(
"main",
DeviceDrag::canopy(CanopyType::FlatCircular, 2.4),
Trigger::Altitude {
height_above_ground_m: 150.0,
},
)
.with_lag_s(1.0),
])?;
// Fly it. `TopSpeed` (below) watches every step of the flight for its fastest moment.
let mut top = TopSpeed::default();
let flight = simulation.run(&mut top)?;
if flight.termination != Termination::GroundHit {
return Err(format!("the flight ended with {:?}", flight.termination).into());
}
let liftoff = flight
.event(EventKind::Liftoff)
.ok_or("the rocket never lifted off")?
.sample;
println!(
"Valetudo on a K400C: {:.2} kg at liftoff, a {rail_length_m} m rail, {wind_speed_m_s} m/s \
of wind from {wind_from_deg}°",
liftoff.mass_kg
);
println!("Not yet validated: see the Accuracy page before trusting these numbers.");
println!();
println!("event time (s) CG height (m) speed (m/s)");
for event in &flight.events {
let name = match event.kind {
EventKind::Liftoff => "liftoff".to_owned(),
EventKind::RailExit => "rail exit".to_owned(),
EventKind::Burnout => "burnout".to_owned(),
EventKind::Apogee => "apogee".to_owned(),
EventKind::Trigger(i) => format!("{} charge fires", simulation.recovery()[i].name),
EventKind::Deployment(i) => format!("{} opens", simulation.recovery()[i].name),
EventKind::GroundHit => "landing".to_owned(),
other => format!("{other:?}"),
};
let sample = &event.sample;
// Heights are the center of gravity's above the pad. The flight ends where it reaches the
// ground, found to within a micrometer just below it: print that as 0 (`+ 0.0` turns a
// -0 into 0).
println!(
"{name:<20} {:>8.2} {:>15.1} {:>13.1}",
sample.time_s,
sample.height_above_ground_m.max(0.0) + 0.0,
sample.cg_velocity_enu_m_s.length(),
);
}
let apogee = flight
.event(EventKind::Apogee)
.ok_or("the flight has no apogee")?
.sample;
let rail_exit = flight
.event(EventKind::RailExit)
.ok_or("the flight never left the rail")?
.sample;
let landing = flight.final_sample;
let (apogee_distance_m, apogee_bearing_deg) = from_pad(apogee.cg_enu_m);
let (landing_distance_m, landing_bearing_deg) = from_pad(landing.cg_enu_m);
println!();
println!(
"Apogee: {:.1} m ({:.0} ft) above the pad, {apogee_distance_m:.1} m from it at a \
bearing of {apogee_bearing_deg:.0}°, at {:.2} s",
apogee.height_above_ground_m,
apogee.height_above_ground_m / METERS_PER_FOOT,
apogee.time_s,
);
println!(
"Top speed: {:.1} m/s (Mach {:.2}), at {:.1} s",
top.speed_m_s, top.mach, top.time_s,
);
println!(
"Rail exit: {:.1} m/s",
rail_exit.cg_velocity_enu_m_s.length()
);
println!(
"Landing: {landing_distance_m:.1} m from the pad at a bearing of \
{landing_bearing_deg:.0}°, falling at {:.1} m/s, at {:.2} s",
-landing.vertical_speed_m_s, landing.time_s,
);
Ok(())
}
/// The international foot.
const METERS_PER_FOOT: f64 = 0.3048;
/// Where `position` is from the pad: its distance over the ground, m, and its bearing, clockwise
/// from north, degrees. The launch frame's axes point east, north and up from the pad
/// (`docs/physics/frames.md`).
fn from_pad(position: DVec3) -> (f64, f64) {
let (east_m, north_m) = (position.x, position.y);
let bearing_deg = east_m.atan2(north_m).to_degrees().rem_euclid(360.0);
(east_m.hypot(north_m), bearing_deg)
}
/// The fastest moment of a flight, relative to the ground.
///
/// An [`Observer`] sees every accepted step of the integration as the flight runs. This one looks
/// at the end of each step. Looking at 200 points inside every step instead raises the top speed
/// by 0.005 m/s, and moves its time by 0.013 s, since the speed is flat near its peak. So the
/// speed can read low by one in its last printed digit, and the time is printed to 0.1 s.
#[derive(Debug, Default)]
struct TopSpeed {
speed_m_s: f64,
mach: f64,
time_s: f64,
}
impl Observer for TopSpeed {
fn step(&mut self, step: &dyn FlightStep) -> Result<(), SimError> {
let sample = step.sample(step.end_s())?;
let speed_m_s = sample.cg_velocity_enu_m_s.length();
if speed_m_s > self.speed_m_s {
*self = Self {
speed_m_s,
mach: sample.mach,
time_s: sample.time_s,
};
}
Ok(())
}
}
It has six steps.
-
The rocket. The program reads Valetudo’s design from
validation/designs/rocketpy-valetudo.jsoninto aRocket: its parts, their shapes, materials and positions, and its motor.The file holds the rocket alone: the
rocketkey of the open design format, without the rest of a.hprfile. HPR Sim also reads whole.hprfiles, and OpenRocket’s.orkfiles (import from OpenRocket). The designs folder holds the other example rockets, and its README says how each was built. -
The surroundings.
Geodetic::from_degreesplaces the launch site by latitude, longitude and height.Environment::standardgives it the Earth’s WGS 84 gravity and rotation, the 1976 US Standard Atmosphere and no wind.with_windadds a constant wind:wind_speed_m_s, 5 m/s (11 mph), fromwind_from_deg, 270°, clockwise from north (see wind direction). Angles in the code are in radians, henceto_radians(). -
The rail.
Rail::vertical(rail_length_m)is a rail 3 m (9.8 ft) long pointing straight up, with no friction. Its fields also set its heading, its angle above the horizon and its friction. -
The simulation.
Simulation::newtakes the rocket and the name of the configuration to fly. A design can hold several, one per motor choice.It also takes the surroundings, the rail and the integration settings, which say how finely to step through time. It runs the design’s checks first, and refuses a rocket that can’t exist, such as a motor wider than its mount.
FlightSettings::default()steps through time to a tight tolerance (Time integration). -
The parachutes. Each
Devicehas a name, a drag, and a trigger that fires its charge.DeviceDrag::canopyis a parachute of the given type and nominal diameter in meters. The drogue’s is 0.6 m (24 in), and the main’s is 2.4 m (94 in).CanopyType::FlatCircularis a flat circular canopy. It’s one of thirteen canopy types, such as conical, hemispherical, cross and ringslot, each with drag data from Knacke’s parachute handbook. TheCanopyTypepage of the API reference lists them all, and Recovery explains the data.Trigger::Apogeefires at apogee;Trigger::Altitudefires when the rocket falls past a height above the pad.with_lag_sis the time from the charge to the lines stretching. With no filling rule given, one for how the canopy’s drag grows as it opens, each parachute opens fully at once.
-
The flight.
runflies the rocket until it lands. It returns aFlightResult, the record of the finished flight. That holds how it ended (termination), itsevents, each with aSampleof the flight at that moment, and the final sample.- The argument to
runis anObserver: any type that is shown every step of the flight as it runs.TopSpeed, at the bottom of the program, is one: it keeps the fastest moment. - For a whole trajectory, to plot or save, pass a
Recorderinstead. It keeps the quantities you choose, each aChannel, such as the height or the Mach number, as a table. Recording a trajectory shows one, lists the channels, and shows what it prints.
- The argument to
A Sample is a snapshot of the flight at one instant.
It holds what the program prints, and more. It has the time, and the center of gravity’s position
(cg_enu_m, meters east, north and up of the pad) and velocity (cg_velocity_enu_m_s). It also
has the height above the pad, the vertical speed, the airspeed, the Mach number, the angle of
attack, the thrust and the mass. Every quantity is in SI units, the metric
units of the International System, and its name ends in its unit:
| ending | unit | example |
|---|---|---|
_m | meters | height_above_ground_m |
_m_s | meters per second | vertical_speed_m_s |
_s | seconds | time_s |
_kg | kilograms | mass_kg |
_n | newtons | thrust_n |
_rad | radians | angle_of_attack_rad |
A number with no unit, such as the Mach number (mach), has none in its name.
Change it
Edit the program and run it again. The edits below are for you to try. Each says which way the results move; run it to see by how much. Nothing checks these edits or what they print, so this page gives no exact numbers for them. For example:
- For more wind, change
let wind_speed_m_s = 5.0;to10.0. The apogee drops a little and the landing moves farther east. - To angle the rail into the wind, replace
Rail::vertical(rail_length_m)withRail { elevation_rad: 85_f64.to_radians(), azimuth_rad: 270_f64.to_radians(), ..Rail::vertical(rail_length_m) }, a rail tilted 5° toward the west. The rocket now lands west of the pad, upwind. - To open the main higher, change
height_above_ground_m: 150.0to300.0. The rocket spends longer under its main and lands farther downwind. - To drop the drogue, delete the first
Device, the drogue. The rocket now falls at over 100 m/s (328 ft/s) until the main opens, far faster than a real parachute survives. The simulator reports the violent deceleration as it opens. But it has no model of a parachute or its harness failing, so the flight still ends in a gentle landing (Recovery).
Your edited program no longer prints what first_flight.output.txt says. That’s expected.
If you propose a change to the program itself in a pull request, two more commands help.
cargo xtask runs the project’s own maintenance tasks, a Rust program in the repository’s
xtask folder:
cargo xtask examplesruns every example program and writes its new output next to it;cargo xtask sitebuilds this documentation site, and checks that the quotes on this page still match the program and its output.
Where next
- Recording a trajectory keeps the whole flight as a table, to plot or save.
- How a flight is simulated explains what happens between ignition and landing, and links the page for each model.
- Your own rocket builds a rocket of your own, with your dimensions and a bundled motor. It shows the rocket’s center of pressure, center of gravity and stability margin. The builder does the same in fewer lines.
.orkdesign files reads a design from OpenRocket. On a file’s own curves and the bundled motors alone, most motor configurations fly.hpr simlooks up a missing curve once and keeps what it finds (how many fly). Its parachutes and streamers fly as OpenRocket flies them.- Accuracy gathers every validation result, and Checking a claim shows how to trace a number to its source and its test.
- The API reference documents every type used here, and
cargo doc --open -p fusionspace-hpr-simbuilds it on your machine.
Fly your .ork
Fly a rocket designed in OpenRocket with hpr sim from the command line, and learn to read the
numbers it prints.
This guide flies a rocket you designed in OpenRocket with hpr sim,
from the command line, and says how to read what it prints. It’s for a flier who has a .ork
file and wants a second simulator’s view of it.
The steps:
- Fly the file as it is.
- Choose the configuration and the launch.
- Fetch a motor the simulator doesn’t have.
- Plot it, or save the numbers.
- When the simulator refuses.
You need hpr installed: the README’s
Install and first flight takes a
few minutes.
The examples fly the guides’ own rocket,
validation/fixtures/ork/guides/level-1.ork.
It’s a 66 mm (2.6 in), 0.82 kg rocket with a 38 mm motor mount and one parachute on the motor’s
ejection charge. It’s saved with two motors, an AeroTech H170M and an I175WS. OpenRocket 24.12 opens
it. Run the commands from a copy of the repository, or put your own file’s path in its place.
Fly the file as it is
hpr sim with the file’s name flies its default configuration, with the motors, delays and
parachutes the file holds. The guide rocket’s motors are in the catalog built into the simulator, so
it flies with no network:
$ hpr sim validation/fixtures/ork/guides/level-1.ork
Level 1 guide rocket (level-1.ork)
configuration 1 of 2: [H170M-10]
help: --config flies the others, by number or name: 2 [I175WS-9]
a simulated flight, not a measurement
static margin 1.70 calibers off the rail; least 1.70 calibers, at 0.12 s, before apogee
CG and CP 0.811 m (31.9 in) and 0.923 m (36.3 in) aft of the nose tip, off the rail
apogee 1065.1 m (3494 ft) above the site at 11.62 s
rail exit speed 26.3 m/s (86 ft/s)
delay apogee 9.48 s after burnout, with the charges held; the motor's set delay: 10 s; its charge fires 0.52 s after apogee; the delay may fire 2.0 s short or long (NFPA 1125): climbing at 14.7 m/s (48 ft/s) to 2.52 s after apogee (no speed: falling with nothing open, a fall HPR Sim doesn't predict)
descent 4.4 m/s (15 ft/s) at landing under `Parachute`
motor: 1 × H170M (from the bundled catalog, as of 2026-10-28) in `Motor mount tube`, lit at launch
recovery: `Parachute` at the ejection charge, 0.520 m² of drag area, opened at 12.14 s
launched at 0.00000° N, 0.00000° E, 0 m (0 ft) above sea level, from 1.5 m (4.9 ft) of vertical rail above its aft end, in calm air
note: the file's 1 recovery device flies as OpenRocket flies it. Each opens fully at its event, with the file's drag coefficient or OpenRocket's own. Once one opens, the rocket descends as a point under the open devices' drag alone
warning: drag: issue #67: a cone-like nose's or shoulder's pressure drag reads high from Mach 0.8 (about twice a measured cone's at Mach 0.85, still +15% at 1.5). So the apogee, top speed and drift read low, and the flutter margin and largest dynamic pressure look better than they are. This flight reaches Mach 0.84 at 1.7 s
warning: drag: issue #68: base drag reads high from Mach 0.8 to 1.2 (0.225 against a measured 0.156 at Mach 0.9). So the apogee, top speed and drift read low, and the flutter margin and largest dynamic pressure look better than they are. This flight reaches Mach 0.84 at 1.7 s
warning: drag: issue #18: skin friction is taken as fully turbulent; on a smooth surface a laminar run near the nose lowers it, by 3.6% on RocketPy's Calisto at Mach 0.3. If this surface is that smooth, the apogee, top speed and drift read low, and the flutter margin and largest dynamic pressure look better than they are
warning: stability: issue #172: the static margin read up to 0.1108 calibers above OpenRocket's on four private designs, cause unknown; this flight's may read high by as much
warning: stability: issue #1290: on one of two wind-tunnel models, the center of pressure sat 0.11 to 0.92 calibers aft of the tunnel's at Mach 0.6 and 0.8, as the report's curve reads; fitted over −3° to 4°, about 0.08 at 0.8. So from Mach 0.6 the flight margin may read high. This flight reaches Mach 0.84 at 1.7 s
warning: stability: issue #1198: the center of pressure sat 0.67 to 1.35 calibers aft of a wind tunnel's on two models at Mach 0.9, so past Mach 0.8 the flight margin may read high. This flight reaches Mach 0.84 at 1.7 s
help: issues: https://github.com/nrdptel/fusionspace-eridanus/issues/<number>
event time height speed
liftoff 0.00 s 0.4 m (1 ft) 0.0 m/s (0 ft/s)
rail exit 0.12 s 1.9 m (6 ft) 26.3 m/s (86 ft/s)
burnout 2.14 s 406.4 m (1333 ft) 240.4 m/s (789 ft/s)
apogee 11.62 s 1065.1 m (3494 ft) 0.1 m/s (0 ft/s)
charge 12.14 s 1063.7 m (3490 ft) 5.1 m/s (17 ft/s)
deployment 12.14 s 1063.7 m (3490 ft) 5.1 m/s (17 ft/s), airspeed 5.1 m/s (17 ft/s)
ground hit 245.78 s 0.0 m (0 ft) 4.4 m/s (15 ft/s)
(heights are the center of gravity's above the site; speeds are over the ground, and a deployment's
airspeed through the air)
top speed 285.6 m/s (937 ft/s) at 1.73 s
top Mach number 0.842
landing 0.7 m (2 ft) from the pad at 245.78 s, at 4.4 m/s (15 ft/s)
How far to trust it. Simulated from the design file, not measured. Against 60 logged flights of
fliers' own designs, the simulated apogee averaged 8.0% above the logged one. HPR Sim flew each in
its day's air from ERA5, a weather reanalysis, and each logged apogee is the height climbed in it.
The simulated apogee was within 10% on 31 and read low on 15, by at most 20%. This flight was flown
in the standard atmosphere. On a day warmer than it at the site, the rocket can climb higher than
this apogee; --weather flies the day's air. Plan a waiver or a field's ceiling with room above this
apogee; the altimeter's reading is the one to log, and the RSO decides.
More: https://hpr.fusionspace.co/accuracy.html
The lines under the configuration are the ones to read first. Each height and speed is in SI, with feet or feet per second in parentheses:
static marginis how far the center of pressure sits behind the center of gravity, in body diameters (calibers). The line gives it as the rocket leaves the rail, and its least value before apogee. A rocket with a fin set of one or two fins has a different margin for each direction the air crosses it.hpr simprints the least (Flight metrics). Check stability for a certification flight says how to use it.CG and CPgives where the center of gravity and the center of pressure sit as the rocket leaves the rail, measured from the nose tip. They’re the two points the margin comes from.apogeeis the highest point of the center of gravity, above the launch site.rail exit speedis the speed as the rocket leaves the rail. The slower it is, the more a crosswind tips the rocket just after.delaygives the coast from burnout to apogee, with the charges held, beside the delay the file sets. Here the H170M’s 10 s charge fires about half a second after apogee. The line ends with how far the delay may fire short or long, and the speed at either end where the simulator predicts one. Pick a motor says how to choose one.descentis how fast the rocket comes down under its open parachutes, without the wind’s drift.
The recovery line names each parachute, when it opened and its drag area. The events table
gives each event’s time, height and speed. The note says how the parachute is flown: it opens
fully at once, as OpenRocket’s does. The command line explains every
line, and any warning you may see.
Choose the configuration and the launch
--config picks another of the file’s configurations, by its number, its name or its motors.
The output’s second and third lines list them. A configuration the file leaves unnamed is called
by its motors and delays in brackets. So the guide rocket’s second is [I175WS-9], and
--config 2, --config I175WS-9 and --config i175ws-9 all fly it.
hpr sim doesn’t read the launch conditions saved with the file’s simulations: give them as
options. Without them, the rocket flies from a 1.5 m (4.9 ft) vertical rail at sea level, at
0° N, 0° E, in calm air. Set the site’s elevation for every real field: air thins with height, and
a rocket climbs higher from a high one. --rail-length runs from the rocket’s aft end to the
rail’s top: from its fin tips if they reach past the tube. So take a standoff or blast deflector
the rocket sits on off the rail’s length as sold. This flies the second configuration from a field
1,400 m (4,593 ft) up. The rail’s top is 2.4 m (7.9 ft) above the rocket’s aft end, the rail is
tilted 5° toward the west, and a 4 m/s (8.9 mph) wind blows from the west:
$ hpr sim validation/fixtures/ork/guides/level-1.ork --config 2 --elevation 1400 --rail-length 2.4 --inclination 85 --heading 270 --wind 4 --wind-from 270
Level 1 guide rocket (level-1.ork)
configuration 2 of 2: [I175WS-9]
help: --config flies the others, by number or name: 1 [H170M-10]
a simulated flight, not a measurement
static margin 1.69 calibers off the rail; least 1.69 calibers, at 0.17 s, before apogee
CG and CP 0.811 m (31.9 in) and 0.923 m (36.3 in) aft of the nose tip, off the rail
apogee 1174.3 m (3853 ft) above the site at 11.51 s
rail exit speed 36.8 m/s (121 ft/s)
delay apogee 10.42 s after burnout, with the charges held; the motor's set delay: 9 s; its charge fires 1.42 s before apogee; the delay may fire 1.8 s short or long (NFPA 1125): climbing at 32.4 m/s (106 ft/s) to falling at 3.4 m/s (11 ft/s)
descent 4.9 m/s (16 ft/s) at landing under `Parachute`
motor: 1 × I175WS (from the bundled catalog, as of 2026-10-28) in `Motor mount tube`, lit at launch
recovery: `Parachute` at the ejection charge, 0.520 m² of drag area, opened at 10.97 s
launched at 0.00000° N, 0.00000° E, 1400 m (4593 ft) above sea level, from 2.4 m (7.9 ft) of rail above its aft end, 85° above the horizon, leaning toward 270° T, in a 4 m/s (9 mph) wind from 270° T
note: the file's 1 recovery device flies as OpenRocket flies it. Each opens fully at its event, with the file's drag coefficient or OpenRocket's own. Once one opens, the rocket descends as a point under the open devices' drag alone
warning: drag: issue #67: a cone-like nose's or shoulder's pressure drag reads high from Mach 0.8 (about twice a measured cone's at Mach 0.85, still +15% at 1.5). So the apogee, top speed and drift read low, and the flutter margin and largest dynamic pressure look better than they are. This flight reaches Mach 0.87 at 1.8 s
warning: drag: issue #68: base drag reads high from Mach 0.8 to 1.2 (0.225 against a measured 0.156 at Mach 0.9). So the apogee, top speed and drift read low, and the flutter margin and largest dynamic pressure look better than they are. This flight reaches Mach 0.87 at 1.8 s
warning: drag: issue #18: skin friction is taken as fully turbulent; on a smooth surface a laminar run near the nose lowers it, by 3.6% on RocketPy's Calisto at Mach 0.3. If this surface is that smooth, the apogee, top speed and drift read low, and the flutter margin and largest dynamic pressure look better than they are
warning: stability: issue #172: the static margin read up to 0.1108 calibers above OpenRocket's on four private designs, cause unknown; this flight's may read high by as much
warning: stability: issue #1290: on one of two wind-tunnel models, the center of pressure sat 0.11 to 0.92 calibers aft of the tunnel's at Mach 0.6 and 0.8, as the report's curve reads; fitted over −3° to 4°, about 0.08 at 0.8. So from Mach 0.6 the flight margin may read high. This flight reaches Mach 0.87 at 1.8 s
warning: stability: issue #1198: the center of pressure sat 0.67 to 1.35 calibers aft of a wind tunnel's on two models at Mach 0.9, so past Mach 0.8 the flight margin may read high. This flight reaches Mach 0.87 at 1.8 s
help: issues: https://github.com/nrdptel/fusionspace-eridanus/issues/<number>
event time height speed
liftoff 0.02 s 0.4 m (1 ft) 0.0 m/s (0 ft/s)
rail exit 0.17 s 2.8 m (9 ft) 36.8 m/s (121 ft/s)
burnout 1.97 s 389.9 m (1279 ft) 271.2 m/s (890 ft/s)
charge 10.97 s 1172.0 m (3845 ft) 15.4 m/s (50 ft/s)
deployment 10.97 s 1172.0 m (3845 ft) 15.4 m/s (50 ft/s), airspeed 17.7 m/s (58 ft/s)
apogee 11.51 s 1174.3 m (3853 ft) 1.0 m/s (3 ft/s)
ground hit 246.17 s 0.0 m (0 ft) 6.3 m/s (21 ft/s)
(heights are the center of gravity's above the site; speeds are over the ground, and a deployment's
airspeed through the air)
top speed 290.9 m/s (954 ft/s) at 1.75 s
top Mach number 0.874
landing 755.8 m (2480 ft) from the pad at 246.17 s, at 6.3 m/s (21 ft/s)
How far to trust it. Simulated from the design file, not measured. Against 60 logged flights of
fliers' own designs, the simulated apogee averaged 8.0% above the logged one. HPR Sim flew each in
its day's air from ERA5, a weather reanalysis, and each logged apogee is the height climbed in it.
The simulated apogee was within 10% on 31 and read low on 15, by at most 20%. This flight was flown
in the standard atmosphere. On a day warmer than it at the site, the rocket can climb higher than
this apogee; --weather flies the day's air. Plan a waiver or a field's ceiling with room above this
apogee; the altimeter's reading is the one to log, and the RSO decides.
More: https://hpr.fusionspace.co/accuracy.html
--inclination is the rail’s angle above the horizon, so 85 is 5° off vertical. OpenRocket gives
the same rail as 5°, from the vertical. --heading 270 leans it toward the west, into the wind.
The wind is the same at every height. The launch lists every option and its default.
Fetch a motor the simulator doesn’t have
A motor outside the simulator’s catalog is fetched from
ThrustCurve.org the first time you fly it. Then it’s kept in the
simulator’s cache, so it flies offline after. A .ork names its motor but rarely carries its
thrust curve. The catalog holds ThrustCurve.org’s solid motors, but not
one newer than it, or one ThrustCurve.org lists without a curve file. With no network, and no copy
in the cache, hpr sim refuses and prints the command that fetches it. This test rocket names an
invented motor, which no catalog holds:
$ hpr sim validation/fixtures/ork/guides/no-curve.ork --offline
error: configuration [Z9-INVENTED] can't be flown as the file has it. No thrust curve for Z9-INVENTED: no embedded curve, and no motor of that manufacturer and designation in the bundled catalog. Invented Z9-INVENTED is not in HPR Sim's cache of ThrustCurve.org, and the run is offline
help: with a network connection, `hpr motors fetch --manufacturer Invented Z9-INVENTED` fetches it into the cache
help: give a motor with --motor
$ echo $?
1
Run that command once with a network connection, or fly the file once online:
hpr motors fetch --manufacturer Invented Z9-INVENTED
The curve is ThrustCurve’s, found by the file’s manufacturer and designation. For the motors of OpenRocket’s own example designs, HPR Sim knows which file holds the curve OpenRocket flies, and takes it. For any other motor, the file may not be the one OpenRocket flies.
A note under the flight names the curve file, who measured it, and which of the two it is. Motors
from ThrustCurve.org says how the simulator picks one. If you
have the motor’s .eng or .rse file, fly it with --motor:
hpr sim my-rocket.ork --motor my-motor.eng.
Plot it, or save the numbers
--plot draws the flight as a picture; --export saves every number.
hpr sim validation/fixtures/ork/guides/level-1.ork --plot level-1.svg --export level-1.csv
The plot is one fixed figure: altitude, speed and acceleration against time, each event marked. An SVG opens in any web browser; Plotting the flight shows one.
Beside it, level-1.plot.csv holds the numbers the figure draws. The
export holds every quantity the simulator tracks, every 0.01 s. The file’s extension picks the
format (.csv, .json, .parquet, .geojson or .kml).
Exporting a flight says what each column means. --json prints the
summary itself as data, for a script to read.
When the simulator refuses
hpr sim refuses, with the reason, rather than fly something other than your design. The
common reasons, and what to do:
| it says | what to do |
|---|---|
| no thrust curve for the motor, and the run is offline | fetch it once online, as above, or give a motor file with --motor |
| the design’s checks found errors | each error names the parts, such as a motor wider than its mount. Fix the design; or, to fly it anyway, add --accept-design-errors, and the flight’s notes list the errors |
| a part the simulator couldn’t read exactly as written | The simulator flies only what it reads exactly. The message names the part; the .ork page lists what it reads |
| a stage that separates, a second motor lit in flight | powered separations fly without --motor, one or several in turn, as on a three-stage rocket (Separation); with --motor, drop the option to fly the file’s own motors. A payload dropped with nothing left to burn flies when its own parachute opens at the split; one that would coast with no drag first is refused: set one of the payload’s devices to open at “Lower stage separation” with no delay (a payload’s split) |
| it can’t tell which configuration to fly | the file has several and no default: name one with --config |
| a parallel stage hangs on the core’s tube, “whose stage carries an added mass with no station” | the core has a mass override with the override for all subcomponents box unticked, and boosters beside it. Say where that mass is: add a center of gravity override on the core with the box unticked too, or untick the one it has (why) |
Warnings aren’t refusals. A warning: line flags something the design’s checks found unusual
but buildable, such as a motor longer than its mount tube. The flight goes on. Warnings,
notes and help: lines go to standard error, so hpr sim rocket.ork > flight.txt saves the
flight alone and leaves them on the terminal.
A stage that weighs more than its parts. If your stage has a mass override with OpenRocket’s override for all subcomponents box unticked, OpenRocket adds that mass to what the parts weigh, and so does the simulator. It used to refuse such a stage. Boosters strapped beside the core (a parallel stage) are read the same way. Their stage’s added mass is one mass for the set, and it drops with them.
Where a stage’s override has that box ticked, the simulator leaves the stage’s parts where they are, as OpenRocket does, and its mass, center and inertia match OpenRocket’s on the probe designs of one stage with no motor aboard. With the override on the lower of two stages, or with a motor aboard and a center override beside an added mass, OpenRocket takes the parts about the whole rocket’s center rather than the stage’s, and the simulator doesn’t. On the probes that show it, the rocket’s inertia across the axis is from 1.6% under to 4.95% over OpenRocket’s (the 1.6% worked by hand from OpenRocket’s own output), and another rocket’s can differ more (what a stage’s added mass leaves out).
Where the ticked override is on boosters strapped beside the core, the boosters’ own mass, center and inertia match OpenRocket’s on the probes. The whole rocket’s inertia across the axis doesn’t. The override adds less to it than it does in OpenRocket, by 0.070% to 4.673% of OpenRocket’s inertia for that rocket. M2.3d14, the rocket’s inertia beside a parallel stage’s covering override, is to close that where an unticked override is beside the ticked one. Where every override is ticked, no work is planned yet (#1432).
A core with boosters and an unticked mass override. It is refused unless a center override with the box unticked is beside the mass. The message says a parallel stage hangs on a tube “whose stage carries an added mass with no station”. With no center override, OpenRocket puts that mass at the center of the core and its boosters together, so it moves when the boosters drop. The simulator’s stage keeps one center. Add a center of gravity override on the core with the box unticked, and the mass has a fixed place. It is a station measured from the core’s forward end. The design then flies with a ring of two or more boosters. Three were measured against OpenRocket. One booster alone, off the axis, is still refused. Flying the mass with no center override that has the box unticked, or beside a single booster off the axis, is open work: M2.3d11, the stage a parallel stage hangs on. An unticked mass override of zero adds nothing, so neither refusal applies to it.
Matching OpenRocket isn’t matching your rocket. Where a ticked override sets the stage’s mass, both put the mass the parts miss at the stage’s center, where it adds no inertia. If that mass is really spread along the stage, as its parts are, the true inertia is higher by about the ratio of the override’s mass to the parts’ (5 times for a 2 kg override on 0.40 kg of parts), and more if it sits farther out (A stage’s rule).
A few more cases are still refused. One is a ticked override on a stage that carries boosters. Another is an unticked mass override on a stage whose parts weigh nothing, with no unticked center override beside it. The third is a flight that moves a mass, releases one, or parts through a stage with an added mass. A stage’s mass and center of gravity overrides lists each.
What it leaves out
- The launch conditions in your file. Give them as options, above.
- Real weather, unless you pass
--weather. By default it flies one wind at every height in the standard atmosphere.--weather FILEflies the profilehpr weatherwrites. - A fall with no parachute open. The landing is then marked “not a prediction” (the landing).
- A verdict. The simulator prints estimates. Whether a rocket is fit to fly is for you, the motor’s printed data and your range safety officer to decide.
Pick a motor
Shortlist the motors that fit your rocket, fly it on each one, and choose an ejection delay, all
with hpr on the command line.
This guide shortlists the motors that fit a rocket, flies it on each, and picks an ejection
delay, all with hpr on the command line. It’s for a flier choosing a motor for a design they
already have.
The steps:
- List the motors that fit.
- Fly the rocket on each.
- Compare them.
- Choose the delay.
- Put the choice in your design.
The examples use the guides’ own rocket,
level-1.ork,
with a 38 mm motor mount. Fly your .ork introduces it.
List the motors that fit
Start from the mount’s diameter: a motor’s case must match it. In OpenRocket, the motor mount
tube’s inner diameter is the size. A 38 mm mount takes 38 mm motors. hpr motors list filters
the 1,004 motors built into the simulator by diameter, impulse class or maker. Here, Loki’s 38 mm
H motors:
$ hpr motors list --diameter 38 --class H --manufacturer Loki
6 motors from ThrustCurve.org's solid motor catalog: every solid motor's record and every data file but a restricted one, captured 2026-10-28; size and delays from each motor's default file's header, the rest from its curve, or from ThrustCurve.org's record where no file of it is bundled.
designation maker class dia mm (in) len mm (in) impulse N·s avg N burn s delays
H100-SF Loki H 38 (1.50) 178 (7.0) 200.9 104.4 1.92 5-8-10-13-17
H90-LR Loki H 38 (1.50) 178 (7.0) 237.1 93.4 2.54 5-8-10-14
H144-LW Loki H 38 (1.50) 178 (7.0) 239.2 153.3 1.56 5-8-10-13-17
H125-CT Loki H 38 (1.50) 177.8 (7.0) 241.7 125.0 1.93 8-18
H160-LB Loki H 38 (1.50) 178 (7.0) 255.4 177.8 1.44 7-9-12-15
H500-LW Loki H 38 (1.50) 292 (11.5) 319.8 517.5 0.62 5-7-9-12-15
The figures are worked out from each motor’s default ThrustCurve.org curve file, the curve
the simulator flies (The bundled motors). The delays column
lists the ejection delays as the file’s header writes them, in seconds after burnout. A - separates
the settings: 5-9-13 is 5, 9 and 13 s, and 8-18 is 8 and 18 s. The header can list fewer delays
than the maker sells, so check the motor’s instructions. P (or 1000) is a plugged motor with no
ejection charge.
A Level 1 certification flight uses an H or I motor (NAR and Tripoli’s Level 1 rules; Check stability for a certification flight quotes them).
Every solid motor ThrustCurve.org listed on October 28, 2026 is built in, such as
--motor H128W, and the 924 with a curve file fly; the 80 with none are listed but can’t. Most
of the 924 (685) fly with a warning: their curve file’s total impulse, average thrust or burn time
is more than 1% off ThrustCurve.org’s own figures for the motor
(the whole catalog). Check such a motor against its maker’s
data. A name several makers use, such as G80, is refused with a name for each motor
(A name several makers share). A newer motor’s curve is fetched once online and kept
(Fetch a motor the simulator doesn’t have).
hpr motors search lists what vendors have in stock and at what price
(Motors you can buy). hpr motors show gives one motor’s figures as
the simulator reads its curve:
$ hpr motors show I175WS
I175WS (AeroTech), from the bundled catalog
impulse class I (320.01–640 N·s)
total impulse 333.2 N·s
average thrust 177.5 N measured; 175 N nominal, as the designation names it
peak thrust 252.6 N
burn time 1.88 s, from 0.023 s to 1.900 s (NFPA 1125, 5% of peak)
propellant WS, the maker's code for Super White Lightning, as ThrustCurve.org names it
propellant mass 168.0 g (5.9 oz) of 348.0 g (12.3 oz) loaded
casing 38 mm (1.50 in) across, 214 mm (8.4 in) long
delays 5 s, 9 s, 13 s
curve file https://www.thrustcurve.org/simfiles/5f4294d20002e900000008bf/ (flown)
RASP (.eng), from a certification test, public domain
passes the 1% check: total impulse +0.05%, average thrust +0.57%, burn time -0.66%
curve file https://www.thrustcurve.org/simfiles/5f9245ad1bca580004171795/
RockSim (.rse), from a user, public domain
passes the 1% check: total impulse +0.05%, average thrust +0.57%, burn time -0.66%
How far to trust it. Copied from ThrustCurve.org's curve file, downloaded 2026-10-28, not measured
by HPR Sim: the size, masses and delays from the file's header, the impulse, thrusts and burn time
from its curve, which can differ from the maker's rated figures. Each file is checked against
ThrustCurve.org's figures and OpenRocket's reading of its impulse and peak thrust, not against the
maker's data: checks of the file, not of the motor. The motor's printed data and its maker's
instructions come first, and the RSO decides.
More: https://hpr.fusionspace.co/pick-a-motor.html
Fly the rocket on each
--motor flies the design with another motor in its mount, and --delay sets that motor’s
ejection delay. Without --delay, the motor fires no charge. A parachute set to open on the
charge, as the guide rocket’s is, then never opens. Give one of the motor’s delays, in seconds, or
P for a plugged motor when your electronics fire the charges. This flies the guide rocket on a
Loki H125, with a 10 s delay:
$ hpr sim validation/fixtures/ork/guides/level-1.ork --motor H125-CT --delay 10
Level 1 guide rocket (level-1.ork)
configuration 1 of 2: [H170M-10] with --motor H125-CT --delay 10
help: --config flies the others, by number or name: 2 [I175WS-9]
a simulated flight, not a measurement
static margin 1.59 calibers off the rail; least 1.59 calibers, at 0.17 s, before apogee
CG and CP 0.818 m (32.2 in) and 0.923 m (36.3 in) aft of the nose tip, off the rail
apogee 914.5 m (3000 ft) above the site at 11.42 s
rail exit speed 25.9 m/s (85 ft/s)
delay apogee 9.42 s after burnout, with the charges held; the motor's set delay: 10 s; its charge fires 0.58 s after apogee; the delay may fire 2.0 s short or long (NFPA 1125): climbing at 14.1 m/s (46 ft/s) to 2.58 s after apogee (no speed: falling with nothing open, a fall HPR Sim doesn't predict)
descent 4.7 m/s (15 ft/s) at landing under `Parachute`
motor: 1 × H125-CT (from the bundled catalog, as of 2026-10-28) in `Motor mount tube`, lit at launch
recovery: `Parachute` at the ejection charge, 0.520 m² of drag area, opened at 12.00 s
launched at 0.00000° N, 0.00000° E, 0 m (0 ft) above sea level, from 1.5 m (4.9 ft) of vertical rail above its aft end, in calm air
note: the file's 1 recovery device flies as OpenRocket flies it. Each opens fully at its event, with the file's drag coefficient or OpenRocket's own. Once one opens, the rocket descends as a point under the open devices' drag alone
warning: drag: issue #18: skin friction is taken as fully turbulent; on a smooth surface a laminar run near the nose lowers it, by 3.6% on RocketPy's Calisto at Mach 0.3. If this surface is that smooth, the apogee, top speed and drift read low, and the flutter margin and largest dynamic pressure look better than they are
warning: stability: issue #172: the static margin read up to 0.1108 calibers above OpenRocket's on four private designs, cause unknown; this flight's may read high by as much
warning: stability: issue #1290: on one of two wind-tunnel models, the center of pressure sat 0.11 to 0.92 calibers aft of the tunnel's at Mach 0.6 and 0.8, as the report's curve reads; fitted over −3° to 4°, about 0.08 at 0.8. So from Mach 0.6 the flight margin may read high. This flight reaches Mach 0.64 at 1.6 s
help: issues: https://github.com/nrdptel/fusionspace-eridanus/issues/<number>
event time height speed
liftoff 0.02 s 0.4 m (1 ft) 0.0 m/s (0 ft/s)
rail exit 0.17 s 1.9 m (6 ft) 25.9 m/s (85 ft/s)
burnout 2.00 s 303.8 m (997 ft) 201.2 m/s (660 ft/s)
apogee 11.42 s 914.5 m (3000 ft) 0.1 m/s (0 ft/s)
charge 12.00 s 912.8 m (2995 ft) 5.6 m/s (18 ft/s)
deployment 12.00 s 912.8 m (2995 ft) 5.6 m/s (18 ft/s), airspeed 5.6 m/s (18 ft/s)
ground hit 202.71 s 0.0 m (0 ft) 4.7 m/s (15 ft/s)
(heights are the center of gravity's above the site; speeds are over the ground, and a deployment's
airspeed through the air)
top speed 217.0 m/s (712 ft/s) at 1.56 s
top Mach number 0.639
landing 0.7 m (2 ft) from the pad at 202.71 s, at 4.7 m/s (15 ft/s)
How far to trust it. Simulated from the design file, not measured. Against 60 logged flights of
fliers' own designs, the simulated apogee averaged 8.0% above the logged one. HPR Sim flew each in
its day's air from ERA5, a weather reanalysis, and each logged apogee is the height climbed in it.
The simulated apogee was within 10% on 31 and read low on 15, by at most 20%. This flight was flown
in the standard atmosphere. On a day warmer than it at the site, the rocket can climb higher than
this apogee; --weather flies the day's air. Plan a waiver or a field's ceiling with room above this
apogee; the altimeter's reading is the one to log, and the RSO decides.
More: https://hpr.fusionspace.co/accuracy.html
And on a harder-hitting I motor, a Loki I377, with the same delay:
$ hpr sim validation/fixtures/ork/guides/level-1.ork --motor I377-CT --delay 10
Level 1 guide rocket (level-1.ork)
configuration 1 of 2: [H170M-10] with --motor I377-CT --delay 10
help: --config flies the others, by number or name: 2 [I175WS-9]
a simulated flight, not a measurement
static margin 1.18 calibers off the rail; least 1.18 calibers, at 0.08 s, before apogee
CG and CP 0.845 m (33.3 in) and 0.923 m (36.3 in) aft of the nose tip, off the rail
apogee 1320.4 m (4332 ft) above the site at 12.02 s
rail exit speed 42.3 m/s (139 ft/s)
delay apogee 11.02 s after burnout, with the charges held; the motor's set delay: 10 s; its charge fires 1.02 s before apogee; the delay may fire 2.0 s short or long (NFPA 1125): climbing at 30.8 m/s (101 ft/s) to falling at 9.5 m/s (31 ft/s)
descent 5.0 m/s (16 ft/s) at landing under `Parachute`
motor: 1 × I377-CT (from the bundled catalog, as of 2026-10-28) in `Motor mount tube`, lit at launch
recovery: `Parachute` at the ejection charge, 0.520 m² of drag area, opened at 11.43 s
launched at 0.00000° N, 0.00000° E, 0 m (0 ft) above sea level, from 1.5 m (4.9 ft) of vertical rail above its aft end, in calm air
note: the file's 1 recovery device flies as OpenRocket flies it. Each opens fully at its event, with the file's drag coefficient or OpenRocket's own. Once one opens, the rocket descends as a point under the open devices' drag alone
warning: design checks: the motor in `Motor mount tube` reaches 22.0 mm past the mount's forward end (configuration [H170M-10] with --motor I377-CT --delay 10). The mass, CG and margin are for the motor as drawn: where a ring or bulkhead closes the mount there, the real case sits that much further aft. At ignition the static margin is 1.12 calibers as drawn, and 0.94 with the case 22.0 mm further aft
warning: drag: issue #67: a cone-like nose's or shoulder's pressure drag reads high from Mach 0.8 (about twice a measured cone's at Mach 0.85, still +15% at 1.5). So the apogee, top speed and drift read low, and the flutter margin and largest dynamic pressure look better than they are. This flight reaches Mach 1.10 at 1.1 s
warning: drag: issue #68: base drag reads high from Mach 0.8 to 1.2 (0.225 against a measured 0.156 at Mach 0.9). So the apogee, top speed and drift read low, and the flutter margin and largest dynamic pressure look better than they are. This flight reaches Mach 1.10 at 1.1 s
warning: drag: issue #222: supersonic pressure drag on an ogive nose or airfoil fins is about twice OpenRocket's, and which is right is unresolved. If HPR Sim's drag is high, the apogee, top speed and drift read low, and the flutter margin and largest dynamic pressure look better than they are. This flight reaches Mach 1.10 at 1.1 s
warning: drag: issue #18: skin friction is taken as fully turbulent; on a smooth surface a laminar run near the nose lowers it, by 3.6% on RocketPy's Calisto at Mach 0.3. If this surface is that smooth, the apogee, top speed and drift read low, and the flutter margin and largest dynamic pressure look better than they are
warning: stability: issue #172: the static margin read up to 0.1108 calibers above OpenRocket's on four private designs, cause unknown; this flight's may read high by as much
warning: stability: issue #1290: on one of two wind-tunnel models, the center of pressure sat 0.11 to 0.92 calibers aft of the tunnel's at Mach 0.6 and 0.8, as the report's curve reads; fitted over −3° to 4°, about 0.08 at 0.8. So from Mach 0.6 the flight margin may read high. This flight reaches Mach 1.10 at 1.1 s
warning: stability: issue #1198: the center of pressure sat 0.67 to 1.35 calibers aft of a wind tunnel's on two models at Mach 0.9, so past Mach 0.8 the flight margin may read high. This flight reaches Mach 1.10 at 1.1 s
help: issues: https://github.com/nrdptel/fusionspace-eridanus/issues/<number>
event time height speed
liftoff 0.00 s 0.3 m (1 ft) 0.0 m/s (0 ft/s)
rail exit 0.08 s 1.8 m (6 ft) 42.3 m/s (139 ft/s)
burnout 1.43 s 384.0 m (1260 ft) 335.1 m/s (1099 ft/s)
charge 11.43 s 1318.2 m (4325 ft) 10.1 m/s (33 ft/s)
deployment 11.43 s 1318.2 m (4325 ft) 10.1 m/s (33 ft/s), airspeed 10.1 m/s (33 ft/s)
apogee 12.02 s 1320.4 m (4332 ft) 0.0 m/s (0 ft/s)
ground hit 269.86 s 0.0 m (0 ft) 5.0 m/s (16 ft/s)
(heights are the center of gravity's above the site; speeds are over the ground, and a deployment's
airspeed through the air)
top speed 371.7 m/s (1219 ft/s) at 1.08 s
top Mach number 1.095
landing 0.8 m (3 ft) from the pad at 269.86 s, at 5.0 m/s (16 ft/s)
How far to trust it. Simulated from the design file, not measured. Against 60 logged flights of
fliers' own designs, the simulated apogee averaged 8.0% above the logged one. HPR Sim flew each in
its day's air from ERA5, a weather reanalysis, and each logged apogee is the height climbed in it.
The simulated apogee was within 10% on 31 and read low on 15, by at most 20%. This flight was flown
in the standard atmosphere. On a day warmer than it at the site, the rocket can climb higher than
this apogee; --weather flies the day's air. Plan a waiver or a field's ceiling with room above this
apogee; the altimeter's reading is the one to log, and the RSO decides.
More: https://hpr.fusionspace.co/accuracy.html
The warning says the I377’s case reaches 22.0 mm (0.87 in) past the mount tube’s forward end.
The 292 mm (11.5 in) case sits 10 mm (0.39 in) out of the back of the rocket’s 260 mm (10 in)
mount tube. The simulator flies it as drawn. If a ring or bulkhead closes the mount’s forward
end, the real case stops there and sits 22.0 mm (0.87 in) further aft. The warning gives the static
margin at ignition both ways, as drawn and moved aft. Moving the case aft moves the center of
gravity aft, so the second figure, 0.94 calibers, is the lower one. The simulator flies the first.
Whether the case fits the real rocket is for you to check.
--motor replaces the motor of the configuration flown. --config picks which of the file’s
configurations it goes in, and --mount picks which mount, if the design has several.
Compare them
Read the same lines for each motor: margin, apogee, rail exit speed, delay and descent. Between the two flights above:
- The I377 climbs higher. If your field has a ceiling, its waiver sets it, not the simulator.
- The I377 leaves the rail much faster. The safety codes ask for a speed that ensures a stable flight but give no number. Competitions set their own, such as 25 m/s (82 ft/s) for the Spaceport America Cup (Rail exit speed quotes them).
- The stability margin changes with the motor. A motor’s mass sits behind the center of gravity. So a heavier motor moves the center of gravity aft, toward the center of pressure, and shrinks the margin. Check it with every motor you might fly (Check stability for a certification flight).
- The I377 takes the rocket past the speed of sound, Mach 1. The H125 stays well below it, and the H170M, at Mach 0.842, barely enters the range from Mach 0.8 to 1.2. In that range, HPR Sim’s center of pressure is up to 2.36 calibers behind NASA’s wind-tunnel data (Known gaps). So its margin there reads high, and published guidance asks for a larger margin (Compare with published guidance).
To fly a few more motors, change --motor and --delay and run it again. --json prints each
flight as data, for a script that tabulates many.
Choose the delay
The delay line’s first figure is the coast, from burnout to apogee, with the charges held. A
delay near it fires the charge near apogee, where the rocket moves slowest. The coast is taken
from the same flight flown with no charge firing. A charge that fires early opens the parachute
while the rocket climbs, and the coast would come out short. A delay that is too short would then
look nearly right. So the delay line’s apogee can come later than the apogee line’s, which is
the flight as flown. The gap is the climb an early parachute cost. The second figure is the delay
you gave, and the third says how far from the held apogee the charge fires. In the events table,
the charge row gives the speed at that moment. The further the charge is from apogee, the faster
the rocket moves when the parachute comes out.
The last figure is how far the delay may fire from its label. Then come the speeds at its short end and its long end. NFPA 1125, the code commercial motors are certified to, lets a delay miss its label by 1.5 s or 20%, whichever is greater, up to 3 s (Choosing the numbers). The limit holds for a motor type’s certification firings. It doesn’t bound every motor, nor a delay drilled to a time no label gives. The band’s speeds are vertical, up or down; the events table’s are the total speed.
An end gets no speed where the flight with the charges held stops matching the one a charge meets. That happens more than 1 s past apogee, where it falls tail first with nothing open, a fall the simulator doesn’t predict. It also happens after another parachute or streamer opens, such as a drogue at apogee. The line says which. Pick a delay whose two ends both suit your recovery. Compare the climb at the short end and the fall at the long end with your parachute’s and harness’s ratings.
In the H125 flight above, the coast is 9.42 s, and the 10 s delay fires the charge 0.58 s after apogee. A delay 2.0 s short fires it climbing at 14.1 m/s (46 ft/s). One 2.0 s long fires it 2.58 s after apogee, in the fall the simulator gives no speed for. The H125 comes in delays of 8, 10, 12, 14 and 18 s, more than its file’s header lists, so 10 s is the nearest. The simulator flies any delay you give. Give one the maker sells, or one your motor’s delay can be adjusted to.
A delay is a burning fuse, and real ones vary from motor to motor. The simulator flies the stated
time exactly. The band on the delay line shows what the code’s tolerance means for your rocket.
Monte Carlo dispersion, in the library, can scatter the delay.
The guide rocket’s own second configuration, [I175WS-9], is an example where the set delay
fires before apogee:
$ hpr sim validation/fixtures/ork/guides/level-1.ork --config 2
Level 1 guide rocket (level-1.ork)
configuration 2 of 2: [I175WS-9]
help: --config flies the others, by number or name: 1 [H170M-10]
a simulated flight, not a measurement
static margin 1.67 calibers off the rail; least 1.67 calibers, at 0.14 s, before apogee
CG and CP 0.813 m (32.0 in) and 0.923 m (36.3 in) aft of the nose tip, off the rail
apogee 1100.7 m (3611 ft) above the site at 11.48 s
rail exit speed 28.9 m/s (95 ft/s)
delay apogee 9.82 s after burnout, with the charges held; the motor's set delay: 9 s; its charge fires 0.82 s before apogee; the delay may fire 1.8 s short or long (NFPA 1125): climbing at 26.6 m/s (87 ft/s) to falling at 9.5 m/s (31 ft/s)
descent 4.5 m/s (15 ft/s) at landing under `Parachute`
motor: 1 × I175WS (from the bundled catalog, as of 2026-10-28) in `Motor mount tube`, lit at launch
recovery: `Parachute` at the ejection charge, 0.520 m² of drag area, opened at 10.97 s
launched at 0.00000° N, 0.00000° E, 0 m (0 ft) above sea level, from 1.5 m (4.9 ft) of vertical rail above its aft end, in calm air
note: the file's 1 recovery device flies as OpenRocket flies it. Each opens fully at its event, with the file's drag coefficient or OpenRocket's own. Once one opens, the rocket descends as a point under the open devices' drag alone
warning: drag: issue #67: a cone-like nose's or shoulder's pressure drag reads high from Mach 0.8 (about twice a measured cone's at Mach 0.85, still +15% at 1.5). So the apogee, top speed and drift read low, and the flutter margin and largest dynamic pressure look better than they are. This flight reaches Mach 0.83 at 1.8 s
warning: drag: issue #68: base drag reads high from Mach 0.8 to 1.2 (0.225 against a measured 0.156 at Mach 0.9). So the apogee, top speed and drift read low, and the flutter margin and largest dynamic pressure look better than they are. This flight reaches Mach 0.83 at 1.8 s
warning: drag: issue #18: skin friction is taken as fully turbulent; on a smooth surface a laminar run near the nose lowers it, by 3.6% on RocketPy's Calisto at Mach 0.3. If this surface is that smooth, the apogee, top speed and drift read low, and the flutter margin and largest dynamic pressure look better than they are
warning: stability: issue #172: the static margin read up to 0.1108 calibers above OpenRocket's on four private designs, cause unknown; this flight's may read high by as much
warning: stability: issue #1290: on one of two wind-tunnel models, the center of pressure sat 0.11 to 0.92 calibers aft of the tunnel's at Mach 0.6 and 0.8, as the report's curve reads; fitted over −3° to 4°, about 0.08 at 0.8. So from Mach 0.6 the flight margin may read high. This flight reaches Mach 0.83 at 1.8 s
warning: stability: issue #1198: the center of pressure sat 0.67 to 1.35 calibers aft of a wind tunnel's on two models at Mach 0.9, so past Mach 0.8 the flight margin may read high. This flight reaches Mach 0.83 at 1.8 s
help: issues: https://github.com/nrdptel/fusionspace-eridanus/issues/<number>
event time height speed
liftoff 0.02 s 0.4 m (1 ft) 0.0 m/s (0 ft/s)
rail exit 0.14 s 1.9 m (6 ft) 28.9 m/s (95 ft/s)
burnout 1.97 s 385.2 m (1264 ft) 260.5 m/s (855 ft/s)
charge 10.97 s 1099.1 m (3606 ft) 8.0 m/s (26 ft/s)
deployment 10.97 s 1099.1 m (3606 ft) 8.0 m/s (26 ft/s), airspeed 8.0 m/s (26 ft/s)
apogee 11.48 s 1100.7 m (3611 ft) 0.0 m/s (0 ft/s)
ground hit 247.48 s 0.0 m (0 ft) 4.5 m/s (15 ft/s)
(heights are the center of gravity's above the site; speeds are over the ground, and a deployment's
airspeed through the air)
top speed 281.3 m/s (923 ft/s) at 1.75 s
top Mach number 0.830
landing 0.7 m (2 ft) from the pad at 247.48 s, at 4.5 m/s (15 ft/s)
How far to trust it. Simulated from the design file, not measured. Against 60 logged flights of
fliers' own designs, the simulated apogee averaged 8.0% above the logged one. HPR Sim flew each in
its day's air from ERA5, a weather reanalysis, and each logged apogee is the height climbed in it.
The simulated apogee was within 10% on 31 and read low on 15, by at most 20%. This flight was flown
in the standard atmosphere. On a day warmer than it at the site, the rocket can climb higher than
this apogee; --weather flies the day's air. Plan a waiver or a field's ceiling with room above this
apogee; the altimeter's reading is the one to log, and the RSO decides.
More: https://hpr.fusionspace.co/accuracy.html
Put the choice in your design
The simulator doesn’t change your .ork file: set the motor and its delay in OpenRocket, save,
and fly the file again. Without --motor, hpr sim flies the motors and delays the file holds,
as Fly your .ork shows. hpr sim’s delay line checks the delay you set.
What it leaves out
- Each motor flies one thrust curve, ThrustCurve.org’s, and its stated delay exactly. Real motors differ a little from their published curves.
- The simulator’s design checks flag a motor wider than its mount. They warn on one longer than its tube, or that runs into an engine block, thrust ring or bulkhead the design draws inside the mount. They don’t know a retainer or closure the design doesn’t draw.
- A motor named with
--motornarrower than its mount flies with no adapter. A note says so when it is more than 5% narrower; the adapter’s mass is left out. A motor the file holds gets none. - The simulator gives no verdict: it ranks nothing as safe or unsafe. The motor’s printed data, the safety codes and your range safety officer decide.
Check stability for a certification flight
Read HPR Sim’s stability margin for a certification flight with every motor you might use, and see where it can read high.
This guide reads HPR Sim’s stability numbers for a rocket you plan to fly for a certification. It checks them with every motor you might use, and says how far to trust them. It’s for a flier preparing a certification flight, and the rules it quotes are Level 1’s. HPR Sim gives no verdict. The safety codes ask you to check stability, and the range safety officer (RSO) and your certifying member decide.
HPR Sim’s margin at rod clearance agrees with OpenRocket 24.12’s to within 0.016 calibers on 41 of OpenRocket’s 53 example flights. But no margin of HPR
Sim’s has been checked against a measured rocket. On OpenRocket’s two pod examples it reads 0.07 calibers above OpenRocket’s. Near the speed of sound HPR Sim’s flight margin also reads high
(accuracy of the margin). The outputs on this page are made by running
each command, and CI checks that they still match what hpr prints.
The steps:
What the rules ask
The safety codes require a stability check, but name no margin. The words below are the organizations’ own, read on October 4, 2026. Check their current pages before your flight. This is not legal or regulatory advice.
- The NAR’s High Power Rocket Safety Code is quoted from its revision of August 2012. It says: “I will check the stability of my rocket before flight and will not fly it if it cannot be determined to be stable.”
- Tripoli’s Unified Safety Code is quoted from version 2, effective January 2026. In 7-1.2 it says: “Stability; the flier shall document the location of the center of pressure and be able to demonstrate the center of gravity.”
- A Level 1 flight uses an H or I motor. The NAR’s Level 1 procedures (revision of January 1, 2022) say “at least one H or I impulse class motor”. Tripoli’s say “a single certified H or I motor”. Neither page states a margin.
In the NAR’s procedures, the candidate may be asked about “the model’s center of gravity and
center of pressure, methods used to determine model stability”. The output of hpr sim gives both
points, as the rocket leaves the rail, and their separation. --json and --export give more.
Read the margin
The static margin line is the distance from the center of gravity back to the center of
pressure, in body diameters (calibers). It gives that first as the rocket leaves the rail, then as
its least value up to apogee. A positive margin turns the nose back into the oncoming air when
the rocket is disturbed (stability margin). This flies the guides’ own rocket,
level-1.ork,
on its default motor, an AeroTech H170M:
$ hpr sim validation/fixtures/ork/guides/level-1.ork
Level 1 guide rocket (level-1.ork)
configuration 1 of 2: [H170M-10]
help: --config flies the others, by number or name: 2 [I175WS-9]
a simulated flight, not a measurement
static margin 1.70 calibers off the rail; least 1.70 calibers, at 0.12 s, before apogee
CG and CP 0.811 m (31.9 in) and 0.923 m (36.3 in) aft of the nose tip, off the rail
apogee 1065.1 m (3494 ft) above the site at 11.62 s
rail exit speed 26.3 m/s (86 ft/s)
delay apogee 9.48 s after burnout, with the charges held; the motor's set delay: 10 s; its charge fires 0.52 s after apogee; the delay may fire 2.0 s short or long (NFPA 1125): climbing at 14.7 m/s (48 ft/s) to 2.52 s after apogee (no speed: falling with nothing open, a fall HPR Sim doesn't predict)
descent 4.4 m/s (15 ft/s) at landing under `Parachute`
motor: 1 × H170M (from the bundled catalog, as of 2026-10-28) in `Motor mount tube`, lit at launch
recovery: `Parachute` at the ejection charge, 0.520 m² of drag area, opened at 12.14 s
launched at 0.00000° N, 0.00000° E, 0 m (0 ft) above sea level, from 1.5 m (4.9 ft) of vertical rail above its aft end, in calm air
note: the file's 1 recovery device flies as OpenRocket flies it. Each opens fully at its event, with the file's drag coefficient or OpenRocket's own. Once one opens, the rocket descends as a point under the open devices' drag alone
warning: drag: issue #67: a cone-like nose's or shoulder's pressure drag reads high from Mach 0.8 (about twice a measured cone's at Mach 0.85, still +15% at 1.5). So the apogee, top speed and drift read low, and the flutter margin and largest dynamic pressure look better than they are. This flight reaches Mach 0.84 at 1.7 s
warning: drag: issue #68: base drag reads high from Mach 0.8 to 1.2 (0.225 against a measured 0.156 at Mach 0.9). So the apogee, top speed and drift read low, and the flutter margin and largest dynamic pressure look better than they are. This flight reaches Mach 0.84 at 1.7 s
warning: drag: issue #18: skin friction is taken as fully turbulent; on a smooth surface a laminar run near the nose lowers it, by 3.6% on RocketPy's Calisto at Mach 0.3. If this surface is that smooth, the apogee, top speed and drift read low, and the flutter margin and largest dynamic pressure look better than they are
warning: stability: issue #172: the static margin read up to 0.1108 calibers above OpenRocket's on four private designs, cause unknown; this flight's may read high by as much
warning: stability: issue #1290: on one of two wind-tunnel models, the center of pressure sat 0.11 to 0.92 calibers aft of the tunnel's at Mach 0.6 and 0.8, as the report's curve reads; fitted over −3° to 4°, about 0.08 at 0.8. So from Mach 0.6 the flight margin may read high. This flight reaches Mach 0.84 at 1.7 s
warning: stability: issue #1198: the center of pressure sat 0.67 to 1.35 calibers aft of a wind tunnel's on two models at Mach 0.9, so past Mach 0.8 the flight margin may read high. This flight reaches Mach 0.84 at 1.7 s
help: issues: https://github.com/nrdptel/fusionspace-eridanus/issues/<number>
event time height speed
liftoff 0.00 s 0.4 m (1 ft) 0.0 m/s (0 ft/s)
rail exit 0.12 s 1.9 m (6 ft) 26.3 m/s (86 ft/s)
burnout 2.14 s 406.4 m (1333 ft) 240.4 m/s (789 ft/s)
apogee 11.62 s 1065.1 m (3494 ft) 0.1 m/s (0 ft/s)
charge 12.14 s 1063.7 m (3490 ft) 5.1 m/s (17 ft/s)
deployment 12.14 s 1063.7 m (3490 ft) 5.1 m/s (17 ft/s), airspeed 5.1 m/s (17 ft/s)
ground hit 245.78 s 0.0 m (0 ft) 4.4 m/s (15 ft/s)
(heights are the center of gravity's above the site; speeds are over the ground, and a deployment's
airspeed through the air)
top speed 285.6 m/s (937 ft/s) at 1.73 s
top Mach number 0.842
landing 0.7 m (2 ft) from the pad at 245.78 s, at 4.4 m/s (15 ft/s)
How far to trust it. Simulated from the design file, not measured. Against 60 logged flights of
fliers' own designs, the simulated apogee averaged 8.0% above the logged one. HPR Sim flew each in
its day's air from ERA5, a weather reanalysis, and each logged apogee is the height climbed in it.
The simulated apogee was within 10% on 31 and read low on 15, by at most 20%. This flight was flown
in the standard atmosphere. On a day warmer than it at the site, the rocket can climb higher than
this apogee; --weather flies the day's air. Plan a waiver or a field's ceiling with room above this
apogee; the altimeter's reading is the one to log, and the RSO decides.
More: https://hpr.fusionspace.co/accuracy.html
A caliber here is the rocket’s widest body diameter, 66 mm (2.6 in). So a margin of 1.70 calibers
puts the center of pressure 1.70 × 66 mm ≈ 112 mm (4.4 in) behind the center of gravity. The
CG and CP line gives the two points it came from, measured from the nose tip in meters and
inches. They’re 0.811 m (31.9 in) and 0.923 m (36.3 in), 112 mm (4.4 in) apart.
Both points are the stations as the rocket leaves the rail, 0.12 s into the burn here, not on the pad. Some propellant has burned by then, so this center of gravity is a little forward of where the loaded rocket balances on the pad. So the margin on the pad is a little smaller than the one printed. Balance the loaded rocket, motor in, and compare where it balances with the line’s center of gravity before trusting the margin. Each millimeter the balance point sits aft of it takes a millimeter off the distance to the center of pressure.
The simulator computes the static margin at Mach 0, with the air along the rocket’s axis. The
margin grows as propellant burns and the center of gravity moves forward. So its least value in
flight is usually the one at the rail. --json also gives the flight margin, at the flight’s own
Mach number (min_flight_margin_cal), and where each least value falls
(Flight metrics).
Check every motor you might fly
The margin depends on the motor, so check each one you might fly, with its delay. A motor’s mass sits behind the center of gravity, so a heavier motor moves the center of gravity aft and shrinks the margin. The guide rocket’s second configuration flies an I175WS:
$ hpr sim validation/fixtures/ork/guides/level-1.ork --config 2
Level 1 guide rocket (level-1.ork)
configuration 2 of 2: [I175WS-9]
help: --config flies the others, by number or name: 1 [H170M-10]
a simulated flight, not a measurement
static margin 1.67 calibers off the rail; least 1.67 calibers, at 0.14 s, before apogee
CG and CP 0.813 m (32.0 in) and 0.923 m (36.3 in) aft of the nose tip, off the rail
apogee 1100.7 m (3611 ft) above the site at 11.48 s
rail exit speed 28.9 m/s (95 ft/s)
delay apogee 9.82 s after burnout, with the charges held; the motor's set delay: 9 s; its charge fires 0.82 s before apogee; the delay may fire 1.8 s short or long (NFPA 1125): climbing at 26.6 m/s (87 ft/s) to falling at 9.5 m/s (31 ft/s)
descent 4.5 m/s (15 ft/s) at landing under `Parachute`
motor: 1 × I175WS (from the bundled catalog, as of 2026-10-28) in `Motor mount tube`, lit at launch
recovery: `Parachute` at the ejection charge, 0.520 m² of drag area, opened at 10.97 s
launched at 0.00000° N, 0.00000° E, 0 m (0 ft) above sea level, from 1.5 m (4.9 ft) of vertical rail above its aft end, in calm air
note: the file's 1 recovery device flies as OpenRocket flies it. Each opens fully at its event, with the file's drag coefficient or OpenRocket's own. Once one opens, the rocket descends as a point under the open devices' drag alone
warning: drag: issue #67: a cone-like nose's or shoulder's pressure drag reads high from Mach 0.8 (about twice a measured cone's at Mach 0.85, still +15% at 1.5). So the apogee, top speed and drift read low, and the flutter margin and largest dynamic pressure look better than they are. This flight reaches Mach 0.83 at 1.8 s
warning: drag: issue #68: base drag reads high from Mach 0.8 to 1.2 (0.225 against a measured 0.156 at Mach 0.9). So the apogee, top speed and drift read low, and the flutter margin and largest dynamic pressure look better than they are. This flight reaches Mach 0.83 at 1.8 s
warning: drag: issue #18: skin friction is taken as fully turbulent; on a smooth surface a laminar run near the nose lowers it, by 3.6% on RocketPy's Calisto at Mach 0.3. If this surface is that smooth, the apogee, top speed and drift read low, and the flutter margin and largest dynamic pressure look better than they are
warning: stability: issue #172: the static margin read up to 0.1108 calibers above OpenRocket's on four private designs, cause unknown; this flight's may read high by as much
warning: stability: issue #1290: on one of two wind-tunnel models, the center of pressure sat 0.11 to 0.92 calibers aft of the tunnel's at Mach 0.6 and 0.8, as the report's curve reads; fitted over −3° to 4°, about 0.08 at 0.8. So from Mach 0.6 the flight margin may read high. This flight reaches Mach 0.83 at 1.8 s
warning: stability: issue #1198: the center of pressure sat 0.67 to 1.35 calibers aft of a wind tunnel's on two models at Mach 0.9, so past Mach 0.8 the flight margin may read high. This flight reaches Mach 0.83 at 1.8 s
help: issues: https://github.com/nrdptel/fusionspace-eridanus/issues/<number>
event time height speed
liftoff 0.02 s 0.4 m (1 ft) 0.0 m/s (0 ft/s)
rail exit 0.14 s 1.9 m (6 ft) 28.9 m/s (95 ft/s)
burnout 1.97 s 385.2 m (1264 ft) 260.5 m/s (855 ft/s)
charge 10.97 s 1099.1 m (3606 ft) 8.0 m/s (26 ft/s)
deployment 10.97 s 1099.1 m (3606 ft) 8.0 m/s (26 ft/s), airspeed 8.0 m/s (26 ft/s)
apogee 11.48 s 1100.7 m (3611 ft) 0.0 m/s (0 ft/s)
ground hit 247.48 s 0.0 m (0 ft) 4.5 m/s (15 ft/s)
(heights are the center of gravity's above the site; speeds are over the ground, and a deployment's
airspeed through the air)
top speed 281.3 m/s (923 ft/s) at 1.75 s
top Mach number 0.830
landing 0.7 m (2 ft) from the pad at 247.48 s, at 4.5 m/s (15 ft/s)
How far to trust it. Simulated from the design file, not measured. Against 60 logged flights of
fliers' own designs, the simulated apogee averaged 8.0% above the logged one. HPR Sim flew each in
its day's air from ERA5, a weather reanalysis, and each logged apogee is the height climbed in it.
The simulated apogee was within 10% on 31 and read low on 15, by at most 20%. This flight was flown
in the standard atmosphere. On a day warmer than it at the site, the rocket can climb higher than
this apogee; --weather flies the day's air. Plan a waiver or a field's ceiling with room above this
apogee; the altimeter's reading is the one to log, and the RSO decides.
More: https://hpr.fusionspace.co/accuracy.html
--motor flies any other motor in the mount, and --delay sets its ejection delay
(Pick a motor). There, the heaviest motor tried, a Loki
I377, leaves the guide rocket the smallest margin of the motors flown. It also takes the rocket
past Mach 1, where the guidance below asks for more.
Compare with published guidance
Published rules of thumb set a lower bound of one caliber, and more for fast flights. These are the sources’ guidance, not the simulator’s judgment.
- James Barrowman devised the standard way to find the center of pressure. He wrote: “A good rule of thumb is to have the static margin equal to the largest diameter of the rocket”. He also wrote: “Remember that one maximum body diameter is the smallest safe static margin”. Both are in Stability of a Model Rocket in Flight, Centuri Technical Information Report TIR-30, 1970. It’s reprinted in this scanned compilation, PDF pages 73 and 76.
- OpenRocket’s user guide gives its recommendation on the page Overrides and surface finish. “The recommended stability margin for subsonic flights is not less than 1.0 caliber, and not less than 2.0 calibers for transonic and supersonic flights”.
- NASA’s Student Launch handbook for 2027 asks for “a minimum static stability margin of 2.0 while sitting on the pad”.
- The Spaceport America Cup’s design guide (2027 REV P1, effective October 15, 2026) states its limits as a share of the rocket’s length instead. Its section 10.2.1 (page 43) asks for a margin of at least 7.5% on a subsonic flight. The minimum rises to 10% if the flight is supersonic at any point. Both hold from launch through motor burnout. Section 10.3.1 (page 44) allows at most 18% at launch. The 2026 guide held the minimum longer, until the first recovery deployment. HPR Sim’s least margin runs on past burnout to apogee, so it can read below the guide’s.
A large margin isn’t free. A very stable rocket turns into a crosswind as it leaves the rail (weathercocking), and so flies off the vertical.
The rail and the build
Two checks beyond the margin: how fast the rocket leaves the rail, and the margin of the rocket as built.
Rail exit speed
The rocket must leave the rail fast enough to fly straight, and the codes name no figure. The NAR’s code asks for “rigid guidance until the rocket has attained a speed that ensures a stable flight”. Tripoli’s, in 7-3, asks for guidance “until it has reached the velocity necessary for stable flight”.
Competitions set numbers. In its section 5.3.1, the Spaceport America Cup’s guide asks for at least 25 m/s (82 ft/s). NASA’s Student Launch handbook asks for 15.8 m/s (52 ft/s).
The reason is the wind. Just off the rail, a crosswind meets the rocket at an angle whose tangent is the wind speed over the rocket’s speed. That’s about 8.6° at the guide rocket’s 26.3 m/s (86 ft/s) in a 4 m/s (8.9 mph) crosswind. The tangent is 4 / 26.3 = 0.152, and the angle whose tangent is 0.152 is 8.6°.
The larger that angle of attack, the further the rocket turns into
the wind. And the simulator’s aerodynamics hold only at small angles. Both of its margins are taken
with the air along the axis, at no angle at all. A longer rail raises the exit speed.
--rail-length sets the length from the rocket’s aft end to the rail’s top, so take off any
standoff the rocket sits on, and --wind sets the wind
(Fly your .ork).
Fly the rocket you built
A design’s center of gravity is a calculation. Your built rocket’s is a measurement, and the
codes ask you to demonstrate it. Weigh the finished rocket, ready to fly but without its motor,
and balance it to find its center of gravity. In OpenRocket, set that mass and center of gravity
as overrides on the stage, covering its parts. Save, and fly the file again
with hpr sim, which reads those overrides (the .ork page).
Leave the motor out of the measurement. An override never covers a motor, in HPR Sim or OpenRocket, and both add the motor’s own mass. So a rocket weighed with its motor in would carry it twice. The margin then rests on your rocket’s measured mass, not the drawing’s.
Accuracy of the margin
The margin’s checks, case by case:
-
On OpenRocket’s examples, HPR Sim’s margin is within 0.016 calibers on 41 of 53 flights. For this comparison it’s taken with the air along the rocket’s axis, as OpenRocket’s is. The margin
hpr simprints is the weakest plane’s, which on a rocket with a fin set of one or two fins can be lower. -
On the three flights of the three-stage example, HPR Sim’s margin is 0.039 to 0.058 calibers below OpenRocket’s. HPR Sim’s center of mass at rod clearance sits 0.043 to 0.062 calibers further aft than OpenRocket’s there, where OpenRocket’s recorded mass reads light (#185). That cause is not yet sized.
-
On the tube-fin example, a rocket with tube fins, HPR Sim’s margin is 1.08 calibers below OpenRocket’s. HPR Sim gives 0.79 calibers to OpenRocket’s 1.87 calibers. Neither program has been checked against a measured tube-fin rocket. Check such a design in both, and treat the smaller margin as the more cautious figure, not a bound.
-
On the five flights of the pods-and-winglets example, Pods--airframes and winglets, HPR Sim’s margin is 0.071 to 0.076 calibers above OpenRocket’s. That’s the flattering side: HPR Sim calls the rocket more stable than OpenRocket does. Two causes are open. One is how the two programs count fins that interfere across sets (#325). The other is the center of pressure of its kinked freeform wings (#326).
A flight whose fin sets share a station, more than four fins between them, warns of #325. A flight with a freeform fin set warns of #326. On a design with pods or freeform fins, check the margin in both. Treat the smaller as the more cautious figure, not a bound. The three flights of Pods--powered with recovery deployment read 0.070 calibers above OpenRocket’s too, cause not yet traced.
-
On 35 flights of 11 private designs, HPR Sim’s margin runs from 0.0166 calibers below OpenRocket’s to 0.1108 above. Four designs read 0.0350 to 0.1108 calibers more stable in HPR Sim than in OpenRocket (the private designs). None of the four has a measured cause yet. #172 and #186 are two of the open causes.
A fifth, launched from a tilted rod, reads 0.0125 to 0.0366 above, most of it traced to the tilt. Reading more stable is the flattering side, so leave room for it near any limit.
-
Near the speed of sound, between Mach 0.8 and 1.2, HPR Sim’s center of pressure is up to 2.36 calibers behind NASA’s wind-tunnel data (Known gaps). Between those speeds, wherever it misses by more than half a caliber, it sits behind. So the flight margin there reads high: the flattering side (Stability in flight shows it against the tunnel). The static margin is computed at Mach 0, so it says nothing about the rocket’s stability in that range. Use the transonic guidance above.
Recording a trajectory
Record a whole flight in HPR Sim as a table of height, speed and position over time, for a spreadsheet or plotting tool.
This page shows how to get a whole flight out of HPR Sim as a table of numbers over time. A spreadsheet or a plotting tool reads it. It flies the rocket of Getting started again, in the same weather, and keeps its height, speed and position every 5 seconds. It needs the first page’s setup, and a little Rust.
Run it
cargo run --example trajectory -p fusionspace-hpr-sim > trajectory.csv
This runs
crates/hpr-sim/examples/trajectory.rs
and saves what it prints in trajectory.csv, a CSV (comma-separated values) file. The file starts
with a header line naming each column with its unit in brackets, then has one line per moment of
the flight. It holds this:
time [s],height above ground [m],vertical speed [m/s],airspeed [m/s],cg east [m],cg north [m],cg up [m]
0.000,0.9,0.0,5.0,0.0,0.0,0.9
0.002,0.9,0.0,5.0,0.0,0.0,0.9
0.371,3.9,16.2,17.0,0.0,0.0,3.9
3.259,216.0,110.6,111.4,-9.7,0.0,216.0
5.000,390.8,90.3,91.3,-24.1,0.0,390.8
10.000,707.8,37.5,39.4,-62.1,0.0,707.8
13.830,778.7,0.0,11.4,-88.7,0.0,778.7
14.330,777.6,-4.5,12.0,-91.9,0.0,777.6
15.000,772.6,-10.2,14.3,-95.6,0.0,772.6
20.000,665.5,-26.4,26.5,-98.4,0.1,665.5
25.000,531.1,-27.0,27.0,-78.6,0.1,531.1
30.000,396.4,-26.8,26.8,-54.4,0.1,396.4
35.000,262.6,-26.7,26.7,-29.5,0.1,262.6
39.234,150.0,-26.5,26.5,-8.4,0.1,150.0
40.000,129.7,-26.5,26.5,-4.5,0.0,129.7
40.234,123.5,-26.5,26.5,-3.3,0.0,123.5
45.000,89.0,-6.4,6.4,20.5,0.0,89.0
50.000,57.0,-6.4,6.4,45.5,0.0,57.0
55.000,25.1,-6.4,6.4,70.5,0.0,25.1
58.933,0.0,-6.4,6.4,90.2,0.0,0.0
Like the first flight’s, this output is committed in
trajectory.output.txt.
CI runs the program on macOS, Windows and Linux and fails if it prints anything else.
This program rounds as it prints. To save a recording with every digit, as CSV or JSON, or the flight path as a map, see Exporting a flight.
Reading the table
| column | what it is | unit |
|---|---|---|
time_s | Time since the motor lit | s |
height_above_ground_m | The height of the center of gravity above the launch pad | m |
vertical_speed_m_s | How fast that height changes: positive going up, negative coming down | m/s |
airspeed_m_s | The rocket’s speed through the air, which the wind adds to or takes from | m/s |
cg_east_m, cg_north_m, cg_up_m | Where the center of gravity is: meters east, north and up of the pad, in the launch frame | m |
There’s a row every 5 seconds, and one at every event, at the moment it happened:
| time (s) | event |
|---|---|
| 0.002 | liftoff: the push up the rail first beats the weight, and the rocket starts to move |
| 0.371 | the rocket leaves the 3 m (9.8 ft) rail |
| 3.259 | burnout |
| 13.830 | apogee; the drogue’s charge fires at the same moment, so it shares this row |
| 14.330 | the drogue opens, half a second later |
| 39.234 | the main’s charge fires, as the rocket falls past 150 m (492 ft) |
| 40.234 | the main opens, a second later |
| 58.933 | landing |
What the numbers show:
-
On the pad the airspeed is 5.0 m/s (11 mph) with the rocket standing still. That’s the wind.
-
The rocket climbs into the wind. The wind blows from the west, and off the rail a stable rocket turns its nose toward the wind it feels (weathercocking). So it drifts west:
cg_east_mis −88.7 m (−291 ft) at apogee. -
Under the drogue alone it falls at about 27 m/s (89 ft/s), and the wind carries it east.
-
The main slows it from 26.5 m/s (87 ft/s) to 6.4 m/s (21 ft/s) between the row where it opens (40.234) and the next (45.000).
-
It lands at 6.4 m/s (21 ft/s), 90.2 m (296 ft) east of the pad.
-
cg_north_mshows 0.1 m (0.3 ft) for a while, with no wind from the south. The Earth’s rotation nudges a moving rocket sideways, to the right of its motion in the northern hemisphere (Coriolis acceleration). While the rocket moves west, that’s north. It drifts up to 6.3 cm (2.5 in), which the table rounds to 0.0 or 0.1 m (0.3 ft). -
cg_up_mandheight_above_ground_magree here, and don’t in general. The launch frame is a flat plane, and the Earth curves away below it. Socg_up_mreads low far from the pad.On the ground 10 km (6.2 mi) from the pad, it’s −7.8 m (−26 ft). At this landing, 90.2 m (296 ft) out, it’s under a millimeter low. For heights, use
height_above_ground_m.
Record something else
The program below makes its recorder with
Recorder::new(vec![Channel::Time, Channel::HeightAboveGround, ...], Some(5.0)), and passes it to
run, which feeds it every step of the flight. Change either argument:
- The interval is
Some(5.0), a row every 5 s.Some(0.1)gives a smooth plot, about 600 rows for this flight.Nonekeeps a row at the end of every step the integrator takes, which is as fine as the flight was computed (Time integration). - The channels are the columns. Others include the Mach number, the
angle of attack, the dynamic pressure,
the thrust, the mass, the attitude and the rotation rates. The
Channelpage of the API reference lists every one with its unit, andChannel::ALLkeeps them all. - After the flight,
recorder.columns()gives the column names, units included, andrecorder.rows()gives one list of numbers per row, in the same order.
To save a file straight from Rust instead of printing, write the same lines to a
std::fs::File.
The program
This is the whole program, line for line the file CI runs. Everything above the recorder is the first flight’s setup, which Getting started explains step by step.
//! A trajectory to plot: the flight of `first_flight.rs`, recorded every 5 s and at every event,
//! printed as CSV (comma-separated values), which a spreadsheet or a plotting tool reads.
//!
//! Run it from anywhere in the repository, and save what it prints to a file:
//!
//! ```text
//! cargo run --example trajectory -p fusionspace-hpr-sim > trajectory.csv
//! ```
//!
//! The documentation site's *Recording a trajectory* page (`docs/recording-a-trajectory.md`)
//! walks through it. What it prints is kept next to it in `trajectory.output.txt`, and CI checks
//! that the two still agree (`cargo xtask examples --check`).
#![allow(
clippy::print_stdout,
reason = "the project's lints forbid printing in library code, and this program exists to print"
)]
use std::error::Error;
use hpr_atmos::ConstantWind;
use hpr_core::geodesy::Geodetic;
use hpr_design::Rocket;
use hpr_sim::{
CanopyType, Channel, Device, DeviceDrag, Environment, FlightSettings, Rail, Recorder,
Simulation, Termination, Trigger, export,
};
fn main() -> Result<(), Box<dyn Error>> {
// The first flight: Valetudo on a K400C, from a 3 m vertical rail in New Mexico, in 5 m/s of
// wind from the west, with a drogue at apogee and a main at 150 m.
let rocket: Rocket = serde_json::from_str(include_str!(
"../../../validation/designs/rocketpy-valetudo.json"
))?;
let site = Geodetic::from_degrees(32.99, -106.97, 1400.0)?;
let environment =
Environment::standard(site)?.with_wind(ConstantWind::new(5.0, 270_f64.to_radians())?);
let simulation = Simulation::new(
&rocket,
"example",
environment,
Rail::vertical(3.0),
FlightSettings::default(),
)?
.with_recovery(vec![
Device::new(
"drogue",
DeviceDrag::canopy(CanopyType::FlatCircular, 0.6),
Trigger::Apogee,
)
.with_lag_s(0.5),
Device::new(
"main",
DeviceDrag::canopy(CanopyType::FlatCircular, 2.4),
Trigger::Altitude {
height_above_ground_m: 150.0,
},
)
.with_lag_s(1.0),
])?;
// What to keep, and how often: the time, the height above the pad, the vertical speed, the
// airspeed and where the center of gravity is (meters east, north and up of the pad), every
// 5 s. A recorder also keeps a row at every event, such as burnout or a parachute opening.
// For a smooth plot, use `Some(0.1)`; `None` keeps a row at the end of every step.
let mut recorder = Recorder::new(
vec![
Channel::Time,
Channel::HeightAboveGround,
Channel::VerticalSpeed,
Channel::Airspeed,
Channel::CgPosition,
],
Some(5.0),
)?;
let flight = simulation.run(&mut recorder)?;
if flight.termination != Termination::GroundHit {
return Err(format!("the flight ended with {:?}", flight.termination).into());
}
// One header line with each column's name and unit, then one line per row: the time to
// 0.001 s, the rest to 0.1.
let header: Vec<String> = recorder
.columns()
.iter()
.map(|column| export::csv_header(column))
.collect();
println!("{}", header.join(","));
for row in recorder.rows() {
let fields: Vec<String> = row
.iter()
.enumerate()
.map(|(column, &value)| rounded(value, if column == 0 { 3 } else { 1 }))
.collect();
println!("{}", fields.join(","));
}
Ok(())
}
/// `value` to `decimals` places, without the minus sign of a value that rounds to zero. Some values
/// that are zero in principle come out a hair below it: the vertical speed at ignition and at
/// apogee, the landing height, which is found just below the ground, and the landing's `cg_up_m`,
/// under a millimeter below the pad's level because the ground curves away.
fn rounded(value: f64, decimals: usize) -> String {
let text = format!("{value:.decimals$}");
match text.strip_prefix('-') {
Some(unsigned) if unsigned.chars().all(|c| c == '0' || c == '.') => unsigned.to_owned(),
_ => text,
}
}
Exporting a flight
Save a flight as CSV, JSON or Parquet tables for a spreadsheet, and as GeoJSON or KML maps of its path and landing.
This page shows how to save a flight as files other programs read. A table of numbers over time, for a spreadsheet or a plotting tool, comes as CSV, JSON or Parquet. A map of the flight path and the landing comes as GeoJSON or KML, which Google Earth, QGIS and most web maps open. It flies the rocket of Getting started again and writes all five files. It needs the first page’s setup, and a little Rust.
Without writing Rust, hpr sim --export writes the same five formats for a .ork or HPR design
file. It puts every quantity HPR Sim tracks in each
(The command line). Its maps mark the landing when a parachute
or streamer opened, as a .ork file’s do, and no landing otherwise
(the landing).
Run it
cargo run --example export_flight -p fusionspace-hpr-sim --features parquet -- my-flight
This runs
crates/hpr-sim/examples/export_flight.rs,
which writes five files into the folder my-flight and prints what it wrote. Without a folder, it
writes them into fusionspace-hpr-export in the system’s temporary folder.
Parquet is an optional feature of
fusionspace-hpr-sim, named parquet, so the command turns it on. Without it, cargo says the
example needs it. The feature adds no other library. I made it optional so that a program with no
use for a binary file format leaves it out. In your own program, turn it on in Cargo.toml with
fusionspace-hpr-sim = { ..., features = ["parquet"] } (the crate your code calls hpr_sim).
wrote 67 rows of 5 columns, a path of 67 points
flight.csv
flight.json
flight.parquet, 3228 bytes
flight.geojson
flight.kml
landed at 32.99000° N, 106.96904° W, 90 m from the pad, at 58.9 s
CI runs it on macOS, Windows and Linux and fails if it prints anything else. The files hold every number to its last digit, which may differ in the last place between operating systems. So the program prints a rounded summary instead of the files.
The five files
| file | what it holds | opens in |
|---|---|---|
flight.csv | a header giving each column in words with its unit in brackets (time [s], cg east [m], …), then one line per recorded moment, lines ending in CRLF as RFC 4180 says | a spreadsheet, pandas, any plotting tool |
flight.json | the same table as {"tool": {...}, "columns": [...], "rows": [[...], ...]}, each column’s unit in its name (time_s, cg_east_m) | any programming language |
flight.parquet | the same table in Apache Parquet, a binary format that stores it column by column: one column of 64-bit numbers per recorded column, named as in the JSON (time_s), not as in the CSV’s header (time [s]), and the program that wrote it, the motor catalog’s date and how far to trust the numbers in the file’s key-value metadata | pandas with pyarrow (Apache Arrow’s Python library), DuckDB |
flight.geojson | the flight path as a line, and a point for each landing: the rocket’s and any separated body’s; a tool object naming the program that wrote it; and the motor catalog’s date and how far to trust the numbers | QGIS, geojson.io, web maps |
flight.kml | the same path and landing | Google Earth |
Which program wrote a file
Each file but the CSV carries its provenance, where it came from. Like a drawing’s title block, the provenance names the tool that made the file. That’s the program, its version and its designation in the FusionSpace product system. It also carries the motor catalog’s date and how far to trust it, which come further below. The tool is named this way:
- In JSON and GeoJSON, it’s a
toolobject at the top,{"name": "FusionSpace HPR", "version": "0.1.0", "designation": "FS-ACHERNAR \u00b7 SW \u00b7 TOOL 001"}. The text is ASCII, so the designation’s middle dot·is written as its escape\u00b7. Every JSON reader reads that back as the dot. In GeoJSON the object is a foreign member, a key the standard doesn’t define. RFC 7946 (section 6.1) allows it, and map programs pass over it. - In KML, it’s a comment on the second line,
<!-- FusionSpace HPR 0.1.0 · FS-ACHERNAR · SW · TOOL 001 -->. - In Parquet, it’s the first three entries of the file’s key-value metadata:
tool(FusionSpace HPR),tool_versionanddesignation. pyarrow shows them withpyarrow.parquet.read_metadata(path).metadata.
The CSV holds only the header and the rows, so a spreadsheet opens it cleanly. Its header gives
each column in words with its unit in brackets, as the FusionSpace product system writes one.
For example, it gives time [s] for the column the other formats call time_s,
velocity east [m/s] for velocity_east_m_s, acceleration up [m/s^2] for
acceleration_up_m_s2 and dynamic pressure [Pa] for dynamic_pressure_pa. A column with no unit, such as mach, is its words alone. The
library’s export::csv_header gives one from the other.
hpr sim writes the title block beside the CSV instead: flight.meta.json for flight.csv. It
holds the same tool object, the CSV’s file name, the design and configuration flown, the number
of rows, and:
catalog_as_of: the day the bundled motor catalog’s curve files were downloaded, such as2026-10-28, which a build fixes. Whether a motor came from the catalog is inhpr sim --json’smotors. Each motor’ssourceis{"kind": "catalog", "as_of": "2026-10-28"}for one that did. Andhpr sim’s motor line saysfrom the bundled catalog, as of 2026-10-28. The day of the run itself is left out, so the same run writes the same bytes.kindandtrust: what the numbers are, and the accuracy notehpr simends with, word for word. The kind issimulatedfor a flight, andhpr motors showsayscopiedof a catalog motor’s figures.
A JSON recording from hpr sim carries the same three, with design and configuration, between
tool and columns. So a saved flight keeps its note. hpr mc --export’s sidecar carries them
too, with hpr mc’s own note. GeoJSON, KML and Parquet carry them as well. So a map or a table
copied away from the rest still says how old its motor data is and how far to trust it:
- In GeoJSON, they’re
design,configuration,catalog_as_of,kindandtrust, as foreign members betweentoolandfeatures, as in the JSON recording. - KML uses the
Document’sdescription:Motor catalog as of 2026-10-28.followed by the note. The design and configuration are already in itsname. KML has no field forkind. The note says the numbers are simulated. - In Parquet, they’re five more entries of the key-value metadata after the program’s three, under
the same names. Each value is text (
kindissimulated). The keys and values come out of pyarrow as bytes:pyarrow.parquet.read_metadata(path).metadata[b"trust"].decode()is the note.
Each gives the bundled catalog’s date whether or not the flight’s motor came from the catalog. A
motor from your own .eng or .rse file is as old as that file. hpr sim --json’s motors
says where each motor came from.
The --plot figure gives the catalog’s date too, in its title block, and its data file has a
sidecar of its own (Plotting the flight). The library’s export::csv
writes the CSV alone. export::json, export::geojson, export::kml and export::parquet carry
no more than the program’s name, version and designation. export::json_with,
export::geojson_with, export::kml_with and export::parquet_with add a program’s own fields.
To look at the Parquet file from Python, install pandas and pyarrow (pip install pandas pyarrow;
pandas can’t read Parquet on its own), then:
python -c "import pandas; print(pandas.read_parquet('my-flight/flight.parquet'))"
or, with DuckDB’s command-line program, duckdb -c "SELECT * FROM 'my-flight/flight.parquet'".
The tables hold whatever channels the
recorder kept, one row per recorded moment. The maps need the recorder to keep the time and the
center of gravity’s position (Channel::Time and Channel::CgPosition). They place each recorded
position on the Earth, with the same conversion as the landing point in
Flight metrics.
A map line in KML looks like this, one longitude,latitude,height per recorded moment (the digits
here are cut short):
<LineString>
<altitudeMode>absolute</altitudeMode>
<coordinates>
-106.97,32.99,1400.93591...
-106.97,32.98999...,1403.85869...
Heights: two datums
A height needs something to count from, a datum. The two map formats use different ones, because their standards say so:
- GeoJSON heights are above the WGS 84 ellipsoid, the smooth shape GPS uses (ellipsoidal height; RFC 7946, section 4).
- KML heights with
altitudeModeabsoluteare above sea level, which KML takes from the EGM96 geoid (height above sea level; OGC KML 2.2, 07-147r2).
Sea level sits above or below the ellipsoid by the
geoid undulation , up to about 100 m (328 ft). The
simulator has no model of it. So it uses the value the flight was given
(Environment::with_geoid_undulation_m, zero unless set), the same for every point of the flight.
The geoid’s slope is about 5 cm (2.0 in) per kilometer, and up to some 30 cm (12 in) in mountains.
Over a rocket’s few kilometers, that slope moves the undulation by centimeters to decimeters.
For example, take a site where sea level is 25 m (82 ft) below the ellipsoid (). There a point 1,500 m (4,921 ft) above the ellipsoid is written as 1,500 m (4,921 ft) in GeoJSON. In KML it’s written as 1,525 m (5,003 ft).
The first flight leaves at zero, so its two files agree. At the real site, sea level is some tens of meters below the ellipsoid. So give for heights you mean to trust.
How the files are checked
-
Each number is written in the shortest form that reads back to the same number. The tests read every file back and compare it with the recording exactly, not within a tolerance. A value that isn’t a finite number is refused with an error rather than written as
NaNornull, which different programs read differently. -
GeoJSON is checked against the published GeoJSON schema (geojson.org/schema), with longitude before latitude as the standard requires. A test also shows the check rejects a broken file.
-
KML is parsed by a strict XML parser, and checked for the KML 2.2 namespace, the height mode and every coordinate.
-
HPR Sim writes the Parquet file itself, from the format’s specification. The tests read it back with an independent reader, Apache’s own Parquet library for Rust, and compare every number bit for bit. One test uses a recording of every channel (30 columns today) long enough to fill at least three data pages per column. Another compares a small file with bytes worked out by hand from the specification.
Once, by hand, when this was written, pyarrow 25.0.1 and DuckDB 1.5.5 each read the example’s file and a 30-column, 3,005-row file. Each got the same numbers as the matching CSV. CI doesn’t repeat that check.
The tests are in
crates/hpr-sim/src/export.rs
and
crates/hpr-sim/src/export/parquet.rs.
What it leaves out
-
The Parquet file isn’t compressed and carries no per-page minimum and maximum. It takes 8 bytes per number, plus a header of about 20 bytes per page of up to 1,024 numbers. A short index of the columns at the end of the file adds to that. The example’s file is 3,228 bytes, and its CSV about 5.6 kB.
Without the minimums and maximums, a tool such as DuckDB can’t skip parts of the file when filtering (say
WHERE time_s > 10). So it reads it all, which for one flight takes no noticeable time. -
A path over the antimeridian (±180° longitude) isn’t cut in two as RFC 7946 asks. So a map would draw it the long way round the globe.
-
A landing is a point on the ground, without a height.
-
There’s no summary file: the flight’s peaks and margins (Flight metrics) aren’t in these files. A
FlightSummaryconverts to JSON on its own withserde_json::to_string. But that path writes a value that isn’t finite asnullrather than refusing it.
The choices are recorded in two decisions: exports as text built in the core and Parquet written in-house, read back by Apache’s library.
The program
This is the whole program, line for line the file CI runs. Everything above the recorder is the first flight’s setup, which Getting started explains step by step.
//! A flight written out for other programs: the flight of `first_flight.rs`, recorded every 1 s
//! and at every event, saved as CSV, JSON and Parquet tables and as a GeoJSON and a KML map of its
//! path and landing.
//!
//! Run it from anywhere in the repository, naming the folder to write the five files to. Parquet
//! is an optional feature of the library, so the command turns it on:
//!
//! ```text
//! cargo run --example export_flight -p fusionspace-hpr-sim --features parquet -- my-flight
//! ```
//!
//! Without a folder it writes them to `fusionspace-hpr-export` in the system's temporary folder. The
//! documentation site's *Exporting a flight* page (`docs/exporting-a-flight.md`) walks through it.
//! What it prints is kept next to it in `export_flight.output.txt`, and CI checks that the two
//! still agree (`cargo xtask examples --check`).
#![allow(
clippy::print_stdout,
reason = "the project's lints forbid printing in library code, and this program exists to print"
)]
#![allow(
clippy::disallowed_methods,
reason = "the library builds each file's text without I/O; this program writes the files"
)]
use std::error::Error;
use std::path::PathBuf;
use hpr_atmos::ConstantWind;
use hpr_core::geodesy::Geodetic;
use hpr_design::Rocket;
use hpr_sim::{
CanopyType, Channel, Device, DeviceDrag, Environment, FlightMetrics, FlightSettings, Rail,
Recorder, Simulation, Termination, Trigger, export,
};
fn main() -> Result<(), Box<dyn Error>> {
// The first flight: Valetudo on a K400C, from a 3 m vertical rail in New Mexico, in 5 m/s of
// wind from the west, with a drogue at apogee and a main at 150 m.
let rocket: Rocket = serde_json::from_str(include_str!(
"../../../validation/designs/rocketpy-valetudo.json"
))?;
let site = Geodetic::from_degrees(32.99, -106.97, 1400.0)?;
let environment =
Environment::standard(site)?.with_wind(ConstantWind::new(5.0, 270_f64.to_radians())?);
let simulation = Simulation::new(
&rocket,
"example",
environment,
Rail::vertical(3.0),
FlightSettings::default(),
)?
.with_recovery(vec![
Device::new(
"drogue",
DeviceDrag::canopy(CanopyType::FlatCircular, 0.6),
Trigger::Apogee,
)
.with_lag_s(0.5),
Device::new(
"main",
DeviceDrag::canopy(CanopyType::FlatCircular, 2.4),
Trigger::Altitude {
height_above_ground_m: 150.0,
},
)
.with_lag_s(1.0),
])?;
// Two watchers on one flight: the metrics, for the landing, and a recorder of the time, the
// height above the pad and the center of gravity's position, which a map needs.
let recorder = Recorder::new(
vec![
Channel::Time,
Channel::HeightAboveGround,
Channel::CgPosition,
],
Some(1.0),
)?;
let mut watchers = (FlightMetrics::new(), recorder);
let flight = simulation.run(&mut watchers)?;
if flight.termination != Termination::GroundHit {
return Err(format!("the flight ended with {:?}", flight.termination).into());
}
let (metrics, recorder) = watchers;
let summary = metrics.summary(&flight, simulation.environment())?;
// The path on the Earth, then the five files. Each function returns the file's contents:
// text, or bytes for Parquet, which is a binary format.
let track = export::track(&recorder, simulation.environment())?;
let files = [
("flight.csv", export::csv(&recorder)?.into_bytes()),
("flight.json", export::json(&recorder)?.into_bytes()),
("flight.parquet", export::parquet(&recorder)?),
(
"flight.geojson",
export::geojson(&track, &summary)?.into_bytes(),
),
(
"flight.kml",
export::kml(&track, &summary, "Valetudo, K400C")?.into_bytes(),
),
];
let folder = match std::env::args_os().nth(1) {
Some(folder) => PathBuf::from(folder),
None => std::env::temp_dir().join("fusionspace-hpr-export"),
};
std::fs::create_dir_all(&folder)?;
for (name, contents) in &files {
std::fs::write(folder.join(name), contents)?;
}
// What was written, and where it landed, to five decimal places of a degree (about a meter).
// The site is west of Greenwich, so the longitude is printed as degrees west.
println!(
"wrote {} rows of {} columns, a path of {} points",
recorder.rows().len(),
recorder.columns().len(),
track.len()
);
for (name, contents) in &files {
// The Parquet file's size is the same on every system: its numbers take 8 bytes each,
// however many digits they have.
if name.ends_with(".parquet") {
println!(" {name}, {} bytes", contents.len());
} else {
println!(" {name}");
}
}
if let Some(landing) = summary.landing {
println!(
"landed at {:.5}° N, {:.5}° W, {:.0} m from the pad, at {:.1} s",
landing.latitude_deg, -landing.longitude_deg, landing.distance_m, landing.time_s
);
}
Ok(())
}
The builder
Describe your own rocket part by part with the hpr crate’s builder, add a motor, and fly it from a
rail.
This page shows the shortest way to fly a rocket of your own with HPR Sim. The hpr
crate has four types for it: Environment, Motor, Rocket and Flight.
Add it with cargo add fusionspace-hpr. Your code then says use hpr::….
You describe the rocket part by part from the nose back, put a motor in it, and fly it from a rail. The page runs four example programs and walks through them. It needs the setup from Getting started, and some Rust.
On two of RocketPy’s example rockets, HPR Sim’s drift and RocketPy’s differ by 10 to 38% (Getting started explains why).
The first example
Run the first example, then read its program part by part.
Run it
cargo run --example build_and_fly -p fusionspace-hpr
This builds the small rocket of Your own rocket. Its airframe is 54 mm (2.1 in) inside and 56.3 mm (2.2 in) outside, and it takes 29 mm motors. It weighs the rocket, and finds its center of gravity (CG), its center of pressure (CP) and its stability margin.
Then it flies the rocket on a Cesaroni H54 from a rail leaning into a light wind. Its parachute opens at the motor’s ejection delay. It prints this:
My 54 mm rocket on a 168H54-10A
Not yet validated: see the Accuracy page before trusting these numbers.
liftoff spent
mass (kg) 0.675 0.579
center of gravity (m from nose) 0.671 0.610
center of pressure (m from nose) 0.779 0.779
stability margin (calibers) 1.92 2.99
From a 1.8 m rail leaning 5° west, in 5 m/s of wind from the west:
Rail exit: 21.7 m/s
Apogee: 1106.6 m above the pad, at 13.69 s, 282 m west of it
Top speed: 186 m/s (Mach 0.56)
Landing: 877 m east of the pad, at 4.6 m/s, at 246.3 s
What the lines say:
- Between liftoff and spent, the rocket loses 96 g of propellant as the motor burns. That moves the CG 6 cm (2.4 in) forward, and the margin grows from 1.92 to 2.99 calibers.
- The CP is worked out by Barrowman’s method at Mach 0.3, a typical subsonic speed, with the air straight along the rocket. It depends on the shape alone, so it doesn’t move as the motor burns.
- The rail exit speed is how fast the rocket leaves the rail. The rail leans 5° west, into the wind. The rocket turns further into the wind as it climbs, a rocket’s usual weathercocking. The lean and the turn together put its apogee 282 m (925 ft) west of the pad. Under the parachute the wind carries it back, to land 877 m (2,877 ft) east of the pad.
- Heights are the height of the rocket’s CG above the launch site. The CG starts above the ground, sitting on the rail, so the apogee includes that starting height.
The program
The program is
crates/hpr/examples/build_and_fly.rs.
It takes four steps: the motor, the rocket, the weighing and the flight.
The motor
Motor::from_catalog("H54") takes a motor from the catalog built into the simulator. It finds the
motor by its designation, such as 168H54-10A, or by its common name, the short form such as
H54. It ignores case, spaces and hyphens, and a leading maker name narrows it (Estes C6). It
finds any of the 924 bundled motors with a thrust curve; hpr motors list lists them
(Solid motors). A name that matches two motors, as I175
does, is refused rather than guessed, with a name listed that finds each alone; so is a name
several makers use, such as G80
(A name several makers share).
685 of the 924 motors with a curve fly a file that is more than 1% from ThrustCurve.org’s figures
for it (the whole catalog). Such a motor still flies, and
warnings() lists what hpr sim --motor would print: each failing figure and each failing
mass check. The library prints nothing itself. Check such a file against the
maker’s data.
The delay is never read from the designation. with_delay_s(10.0) sets it, and a parachute opened
by the motor’s charge needs it. Motor::from_eng reads the text of a
RASP .eng file, such as one downloaded from ThrustCurve.org, instead.
The rocket
Rocket::new(name, diameter_m) starts an empty rocket with an outer body diameter. Then each
add_ call adds one part and returns the rocket, so the calls chain. Body parts stack from the
nose tip in the order you add them. The parts that go inside or on the airframe attach to the last
body tube you added:
| part | what it is | where it goes |
|---|---|---|
Nose::hollow, Nose::solid | A nose cone of a shape and length, and its wall. with_shoulder adds the sleeve that fits inside the tube behind; with_capped_shoulder closes the sleeve’s aft end with a disc | First, at the tip. Its base takes the rocket’s diameter |
Tube::new | A body tube of a length and a wall. with_diameter_m gives it another diameter | Behind the last body part, at its diameter |
Transition::conical | A cone to a new diameter at its aft end: a boattail, or a step up or down in the airframe | Behind the last body part, starting at its diameter |
Fins::new | A set of identical fins of a shape (FinPlanform, which names each dimension), square-edged unless with_cross_section says otherwise | On the last tube, flush with its aft end unless at places them |
MotorTube::new | The tube the motor goes in: its length, bore and wall | In the last tube, flush with its aft end unless at places it |
Mass::new | Anything else inside: a recovery bay, an altimeter, ballast | In the last tube, where its position puts it |
A position (Position) is measured along the tube the part is on:
Topplaces the part’s fore end a distance aft of the tube’s.Bottommeasures the part’s aft end from the tube’s aft end.Middlemeasures its middle from the tube’s middle.Afterplaces its fore end behind the part before it.Absolutemeasures its fore end from the nose tip.
So a Mass given a size with packed has its center half that length from the end its position
names. One placed by its Middle has its center at the point itself. In the example, the
recovery bay is packed 15 cm (5.9 in) long, its top 7 cm (2.8 in) down the tube. That moves the
rocket’s CG at liftoff 22 mm (0.87 in) aft of where a point mass at the top puts it.
Every part names its material, and every hollow part its wall. material("abs") finds one of the
built-in materials, each with the source of its density. The mass page explains
how the masses are found. I gave the builder no default material or wall, because each would be a
guess at your rocket’s mass.
The defaults it does have change the drag, not the mass. Fins have square edges, and every outer surface has the design’s default finish, mass-production paint. The finish sets the friction of the air on it (Drag). The builder can’t change the finish yet.
set_motor puts the motor in the motor tube, lit at launch. add_parachute adds a recovery
device. Here it’s a 90 cm (35 in) flat parachute opened by the ejection charge of motor number 0,
the first, Trigger::MotorDelay { motor: 0 }.
A device adds drag, not mass. The parachute’s mass is in the 200 g recovery bay. The recovery page explains the devices and what opens them.
Weighing it
mass_properties(t) gives the mass, CG and inertia t seconds after the motor lights.
margin(t, mach) gives the CP and the margin, and static_margin_cal(t, mach) the margin alone.
Weighing runs the same checks on the design as a flight does, so a motor wider than its tube is
refused by both.
The CG is in the body frame, whose axis points to the nose. So a point 0.671 m (26.4 in) behind the nose tip is at . The CP is a station, meters aft of the tip. So the example prints it as it comes, and the CG with its sign turned.
Flying it
Environment::new(latitude, longitude, elevation) is the launch site, in degrees north, degrees
east (so the Americas are negative) and meters. It has the
standard atmosphere and no wind.
with_constant_wind(5.0, 270.0) adds 5 m/s (11 mph) blowing from 270°, the west. The elevation is
taken both as the height above sea level, where the air is read, and as the height above the
ellipsoid.
Flight::builder(&rocket, &environment, 1.8) sets up a flight from a vertical 1.8 m (5.9 ft) rail.
inclination_deg is the rail’s angle above the horizon: 90 is vertical, and 85 leans 5° off it.
OpenRocket measures its launch rod angle from the vertical instead, so its 5° is 85 here.
heading_deg is the way the rail leans, clockwise from true north (add the
declination to a compass reading). A wind’s direction is where it
comes from, so a rail leaning into a west wind has both at 270.
fly() flies the rocket to the ground. The flight’s apogee_m, max_speed_m_s,
rail_exit_speed_m_s and landing are the numbers most asked for. summary() has every metric
the metrics page describes.
Motors, fins and parts
Three more examples: choosing a motor, sizing the fins, and building the rocket from a maker’s parts.
Which motor
The second example flies the same rocket on each 29 mm motor that comes with the simulator, from a vertical rail. The parachute opens at apogee whatever the delay:
cargo run --example motor_choice -p fusionspace-hpr
My 54 mm rocket from a 1.8 m vertical rail, in 5 m/s of wind from the west
Not yet validated: see the Accuracy page before trusting these numbers.
motor liftoff margin rail exit apogee top speed best delay
(kg) (cal) (m/s) (m) (m/s) (s)
F15 0.569 3.00 10.0 206.9 55 4.6
F52C 0.548 3.32 18.5 438.6 106 8.0
168H54-10A 0.675 1.92 21.7 1134.6 186 10.5
set_motor swaps the motor in the tube, so one rocket flies on all three. The H54 reaches
1,134.6 m (3,722 ft) here, from a vertical rail in the wind. The same rocket reaches 1,144.5 m
(3,755 ft) on Your own rocket, from a vertical rail in calm air. It reaches
1,106.6 m (3,631 ft) at the top of this page, from a leaning rail. The parachutes open at different
times too: here at apogee, there at the motor’s charge.
The best delay is the time from burnout, the end of the thrust curve, to apogee, so the charge fires at the top. It’s 10.5 s on the H54, near the 10 s delay that motor’s designation names. The H54 burns out at 3.5 s. So on the leaning rail at the top of this page, its 10 s delay fires at 13.5 s. That’s 0.2 s before its apogee.
The F52 wants 8 s. The F15 leaves the rail at only 10 m/s (33 ft/s), the slowest of the three. A slow rocket’s fins have the least air to steer with.
Sizing fins
The third example builds the same rocket with fins of five spans. A fin’s span is its height from the body tube to its tip. The example flies each from a vertical rail, in calm air and in 5 m/s (11 mph) of wind from the west. The parachute opens at apogee here, not at the motor’s charge, so the charge doesn’t cut the climb short:
cargo run --example fin_sizing -p fusionspace-hpr
My 54 mm rocket on an H54, fins of five spans, in calm air and a 5 m/s west wind
Not yet validated: see the Accuracy page before trusting these numbers.
fin span liftoff margin apogee (m) in the wind: drift (m)
(mm) (kg) (cal) calm wind apogee upwind landing downwind
25 0.666 -2.11 too little margin to fly
35 0.671 0.33 too little margin to fly
45 0.675 1.92 1145 1135 119 1068
55 0.680 2.97 1126 1110 156 1001
65 0.684 3.67 1107 1088 176 954
Because a rocket is a value built by a function, a design study is a loop. The example’s
rocket(span_m) builds the rocket with fins of that span, and the loop weighs and flies each.
-
The margin, at liftoff and at Mach 0.3, grows fast with the span. It goes from −2.11 calibers, a CP ahead of the CG, to 3.67 calibers. The usual rule of thumb asks for at least one caliber (stability margin). So the program doesn’t fly the two smallest. The example’s own fins are the 45 mm (1.8 in) ones.
-
Bigger fins cost height. In calm air the 65 mm (2.6 in) fins reach 38 m (125 ft) less than the 45 mm (1.8 in) ones. That’s their drag and their extra mass, about 9 g.
In the wind they lose 47 m (154 ft), since they also turn the rocket further into it. The apogee drift shows the extra turn: 119 m (390 ft) upwind with the 45 mm (1.8 in) fins. With the 65 mm (2.6 in) fins it’s 176 m (577 ft).
-
The landing is closer with bigger fins. It comes 114 m (374 ft) closer from the 45 mm (1.8 in) fins to the 65 mm (2.6 in). The parachute opens further upwind, and lower, so it drifts for less time.
Parts from a catalog
A rocket can also be built from a maker’s parts, as sold, from a parts catalog. HPR Sim bundles
the one OpenRocket ships: 3,449 parts from Estes, LOC Precision and a dozen more makers. It reads
them as the .orc page explains. The fourth example finds LOC Precision’s 2.56 in
(65 mm) airframe parts in the catalog by maker and part number. It builds the rocket from them and
flies it on an AeroTech H170:
cargo run --example catalog_rocket -p fusionspace-hpr
LOC 2.56 in from the catalog, with motor H170M
Not yet validated: see the Accuracy page before trusting these numbers.
part mass (g)
LOC Precision PNC-2.56 87.7
LOC Precision BT-2.56 120.0
LOC Precision BT-1.52, MMT-1.52 43.6
LOC Precision CR-2.56-38mm 4.2
LOC Precision CR-2.56-38mm 4.2
fins 99.7
LOC Precision LP-36-2022 70.7
structure 430.1
At liftoff: 0.760 kg, center of gravity 0.728 m from the nose,
stability margin 1.07 calibers at Mach 0.3.
Rail exit: 30.0 m/s
Apogee: 1119.3 m above the pad, at 11.77 s
Top speed: 302 m/s (Mach 0.91)
Landing: at 4.6 m/s, at 250.8 s
Each part is named by its maker and its part number, as the design keeps it. LOC’s numbers say what the part is and its size in inches:
PNC-2.56is a plastic nose cone for the 2.56 in tube.BT-2.56is the body tube.MMT-1.52is the 1.52 in (38 mm) motor tube.CR-2.56-38mmis a centering ring between the two.LP-36-2022is a 36 in parachute.
Structure is all the parts together, without the motor.
Nothing checks the flight itself: the note at the top of this page applies. The top speed is Mach 0.91, close to the speed of sound. There drag rises steeply and is least certain (Drag through Mach 1). The stability margin, 1.07 calibers, is taken at Mach 0.3, about 100 m/s (328 ft/s). That’s more than three times the speed the rocket leaves the rail at.
The program is
catalog_rocket.rs.
Its steps:
- Find the part.
hpr::hpr_io::orc::bundled().find("LOC Precision", "PNC-2.56")returns the parts with that maker and number. Use the maker’s name as the file writes it (“LOC Precision”, where OpenRocket shows “LOC/Precision”). - Make the builder’s part from it.
Nose::from_catalog(part),Tube::from_catalog,Transition::from_catalogandMotorTube::from_catalog(a body tube used as the motor tube) take the catalog’s sizes, material and density. A catalog nose or transition states its own diameters. So the tube behind it takes the nose’s diameter, not the one given toRocket::new. - Cut a tube. Catalog tubes are sold long (LOC’s motor tube is 34 in).
with_length_mcuts one to length, and its mass follows. - Fittings. A fitting is a part that goes in or on the last body tube. It can be a coupler,
an engine block, a centering ring, a bulkhead, a launch lug, or a packed parachute or streamer.
Fitting::from_catalog(part)makes one from a catalog part, andRocket::add_fittingadds it, flush with the tube’s aft end unlessatplaces it.Fitting::centering_ring,bulkhead,couplerandlaunch_lugmake one to your own sizes. - A parachute is two things. As a fitting it is its weight: canopy and shroud lines, at its place in the tube. Its drag is a recovery device, as in the first example. The example gives that device the catalog’s diameter.
- The fins are made by hand: the catalog has none.
229 of the 3,449 parts state their mass in the catalog, and each weighs that mass. The builder sets the part’s density so that the part, as the catalog sizes it, weighs the stated mass. The material’s name gains “, density set by the part’s stated mass”. A part changed afterwards, such as a tube cut shorter, keeps that density, so its mass follows the change.
OpenRocket gives a rigid part its stated mass the same way. It gives a parachute its stated mass as an override, which comes to the same for a parachute left as it is. It ignores a streamer’s.
What the catalog leaves unsaid
A catalog leaves some sizes out. The builder fills each one in the way OpenRocket 24.12 does when it builds the part. The one exception is a hollow part’s shoulder. The shapes are explained in Shapes:
| Left unsaid | The builder’s choice | OpenRocket’s |
|---|---|---|
| An ogive’s shape | tangent | the same |
| A parabola’s parameter | 1 | the same |
| A Haack series’ | 0, the von Kármán | the same |
| A power series’ exponent | ½ | the same |
| Whether a transition is clipped | yes for elliptical, Haack and power series | the same |
| A filled part’s shoulder | solid | the same |
| A parachute’s line material, when the file names none or one it doesn’t define | weightless lines | the same |
| A hollow part’s shoulder wall | the part’s own wall | zero: it weighs nothing |
A clipped transition is cut from a whole nose cone, rather than stretched from one (Shapes).
A molded plastic nose cone’s shoulder is a tube of the same plastic, so a shoulder that weighs nothing would be wrong. The catalog’s stated masses agree. Of the hollow parts with a shoulder, 74 state their mass. On 46 of them, the file’s density weighs nearer the stated mass with the shoulder’s wall than without it. The median stated mass is 0.97 of the mass with the wall, and 1.30 of the mass without it.
The masses against OpenRocket
tests/catalog_openrocket.rs
builds every part in the catalog with the builder. It holds each part’s mass and center of mass
to what OpenRocket builds from it. OpenRocket is run as an oracle, and
orc_built.py
records what it builds. I set the tolerances before measuring. Every part is in one row:
| Parts | Count | Allowed | Largest difference found |
|---|---|---|---|
| Tubes, couplers, rings, bulkheads, lugs, parachutes, streamers | 2,230 | 1e-12 of the mass; center 1e-12 of the length | under 1e-14 of the mass, or 8.8e-10 where it is stated in ounces (below); center under 1e-13 of the length |
| Filled nose cones and transitions | 1,029 | 1e-3 of the mass; center 1e-3 of the length | 2.0e-4 of the mass, or 8.8e-10 in ounces; center 7.0e-5 of the length |
| Hollow nose cones and transitions, shoulders taken out | 181 | the same | 6.3e-4 of the mass, or 8.8e-10 in ounces; center 9.7e-4 of the length |
| Hollow elliptical nose cones whose walls differ | 4 | counted | up to 0.48% heavier here; center up to 1.7e-3 of the length |
| A streamer that states its mass | 1 | counted | HPR Sim weighs the stated mass; OpenRocket ignores it |
| Refused by the builder | 4 | counted | OpenRocket weighs each as nothing |
| All | 3,449 |
Where the masses differ, the test checks each cause:
-
OpenRocket’s volumes are close, not exact. Even a cone, whose volume has a formula, differs a little. The test holds HPR Sim’s 85 filled cones to that formula, so the difference is OpenRocket’s.
-
A hollow part’s shoulders are taken out of HPR Sim’s mass and center. Each is worked out on its own as a tube of the part’s wall. That leaves the body, which is what OpenRocket weighs.
-
The two programs’ walls differ. HPR Sim’s wall is every point within its thickness of the outer surface. OpenRocket’s masses follow a wall measured across each station instead. That wall’s inner radius is ( the radius, the thickness, the slope). The test works out both on its own.
All 185 hollow parts’ OpenRocket centers agree with the station-wise wall to 1.1e-4 of the length. Their masses agree to 2.5e-4, on the 111 that state no mass (a stated mass is OpenRocket’s whatever the wall). HPR Sim’s 113 hollow conical, tangent-ogive and elliptical nose cones agree with integrals of its own wall, in volume and center, to 1e-9. The other 72 hollow parts (Haack and parabolic noses, and transitions) have no such integral. They’re checked only against OpenRocket, within the tolerance.
The two walls differ most on short, blunt nose cones. Four elliptical ones fall outside the tolerance. Three are up to 0.48% heavier here, their centers up to 1.7e-3 of their length apart. The fourth, which states its mass, differs by its center alone, 1.0e-3 of its length.
-
185 parts of every kind state their mass in ounces, a different 185 from the hollow parts above. Their masses differ by OpenRocket’s rounded ounce, 8.8e-10 of the mass.
-
Of the 4 refused parts, one nose cone names a material its file doesn’t define. Three tubes or rings have a bore no narrower than their outside.
The test compares mass and center of mass, not the moments of inertia. What it checks is each part as the catalog describes it. A catalog’s sizes and densities are the makers’ or the database’s, and none was weighed here. Glue, paint and hardware are still missing: weigh the finished parts when you can.
Limits and next steps
Where the builder stops, what it refuses, and where to go from here.
Beyond the builder
The builder covers a single-stage rocket with one motor. Two ways lead further, both into the crates the builder is made of.
-
Change the design. A rocket’s
design()is its design tree, which a design file holds. Clone it, and add what the builder can’t with thehpr_designcrate (a cluster, pods, rail buttons, a stage). Then make a rocket of it withRocket::from_design(tree, configuration), which names the configuration, the motors, to fly.from_designalso takes a design file, or an OpenRocket file read as the.orkpage shows.A second stage also needs a separation, which the flight builder’s
separationtakes, and a recovery device on each part it makes. For a.ork,hpr::ork::separated_recoveryputs the file’s own devices on their parts, ashpr simdoes (Separation). Theork_two_stageexample flies one, building its simulation withSimulation::newrather than through the builder. -
Change the flight. A flight builder’s
simulation()hands over the simulationfly()would run. Themotor_choiceexample passes it tohpr_sim::metrics::optimum_delays. The simulation’s methods add a separation, events of your own, or moving or released masses.A drag model of your own, or another program’s drag table, needs no detour. The flight builder’s
drag_modelanddrag_tabletake them (Models of your own).run(&mut ())flies the simulation, with no observer watching. A flight flown that way returns the simulation’s own result, without the builder’sFlightmethods.hpr_sim::FlightMetricsgives the same metrics (Flight metrics).
What it refuses
Each part’s numbers are checked when the part is added. That catches a negative length, a NaN, a
zero diameter, zero fins, or a shape parameter out of range. The error names the number, such as
tube diameter, m is 0, but it must be finite and above 0. Most of a fin’s numbers and shape
parameters come without a bound. A part in an order the tree can’t take is checked when it’s added, too.
That’s fins before any tube, a second motor tube, or a nose behind a tube.
The launch site and wind are checked when they’re given, and the rail when the flight is set up. A
design that comes in whole through from_design is checked before it flies.
Tests try each of these checks and pin which check refuses it
(parts_out_of_order_are_refused, degenerate_designs_error_or_stay_finite).
One rocket in them has no fins at all. It flies, tumbling, to finite numbers. That test belongs to
a Loft lesson, the one
on degenerate designs.
A catalog part is refused when the builder can’t make it as the catalog describes it:
- a part of another kind than the
from_catalogit’s given (a body tube given toNose::from_catalog); - a material its file names but doesn’t define;
- a shape the builder doesn’t have;
- a nose cone or transition the file neither fills nor gives a wall thickness;
- a tube or ring whose bore is no narrower than its outside;
- a part stating a mass with no volume to give it.
The error names the part by maker, number and file. Rocket::add_fitting also refuses a fitting
before any body tube, and a part that isn’t a fitting.
What it can’t do yet
- The builder makes one stage with one motor. Clusters, staging and pods go through the design, as above. The staging page explains how they fly.
- Rail buttons go through the design. Without them the rocket leaves the rail when its aft end passes the rail’s top. A launch lug is a fitting (above), with its drag. Without one, a lug’s drag is missing. With one, the rocket leaves the rail when the lug’s aft edge passes the rail’s top.
- The builder can’t change the finish. Every surface is painted, as above.
Where next
- Models of your own flies a drag model and a wind of your own in the simulator’s place.
- The API reference’s
guidemodule is this page’s walk-through in five short chapters, each with code that CI runs. - The API reference documents every method, starting at the
hprcrate. - Your own rocket builds the same rocket without the builder, and shows every field a part has.
- Recording a trajectory keeps the flight’s path: pass a recorder to
fly_withinstead of callingfly.
Python
Fly a rocket from Python with the fusionspace-hpr package, once or as a Monte Carlo run, and get
its recording back as NumPy arrays.
The fusionspace-hpr package has the same four types as the Rust builder: an
Environment, a Motor, a Rocket and a Flight. You describe the rocket part by part from the
nose back, or read it from a design file. Then you fly it from a rail: once, or many times with
its inputs scattered, as a MonteCarlo run.
A flight’s metrics come back as numbers and dictionaries. Its recording and a run’s flights come
back as NumPy arrays. You need Python 3.10 or later and some familiarity
with it. pip install fusionspace-hpr installs it (Install it).
On two of RocketPy’s example rockets, HPR Sim’s drift and RocketPy’s differ by 10 to 38% (Getting started explains why).
The package is new and covers less than the Rust library (What is not here yet). If you
bring a design file, the gap that matters most is that a .ork configuration with a stage
separation to fly is refused. The package also doesn’t fetch a missing thrust curve from
ThrustCurve.org, as hpr sim does. So a configuration whose motor has no curve in the file or the
bundled catalog is refused too (A design from a file). The package is built and tested on Linux, macOS
and Windows. It’s published on PyPI, Python’s package index, as fusionspace-hpr.
First steps
Install the package, fly a first rocket, and read its recording.
Install it
pip install fusionspace-hpr installs release 0.1.0 from PyPI, with NumPy. One wheel serves
CPython 3.10 and later on Linux on x86-64, on Macs with Apple silicon, and on Windows on x86-64.
The Linux wheel needs glibc 2.17 or later. On any other system, or on Linux with an older glibc,
pip builds the source package, which needs Rust
(Install a release).
You can also build it from this repository. You need the Rust toolchain from Getting started and maturin, the tool that builds Python packages from Rust. From the repository’s root, make a virtual environment and build into it:
python3 -m venv .venv
source .venv/bin/activate # on Windows: .venv\Scripts\activate
pip install maturin
maturin develop --release --manifest-path crates/hpr-py/Cargo.toml
maturin develop builds the package and installs it into the environment, with NumPy. It links
the environment to the build, so after a change to the Rust code, run it again.
To install elsewhere, build a wheel instead, the file pip install takes:
maturin build --release --manifest-path crates/hpr-py/Cargo.toml writes it to target/wheels/.
One wheel serves every CPython (the standard Python) from 3.10 on (tested on 3.10 and 3.13), on
the operating system and processor that built it. scripts/python-tests.sh builds one and runs the package’s tests on it,
which needs uv.
The package’s distribution name, the one pip lists, is fusionspace-hpr, and it imports as
fusionspace.hpr. The examples here write from fusionspace import hpr, so the rest of the code
says hpr.Rocket, hpr.Flight and so on. import fusionspace.hpr as hpr does the same.
fusionspace is a namespace that other FusionSpace packages can share; it holds nothing itself.
A first flight
This builds a simpler version of the rocket in Your own rocket and The builder. It’s a 54 mm (2.1 in) airframe with an ogive nose, three fins and a Cesaroni H54. Its recovery bay here is a point mass, and its nose has no shoulder. It flies from a 1.8 m (5.9 ft) rail leaning 5° into a 5 m/s (11 mph) west wind. The motor’s ejection charge opens a parachute at the end of its ejection delay.
from fusionspace import hpr
environment = hpr.Environment(32.99, -106.97, 1400.0, wind_speed_m_s=5.0, wind_from_deg=270.0)
rocket = hpr.Rocket("My 54 mm rocket", 0.0563)
rocket.add_nose("ogive", 0.22, "abs", wall_m=0.0015)
rocket.add_tube(0.9, 0.00115, "kraft_phenolic")
rocket.add_motor_tube(0.2, 0.029, 0.001, "kraft_phenolic", overhang_m=0.005)
rocket.add_fins(
3,
root_chord_m=0.1,
tip_chord_m=0.04,
span_m=0.045,
sweep_m=0.05,
thickness_m=0.003175,
material="birch_plywood",
cross_section="rounded",
)
rocket.add_mass(0.2, position="top", offset_m=0.07, name="recovery bay")
rocket.set_motor(hpr.Motor.from_catalog("H54", delay_s=10.0))
rocket.add_parachute("parachute", diameter_m=0.9, trigger="motor_delay")
print(f"Stability at liftoff: {rocket.static_margin_cal(0.0, 0.3):.2f} calibers")
flight = hpr.Flight(rocket, environment, 1.8, inclination_deg=85.0, heading_deg=270.0)
print(f"Apogee: {flight.apogee_m:.1f} m at {flight.apogee_time_s:.2f} s")
print(f"Top speed: {flight.max_speed_m_s:.0f} m/s (Mach {flight.max_mach:.2f})")
landing = flight.landing
print(f"Landing: {landing['distance_m']:.0f} m from the pad, descending at {landing['descent_rate_m_s']:.1f} m/s")
It prints:
Stability at liftoff: 2.12 calibers
Apogee: 1118.3 m at 13.67 s
Top speed: 190 m/s (Mach 0.57)
Landing: 905 m from the pad, descending at 4.6 m/s
Line by line:
Environmenttakes the launch site’s latitude and longitude in degrees (longitude positive east, so negative in the Americas) and its elevation in meters. The air is the US Standard Atmosphere 1976. The wind is the same at every height, and blows fromwind_from_deg, clockwise from north.Rockettakes a name and the airframe’s outside diameter, m.- The nose is a tangent ogive 0.22 m (8.7 in) long, of ABS, hollow with a 1.5 mm (0.059 in) wall. The tube is 0.9 m (35.4 in) long with a 1.15 mm (0.045 in) wall. The motor tube is 0.2 m (7.9 in) long, with a 29 mm (1.1 in) bore and a 1 mm (0.039 in) wall.
- Parts go on from the nose back: the nose, then tubes. Fins, a motor tube and masses go on or in the tube before them.
- Each part names its material by an id from the built-in list,
hpr.materials(). It takes its mass from its shape and that material’s density. - The fins’ lengths are named, so a swap shows in the call. They’re the root chord, tip chord and span, and the sweep. The sweep is how far aft of the root’s leading edge the tip’s is.
Motor.from_catalogfinds one of the 924 bundled motors with a curve by its name. It doesn’t take the delay from the designation (the H54’s full one is 168H54-10A). So give it asdelay_s: a parachute opened by the motor needs one. A motor whose bundled file is more than 1% from ThrustCurve.org’s figures, or that fails a mass check, still flies.from_catalogissues aUserWarningfor each problem (it doesn’t stop the script), and the motor’swarningskeeps them. Check such a file against the maker’s data.Motor.from_filereads a RASP.engor RockSim.rsefile.static_margin_cal(0.0, 0.3)is the stability margin at ignition (0 s) and Mach 0.3.Flightflies the rocket as soon as it is made. The rail is 1.8 m (5.9 ft) long and leansinclination_degabove the horizon, 90 by default, towardheading_deg, clockwise from north.- The landing’s
descent_rate_m_sis how fast it comes down. Itsground_hit_speed_m_sis faster, as it adds the wind’s drift.
The stability margin is the distance from the center of gravity back to the center of pressure, in body diameters (calibers). It’s 2.12 here and 1.92 in The builder’s example.
That example packs its 200 g recovery bay into a 15 cm (5.9 in) cylinder. This moves the bay’s
center aft, and with it the rocket’s center of gravity: about 0.4 calibers less. It also gives the nose a
capped shoulder, which adds mass at the front: about 0.2 calibers more. A test holds both steps to
these sizes
(test_the_margin_moves_as_the_python_page_says).
The recording
A flight is recorded at every step of the integrator, or every
interval_s seconds (at least 0.001 s) if you give Flight one. Either way there’s a row at every
event too. flight.columns names the columns, each with its unit, and flight["name"] gives one as a NumPy
array. flight.series gives them all, as a dictionary of arrays. Continuing from above:
height_m = flight["height_above_ground_m"]
time_s = flight["time_s"]
print(len(flight.columns), "columns:", ", ".join(flight.columns[:3]), "...")
print(f"Highest recorded height: {height_m.max():.1f} m at {time_s[height_m.argmax()]:.2f} s")
for event in flight.events[:4]:
print(f"{event['kind']:>10} at {event['time_s']:6.3f} s")
30 columns: time_s, position_east_m, position_north_m ...
Highest recorded height: 1118.3 m at 13.67 s
liftoff at 0.001 s
rail_exit at 0.174 s
burnout at 3.500 s
trigger at 13.500 s
The columns are the ones Recording a trajectory lists. They’re time, position and velocity east, north and up of the pad, attitude, height, airspeed, Mach number, angle of attack, thrust, mass and more. Heights are the center of gravity’s, above the pad. The rocket stands on the rail at the start, so the first height isn’t zero.
The arrays are read-only copies, so a slip can’t change the flight’s record. To plot one, hand the
arrays to any plotting library, for example matplotlib.pyplot.plot(time_s, height_m).
flight.events lists what happened, in the order it happened. Each event is a dictionary. It
holds its kind, the index of the parachute or motor it is about, its time_s, and the flight’s state
then, sample. The kinds are "liftoff", "rail_exit", "burnout", "apogee", "trigger" (a
parachute’s charge fires), "deployment" (it is open) and "ground_hit". Here the parachute’s
charge fires at 13.5 s, the H54’s 3.5 s burn plus its 10 s delay, 0.17 s before apogee.
flight.landing is a dictionary of the landing. It holds its time_s, latitude_deg,
longitude_deg, east_m and north_m of the pad, distance_m, ground_hit_speed_m_s and
descent_rate_m_s. Its body says which separated body landed (None for a rocket that didn’t
come apart). flight.summary has every metric of the flight as a dictionary. They’re the apogee,
top speed, Mach number and dynamic pressure, the stability margins and the landings, each explained
in Flight metrics.
flight.envelope_flags lists where the flight went past what the simulator’s numbers have been
checked for (the operating envelope). It also lists
"unstable_under_power" for a static margin below zero while a motor burns. Or, where the
simulator can give no margin, it lists "unstable_without_margin" for a pitching moment that turns
the rocket away while a motor burns.
Flight metrics: unstable under power explains both.
Each entry is a dictionary with its flag, such as "beyond_validated_range", and the value
that raised it. That’s a Mach number, an angle of attack in radians, a margin in calibers, or a
pitch-moment slope per radian. It also holds its time_s and height_above_ground_m, and a
message. The list is empty for a flight that raises none.
flight.issue_warnings lists the known errors in the simulator’s drag, stability or flight path
the flight meets (the list). Each warning is a dictionary
with its issue number, such as 67, its kind ("drag", "stability" or "flight"), and its
url. It also holds the flight’s max_mach and its time_s, the parts whose shape meets it, and a
message saying which way its numbers lean. flight.to_json() is the whole record as JSON text.
Files and RocketPy
Fly a design read from a file, and fly RocketPy’s example rocket as the validation suite flies it.
A design from a file
Rocket.from_file reads a design instead of building one. The design can be a file in
the HPR design format (.hpr or .hprz), an OpenRocket .ork file (.ork
design files), or a rocket’s JSON. It flies the
motor configuration you name, or the file’s default one, or its only
one, as hpr sim does.
A configuration flies if every motor has a thrust curve, in the file or in the simulator’s bundled
catalog, the reader takes its airframe and stages as written, and the reader finds no stage
separation to fly in it. A stage set to separate at apogee, or at a height on the way down, is
not one: that separation belongs to the descent, and the stack flies whole
(When parachutes open and stages separate).
Otherwise from_file raises HprError and says why. With the file’s own curves and the bundled
catalog, the reader finds 154 of the 170 configurations in the reference library and
OpenRocket’s examples it can fly (cargo xtask ork counts them). Python flies those of the 154
with no separation to fly. Python can’t yet swap in a motor as hpr sim --motor does.
A configuration that lights a motor at its stage’s separation is refused too. In a rocket’s JSON
or an HPR design, that is a motor with "ignition": {"separation": …}
(When a motor lights). Python flies no separation, so
that motor would never light, and the apogee would read low. from_file raises HprError and
names the motor, as hpr sim refuses the same file. To fly such a file from Python, pass
configuration= for a configuration whose motors light without a separation, or change that
motor’s ignition in the file. The Rust library flies the staged flight
(Staging).
A design of several stages that does fly, flies as one stack: no stage drops away, and
rocket.notes says so.
A design read from a file flies without the parachutes it stores, unless you ask for them
with recovery=True. Rocket.from_file("validation/fixtures/ork/guides/level-1.ork", recovery=True) flies the file’s devices as hpr sim does. Each opens fully at its event, with
the file’s drag coefficient or OpenRocket’s own (When parachutes open and stages separate).
Without that option, add parachutes with add_parachute. Until you do, the rocket falls to the
ground unslowed, and its landing numbers mean nothing. Parachutes added after recovery=True come
after the file’s, so the file’s first is parachute 0 for released_by. Stage separations are never
flown.
rocket.notes lists what reading the file said. It holds the .ork reader’s warnings, and notes
a design written by an older version of the format. It also notes what the file holds that isn’t
flown, and a file’s parachute that never opens in the configuration flown. A file’s recovery the
simulator can’t fly, such as a device opened by an event it doesn’t read, raises HprError with
why.
This one is RocketPy’s example rocket, Calisto, from the file the validation suite uses, with its two parachutes as RocketPy’s example gives them. The path is the repository’s, so run it from the repository’s root:
calisto = hpr.Rocket.from_file("validation/designs/rocketpy-calisto-tests-motor-at-minus-1.373.json")
calisto.add_parachute("drogue", cd_s_m2=1.0, lag_s=1.5)
calisto.add_parachute("main", cd_s_m2=10.0, trigger="altitude", altitude_m=800.0, lag_s=1.5)
site = hpr.Environment(32.990254, -106.974998, 1400.0)
flight = hpr.Flight(calisto, site, 5.2, inclination_deg=85.0)
print(f"{calisto.configuration}: apogee {flight.apogee_m:.0f} m, landing at {flight.landing['descent_rate_m_s']:.1f} m/s")
example: apogee 2841 m, landing at 5.2 m/s
This flight uses HPR Sim’s own drag, in calm air. The validation suite flies the same design with HPR Sim’s own drag too, in a wind and in RocketPy’s atmosphere. There its apogee is 0.601% above RocketPy’s, the closest of the suite’s six rockets. HPR Sim’s own drag puts the others’ apogees from 7.280% below RocketPy’s to 10.302% above (Whole flights with each code’s own drag, same-drag and predicted mode).
RocketPy’s example, flown as the suite flies it
Here Calisto flies again from Python, this time the way the validation suite flies it against RocketPy. It’s for checking HPR Sim against RocketPy, or for moving a RocketPy script across. Both codes fly the same drag and the same inputs. So the comparison tests the rest of the physics: the equations of motion, the atmosphere, the rail and the parachutes. It’s a comparison between two codes, not with a real flight.
Three options make it RocketPy’s flight:
- A drag table.
DragTableholds a zero-lift drag coefficient against Mach number, as RocketPy’spower_off_dragandpower_on_dragdo. Its power-on curve is flown while the motor burns, its power-off curve the rest of the time. Pass it to a flight asdrag_table=; it replaces the simulator’s own drag, and nothing else.DragTable.from_csvreads RocketPy’s two-column drag files. - RocketPy’s gravity.
Environment(..., gravity="vertical_taylor")uses RocketPy’s formula for gravity instead of HPR Sim’s default. Near the ground the two differ in size by about one part in . But HPR Sim’s default also turns with the rocket’s position over the ground. On this flight the switch moves the apogee by 2 parts in and the landing point by 0.3 m (1.0 ft); see Gravity. - One parachute at a time. RocketPy flies only the last parachute to open, and HPR Sim adds
together every one that is open.
released_byis another parachute’s number, counted from 0 in the order they were added.add_parachute(..., released_by=1)cuts this one away once the second parachute is fully open (Recovery).
Here is an invented table with less drag while the motor burns. Calisto flies it in calm air, as in the section above, to 2,650 m (8,694 ft) above the pad:
table = hpr.DragTable([(0.0, 0.5), (3.0, 0.5)], [(0.0, 0.45), (3.0, 0.45)])
print(f"C_D0 at Mach 0.6: {table.cd0(0.6):.2f} coasting, {table.cd0(0.6, thrusting=True):.2f} burning")
flight = hpr.Flight(calisto, site, 5.2, inclination_deg=85.0, drag_table=table)
print(f"apogee {flight.apogee_m:.0f} m")
C_D0 at Mach 0.6: 0.50 coasting, 0.45 burning
apogee 2650 m
The example
crates/hpr-py/examples/calisto.py
puts it all together. It’s written as notebook cells (# %%), which editors such as VS Code run
one at a time. It reads the rocket, the wind, the drag and the parachutes from the repository’s
files, then flies them. Then it measures each metric as RocketPy defines it, and not always as
HPR Sim’s own summary does:
- RocketPy follows the rocket’s dry center of mass, its center of mass without propellant, and starts that point at ground level. HPR Sim stands the rocket on its rail, so the same point starts 1.250 m (4.10 ft) up (the first line printed below). The example subtracts 1.250 m (4.10 ft) from every height, and opens the main 1.250 m (4.10 ft) above RocketPy’s 800 m (2,625 ft).
- RocketPy’s rail exit is when its forward rail button leaves the rail, after 3.745 m (12.29 ft) of
travel (RocketPy’s
effective_1rl). HPR Sim’s is when its aft-most rail guide clears the top of the 5.2 m (17 ft) rail, after 4.45 m (14.6 ft) of travel. So the example reads RocketPy’s off the recording. - RocketPy’s flight ends when the dry center of mass is back at its starting height.
Run from the repository’s root, python crates/hpr-py/examples/calisto.py prints:
The dry center of mass starts 1.250 m above the ground.
metric hpr RocketPy difference
apogee_agl_m 2613.59 2612.22 +0.05%
apogee_time_s 22.88 22.85 +0.10%
max_speed_m_s 243.56 243.52 +0.01%
max_mach 0.7321 0.7329 -0.12%
max_acceleration_m_s2 112.35 112.24 +0.10%
max_acceleration_power_on_m_s2 112.35 112.24 +0.10%
rail_exit_speed_m_s 28.20 28.20 -0.01%
rail_exit_time_s 0.2945 0.2947 -0.07%
burnout_altitude_agl_m 684.23 684.10 +0.02%
burnout_speed_m_s 235.65 235.60 +0.02%
flight_time_s 260.86 260.53 +0.12%
apogee_drift_m 422.52 426.36 -0.90%
landing_drift_m 1277.36 1261.50 +1.26%
impact_speed_m_s 5.4549 5.4560 -0.02%
largest difference 1.26%, within 3%: True
Every metric is within 3% of RocketPy’s, the widest of the suite’s
gates. These are the suite’s numbers. A
test holds each to within 0.001% of what the suite’s report records for the same flight
(test_calisto.py).
Because both codes fly the same drag, this says nothing about HPR Sim’s own drag, the largest source of difference. Flying its own drag, HPR Sim puts the suite’s six rockets’ apogees 7.280% below RocketPy’s to 10.302% above, as the section before says. The drifts differ most here. Juno III and Bella Lui are two of RocketPy’s other example rockets. On them, flown in a wind, HPR Sim’s drift and RocketPy’s differ by 10 to 38% (Getting started explains why).
Drag, wind and scatter
Fly a drag and a wind you write in Python, and fly a rocket many times with its inputs scattered.
Drag and wind of your own
A flight can fly a drag and a wind you write as Python functions. They take the place of the simulator’s own drag and the environment’s wind. A drag curve from a wind tunnel or another program is one example, and a wind profile from a weather balloon another.
The simulator calls them as it flies, several times for each time step of its integrator. It keeps everything else its own: the rest of the aerodynamics, the thrust, the masses and the atmosphere. They’re the Python side of the Rust library’s models of your own.
| Given as | Called as | Returns |
|---|---|---|
Flight(..., drag=f) | f(mach, thrusting), with thrusting true while a motor burns | the whole rocket’s zero-lift drag coefficient , on its reference area (the largest body diameter’s circle) |
Environment(..., wind=f) | f(height_m), the height above sea level in meters, not above the launch site | the air’s velocity (east_m_s, north_m_s), as a tuple, list or array |
Three things about the drag number, as for a Rust drag model:
- It is not rescaled. A
DragTablecan carry the diameter it was measured on; a function’s number must already be on the rocket’s reference area. - At an angle of attack the simulator scales it, as it scales its own.
- Under a parachute the drag is the parachute’s, not the function’s.
The wind’s two numbers are the way the air moves, so a wind from the west is (+speed, 0). That’s
the opposite of wind_from_deg, which names where the wind comes from.
Here the drag rises through Mach 0.8 to 1.1 and drops 10% under power, and the wind strengthens with height:
def drag(mach, thrusting):
"""0.5 below Mach 0.8, rising to 0.8 by Mach 1.1; 10% less while the motor burns."""
rise = min(max((mach - 0.8) / 0.3, 0.0), 1.0)
cd0 = 0.5 + 0.3 * rise
return 0.9 * cd0 if thrusting else cd0
def wind(height_m):
"""From the west, 3 m/s at the 1400 m site, 1 m/s stronger every 100 m above it."""
above_m = max(height_m - 1400.0, 0.0)
return (3.0 + above_m / 100.0, 0.0)
windy = hpr.Environment(32.99, -106.97, 1400.0, wind=wind)
flight = hpr.Flight(rocket, windy, 1.8, drag=drag)
print(f"apogee {flight.apogee_m:.0f} m, landed {flight.landing['east_m']:.0f} m east")
table = hpr.DragTable([(0.0, 0.5), (3.0, 0.5)])
same = hpr.Flight(rocket, windy, 1.8, drag=lambda mach, thrusting: 0.5)
print(same.apogee_m == hpr.Flight(rocket, windy, 1.8, drag_table=table).apogee_m)
def refuses(mach, thrusting):
if mach > 0.3:
raise LookupError("no drag measured past Mach 0.3")
return 0.5
try:
hpr.Flight(rocket, windy, 1.8, drag=refuses)
except LookupError as error:
print(type(error).__name__, error)
apogee 1109 m, landed 1963 m east
True
LookupError no drag measured past Mach 0.3
A function that always returns the same number flies as a drag table of that number does. At 0.5 the two agree to the last digit. At some numbers, 0.3 or 0.45 say, they differ in the eleventh, because the table’s interpolation rounds its own constant.
A function that raises stops the flight, and Flight raises its exception unchanged, with its
type and traceback. That holds even for an exception at a trial step.
The integrator tries a step, and when a model refuses, it would normally retry with a shorter one. It asks at speeds and heights a little past the flight’s own. The landing’s search, for one, asks the wind a few meters below the ground. So a function that refuses past its data wants some margin.
A function can’t be given alongside its constant counterpart. drag with drag_table, or wind
with wind_speed_m_s or wind_from_deg, raises hpr.HprError. So does something that can’t be
called, a drag coefficient that is negative or not finite, or a wind that isn’t finite. An answer
of the wrong type, such as a string, raises Python’s TypeError.
Each call takes Python’s global interpreter lock. So a flight with a Python function runs slower than one without, and flights in other threads wait while it calls. The functions should give the same answer to the same question, or a flight can’t be repeated.
Monte Carlo
A Monte Carlo run flies the rocket many times, to show how far the apogee and the landing spread. Each time, its uncertain inputs are drawn afresh about their planned values. Monte Carlo dispersion explains the method and how to choose the numbers.
hpr.MonteCarlo takes the rocket, the site and the rail as Flight does (a vertical rail by
default). It also takes how many flights to fly (100 by default) and a seed (0
by default). And it takes one standard deviation for each input
to scatter. That’s a fraction for a share (impulse_sd_fraction=0.03 is 3%), degrees for an angle,
and meters or seconds otherwise. An input left out isn’t scattered.
Like Flight, it flies as soon as it’s made, with its flights spread over the computer’s cores.
The spread it shows is only as good as the standard deviations you give and the simulator’s flight
models. Those models aren’t yet checked against repeated real flights (Accuracy).
Where a rocket lands in a wind is the least certain number of all.
The run reads as a dictionary of NumPy arrays, one value a flight. The arrays hold what each flight
drew (motor_1_impulse_scale, drag_scale and the rest) and what it came to (apogee_m,
landing_distance_m, max_mach and the rest). run.columns lists them, in the order of
hpr mc --export’s CSV columns. This flies a level 1 certification rocket’s
.ork design 200 times from a 1.5 m (4.9 ft) vertical rail. It flies its default motor
configuration, with the parachute stored in its file (recovery=True,
A design from a file):
import numpy
level_1 = hpr.Rocket.from_file("validation/fixtures/ork/guides/level-1.ork", recovery=True)
windy = hpr.Environment(0.0, 0.0, 0.0, wind_speed_m_s=4.0, wind_from_deg=270.0)
run = hpr.MonteCarlo(
level_1, windy, 1.5, runs=200, seed=2026,
mass_sd_fraction=0.02, drag_sd_fraction=0.05, impulse_sd_fraction=0.03,
wind_sd_fraction=0.25, wind_from_sd_deg=15.0,
)
apogee = run.spread("apogee_m")
print(f"{run.flown} of {run.runs} flights flown, {run.failed} failed")
print(f"apogee: mean {apogee['mean']:.0f} m, 5% to 95% "
f"{apogee['p05']:.0f} to {apogee['p95']:.0f} m")
print(f"mean landing: {numpy.nanmean(run['landing_east_m']):.0f} m east of the pad")
200 of 200 flights flown, 0 failed
apogee: mean 1069 m, 5% to 95% 1002 to 1134 m
mean landing: 842 m east of the pad
The command line flies the same run: hpr mc validation/fixtures/ork/guides/level-1.ork --runs 200 --seed 2026 --wind 4 --wind-from 270 --mass-sd 0.02 --drag-sd 0.05 --impulse-sd 0.03 --wind-sd 0.25 --wind-from-sd 15. run.to_csv() returns the text hpr mc --export writes.
A test holds the two equal
(test_a_run_is_hpr_mcs_bit_for_bit).
It flies 40 flights of this design with all eleven inputs scattered. It finds every number of
every column equal, bit for bit, and the two CSV texts equal byte for byte. That holds on one
platform, with both built in release mode (maturin develop --release, cargo build --release).
A debug build’s last digits can differ.
A flight that fails, such as one whose drawn mass is negative, is counted and kept, never
dropped. run.failed counts them. run.failures groups them by why, a dictionary each: at,
"inputs" or "flight"; reason; count; and first_index, the first one’s row. The
outcome, failed_at and reason columns say which they were.
A failed flight’s figures are NaN. run.spread(name) takes a column of numbers, such as
"apogee_m" or "landing_distance_m", and returns a dictionary of its spread over the flights
that have a value: attempted, count, mean, standard_deviation, min, p05, p50, p95
and max. NumPy’s nanmean and nanpercentile give the same figures to rounding. Both leave
the failed flights out, so if those would have flown highest, the 95% reads low.
The dictionary also has p05_counting_missing and p95_counting_missing: the 5% and 95% with
each failed flight placed past that end, the worst case they allow
(Failed flights are counted). Each is None when
every flight has a value, and -inf (the 5%) or inf (the 95%) when too many failed for the
run to bound it. So check for None before formatting one.
run.nominal is the flight with nothing scattered, as Flight.summary gives it, and
run.dispersion the standard deviations given, by name.
The eleven inputs, each named for its unit:
| argument | one standard deviation of |
|---|---|
mass_sd_fraction | each stage’s mass without its motors, as a fraction of it |
cg_sd_m | each stage’s center of mass along the axis, m |
drag_sd_fraction | the rocket’s zero-lift drag coefficient, as a fraction of it: the simulator’s own, a drag_table’s or a drag function’s |
impulse_sd_fraction | each motor’s total impulse, as a fraction of it; its propellant mass scales with it |
burn_time_sd_fraction | each motor’s burn time, as a fraction of it, at the same impulse |
delay_sd_s | each motor’s ejection delay, s |
wind_sd_fraction | the wind’s speed at every height, as a fraction of it |
wind_from_sd_deg | the wind’s direction, degrees |
inclination_sd_deg | the rail’s angle above the horizon, degrees |
heading_sd_deg | the rail’s heading, degrees |
deployment_lag_sd_s | each parachute’s lag after its trigger, s |
A drag or wind function of your own is called from every flight of the run, one call at a
time. An exception it raises stops the run, and MonteCarlo raises it. The calls come in no set
order, so a run repeats bit for bit only if the function’s answer depends on its arguments alone.
A run takes 1 to 100,000 flights. A standard deviation that is negative or not finite raises
hpr.HprError, named by its argument.
Reference and limits
The errors the package raises, how it names values and units, every call it has, and what it can’t do yet.
When something is wrong
A value out of its range, a part out of order, or a motor or material that isn’t there raises
hpr.HprError. It’s a kind of ValueError, and it carries the library’s own message. An argument
that doesn’t apply raises it too, such as a canopy beside a cd_s_m2:
try:
hpr.Motor.from_catalog("Z9000")
except hpr.HprError as error:
print(error)
no motor in the bundled catalog matches `Z9000`
Names and units
Every value is in SI units. Every argument and attribute that carries one names it, as the Rust
API does: length_m, mass_kg, apogee_m, max_speed_m_s, wind_from_deg. Names that pick one
of several things are strings, in any case. A space or hyphen is allowed where the name has an
underscore:
| argument | the choices |
|---|---|
a nose’s or transition’s shape | "conical", "ogive", "elliptical", "power_series", "parabolic_series", "haack" (Shapes). parameter is an ogive’s radius ratio (1, a tangent ogive, by default), a Haack series’ (0, the von Kármán, by default), and a power series’ exponent or a parabolic series’ , which those two need |
fins’ cross_section | "square" (the default), "rounded", "airfoil" |
a part’s position | "top", "middle", "bottom" or "after" the tube it is in, then offset_m aft of that. A mass is at the top by default; fins and a motor tube sit flush with the tube’s aft end |
a parachute’s trigger | "apogee" (the default); "altitude" with altitude_m, on the way down past that height above the pad; "time" with time_s after launch; "motor_delay" with motor, the motor’s number (0, the first, by default) |
a parachute’s canopy | "flat_circular" (the default), "conical", "biconical", "triconical", "extended_skirt10_flat", "extended_skirt14_full", "hemispherical", "annular", "cross", "flat_ribbon", "conical_ribbon", "ringslot", "ringsail" (Recovery) |
A parachute is either a canopy diameter_m across, with its type’s drag coefficient or your own
drag_coefficient, or a drag area cd_s_m2. A drag area is the
parachute’s drag coefficient times its area in m², as RocketPy’s cd_s is.
Every class and method
| call | what it does |
|---|---|
Environment(latitude_deg, longitude_deg, elevation_m, wind_speed_m_s=, wind_from_deg=, gravity=, wind=) | the launch site, a wind, and the gravity model: "ellipsoidal" (the default), "vertical" or "vertical_taylor" (RocketPy’s); wind= is a wind function, wind(height_m) -> (east_m_s, north_m_s) (Drag and wind of your own) |
DragTable(power_off, power_on=, reference_diameter_m=), DragTable.from_csv(power_off, power_on=, reference_diameter_m=) | a drag coefficient against Mach number, from (mach, cd) rows or CSV files; its cd0(mach, thrusting=), has_power_on and reference_diameter_m |
Motor.from_catalog(name, delay_s=), Motor.from_file(path, delay_s=), Motor.from_eng(text, delay_s=), Motor.from_rse(text, delay_s=) | a motor; its designation, diameter_m, length_m, delay_s, total_impulse_ns, propellant_mass_kg, warnings (the problems found with a catalog motor’s file) and thrust_curve(), two arrays |
Rocket(name, diameter_m), Rocket.from_file(path, configuration=, recovery=) | a rocket, built or read, with the file’s parachutes when recovery=True; its name, configuration and notes |
add_nose(shape, length_m, material, wall_m=, parameter=, shoulder_length_m=, shoulder_wall_m=, capped_shoulder=, name=) | the nose: hollow with wall_m, solid without; a shoulder, capped or not |
add_tube(length_m, wall_m, material, diameter_m=, name=) | a body tube |
add_transition(length_m, aft_diameter_m, wall_m, material, shape=, parameter=, solid=, name=) | a shoulder or boattail between tubes |
add_fins(count, root_chord_m=, tip_chord_m=, span_m=, sweep_m=, thickness_m=, material=, cross_section=, cant_deg=, position=, offset_m=, name=) | trapezoidal fins |
add_motor_tube(length_m, inner_diameter_m, wall_m, material, overhang_m=, position=, offset_m=, name=) | the motor tube |
add_mass(mass_kg, position=, offset_m=, packed_length_m=, packed_diameter_m=, name=) | a mass, at a point or packed in a cylinder |
set_motor(motor), add_parachute(name, ..., released_by=) | the motor, and a parachute, cut away once parachute released_by is fully open |
mass_properties(time_s=), static_margin_cal(time_s=, mach=), margin(time_s=, mach=), design_json() | the mass, center of gravity and inertia; the margin; the design as JSON |
Flight(rocket, environment, rail_length_m, inclination_deg=, heading_deg=, interval_s=, drag_table=, drag=) | the flight, drag= a drag function, drag(mach, thrusting) -> C_D0 (Drag and wind of your own); its apogee_m, apogee_time_s, max_speed_m_s, max_mach, rail_exit_speed_m_s, landing, envelope_flags, issue_warnings, summary, events, columns, series, flight[name] and to_json() |
MonteCarlo(rocket, environment, rail_length_m, runs=, seed=, inclination_deg=, heading_deg=, drag_table=, drag=, mass_sd_fraction=, ...) | a Monte Carlo run, the eleven standard deviations as Monte Carlo lists them; its runs, seed, flown, failed, failures, nominal, dispersion, columns, run[name], spread(name) and to_csv() |
FlightLog.read(path, mapping=, layout=, sheet=, recording=, fip_header=), FlightLog.header_mapping(path, sheet=) | a flight log, read by its format’s own reader, by a column mapping, by a record layout or, for a Raven FIP export below no header, by a FIP header, each a dict or a JSON file’s path (Reading your own logger); sheet= picks a workbook’s sheet, recording= a raw dump’s recording, each from 0 (A file of several records); its format, logger, serial_number, firmware, flight_number, time_s, altitude_m, channels, events, stated, notes, to_dict(), smoothed(), the smoother’s track and health card, and readings(), a dict of the liftoff, apogee, max_speed, max_acceleration and landing readings hpr analyze takes, each within its bound, some with a 90% interval, or withheld (Flight-log readings); and what a table’s header states, as a mapping to edit |
An argument written name= above can be left out, and is given by name. add_fins’ lengths
have no default, but are named too. Each class and method has a docstring that says what its
arguments mean: help(hpr.Rocket.add_fins), for example. The Rust reference for the package, hpr_py, says how it is
built.
What is not here yet
The package covers the Rust builder, not the whole library. Not yet:
- An atmosphere written in Python. Rust programs have one today (Models of your own).
- Staging and mass shifts. A configuration with a stage separation to fly is refused. So is one
that lights a motor at its stage’s separation, as a rocket’s JSON or an HPR design can. A
design of several stages that does fly, flies as one stack, and no stage drops away. A motor
lit by another’s burnout lights on the whole stack.
rocket.notessays so. - Swapping a motor into a design read from a file, as
hpr sim --motordoes. - Separations stored in a design file, as above.
- Monte Carlo’s landing ellipses, which
hpr mcprints and Rust programs get fromhpr_analysis. From Python, NumPy finds them from the run’s landing arrays. - The library’s built-in winds that change with height (power law, log law, layers) and weather files fly only from Rust. From Python you can write any of them as a wind function (Drag and wind of your own).
- Parts from a parts catalog, which only Rust programs build with (Parts from a catalog).
- Type stubs, so an editor sees the docstrings but not the arguments’ types.
Models of your own
Replace one of HPR Sim’s models with your own drag curve, wind profile or atmosphere, and fly a rocket with it.
This page shows how to fly a model of your own in place of one of HPR Sim’s. It can be a drag model, a wind, or an atmosphere. You might have a drag curve from a wind tunnel, from another program, or from your own flights. Or you might have a wind profile from a weather balloon that none of the built-in winds fits.
The page runs two example programs and walks through them. It follows on from The builder, and needs some Rust. From Python, a drag and a wind can be plain functions (Python).
A test
(a_drag_model_is_flown_in_place_of_hprs_drag)
pins two things. A model that returns the simulator’s own drag flies the same flight, bit for
bit, as flying without one. A model with the same drag at every speed flies exactly as a drag
table of that value does.
Which models you can replace
Each is a Rust trait: a set of methods your own type provides. Write the type, give it the method, and hand it over.
| Model | What your type gives | How to fly it |
|---|---|---|
Drag, DragModel | The rocket’s zero-lift drag coefficient at a flow | Flight::builder(...).drag_model(model) |
Wind, Wind | The wind’s velocity at a height | Environment::with_wind(wind) |
Atmosphere, Atmosphere | The air’s pressure, temperature, density, speed of sound and viscosity at a height | Environment::with_atmosphere(air) |
The zero-lift drag coefficient is the drag with the rocket pointed straight into the air, divided by the dynamic pressure and the rocket’s reference area. By default that’s the area of a circle of the rocket’s largest body diameter. A drag model replaces that number and nothing else:
- At an angle of attack, the simulator scales your number up and down with the angle as it scales its own (Drag).
- The normal force, center of pressure, roll and damping stay the simulator’s. So the stability margin a rocket reports doesn’t change with the drag model.
- Recovery doesn’t use it. Under a parachute the drag is the parachute’s.
- A drag model is the whole stack’s drag. So a flight with a powered separation refuses it at the separation (Staging).
A drag table read from another program’s export replaces the same number. That’s the flight
builder’s drag_table, or with_drag_table on a simulation, which
Getting started uses. A drag model is the same
idea, with your code in place of the table. The last one set is the one flown.
One difference matters. A table can carry the diameter it was measured on, and the simulator rescales it to the rocket’s reference area. A negative coefficient is refused from either, where the flight meets it. A table can give a negative one past its rows or between them if its curve extrapolates linearly or bends.
A model’s number is not rescaled. If your curve was measured on another
area, multiply it by your area over query.reference_area_m2() before returning it.
A drag model
cargo run --example custom_drag -p fusionspace-hpr
This flies the rocket of The builder three times on a Cesaroni H54, from a vertical rail in calm air. It flies with the simulator’s own drag, with that drag made 10% higher, and with a drag curve of invented numbers. The parachute opens at apogee, so only the drag changes from one flight to the next. Then it tries a curve that stops short of the rocket’s speed. It prints this:
My 54 mm rocket on a 168H54-10A, from a 1.8 m vertical rail in calm air
Not yet validated: see the Accuracy page before trusting these numbers.
drag apogee apogee at top speed
(m) (s) (m/s)
hpr's own drag 1145.1 14.06 187
hpr's, 10% higher 1091.2 13.65 183
a curve (invented) 1146.5 13.99 188
A curve that ends at Mach 0.4 stops the flight: Mach number past the drag curve's last point, 0.40
What the lines say:
- 10% more drag costs 53.9 m (177 ft) of apogee, 4.7%, and reaches it 0.41 s sooner. Flying 10% more drag is a way to see how much a rougher finish, or an uncertain drag, could matter.
- The curve is invented. Its apogee lands within 2 m (6.6 ft) of the simulator’s because of the numbers chosen. That says nothing about whether either is right. A curve from your own data would put your numbers here.
- The short curve refuses to guess past its last point. So the flight stops there and says why, instead of flying on made-up drag.
The program
The program is
crates/hpr/examples/custom_drag.rs.
Each model is a type with one method, zero_lift_drag, which gets a DragQuery and returns the
coefficient:
query.mach()is the Mach number.query.conditions().thrustingsays whether a motor is burning. A burning motor fills the base of the rocket, so its drag is lower (power-on and power-off drag). The example’s curve has a column for each.query.conditions().reynolds_per_mis the Reynolds number per meter, for a model that depends on it.query.buildup()is the simulator’s own drag at that flow, what the flight would have used without the model. The 10% model multiplies itszero_lift_coefficientby 1.1.
The method returns a Result, so a model can refuse a question it can’t answer. A refusal stops
the flight with its error, wrapped to say it came from the drag model. The short curve refuses
that way past Mach 0.4.
The integrator tries speeds a little past the flight’s own as it works out each step. So a curve that refuses past its end wants some margin beyond the top speed. A model is asked several times every step of the flight, so it should be fast. It should also give the same answer to the same question, since a flight is only as repeatable as its models. Whatever the drag model, a flight stops at Mach 5, where the simulator’s normal force ends.
A wind model
cargo run --example custom_wind -p fusionspace-hpr
The simulator has steady, power-law, log-law and layered winds built in (Wind),
and they reach the flight through the same Wind trait. This example writes one of its own. Its
wind grows from 4 m/s (8.9 mph) at the ground to 10 m/s (22 mph) at 1,000 m (3,281 ft). On the way
up it veers, turning clockwise, from the west (270°) to the north-west (315°). Above 1,000 m
(3,281 ft) it holds steady.
The example flies the same rocket in that wind and in a steady 4 m/s (8.9 mph) west wind:
My 54 mm rocket on a 168H54-10A, from a 1.8 m vertical rail
Not yet validated: see the Accuracy page before trusting these numbers.
wind apogee landing east landing south descent
(m) (m) (m) (m/s)
steady, from the west 1138.0 853 0 4.6
veering 1135.7 1395 835 4.6
Both winds are the same at the ground, where a flier would measure them. Aloft, the veering wind is stronger and comes from further north. So the rocket drifts further under its parachute, and to the south-east rather than due east. The parachute’s descent rate is the same in both.
The program is
crates/hpr/examples/custom_wind.rs.
Its Veering type has one method, wind, which gets a height above mean sea level and returns a
WindSample. The sample holds the air’s velocity as east, north and up components. It also says
whether the model had to extrapolate past its data (never, for this one).
A wind is asked by height above sea level, not above the ground, so the type keeps the ground’s
elevation to measure from. Environment::with_wind flies it. The
wind direction is where the wind blows from, so a west wind moves the
air east.
The simulator refuses a wind velocity that isn’t finite wherever it reads the wind. A wind that
returns a NaN (not a number) or an infinity stops the flight with a SimError::Domain error. Its
message names the wind and gives the height above sea level, in meters, where the wind was asked.
Take a test wind that turns to NaN above 1,700 m (5,577 ft). The height in the message is that of the first step to ask above 1,700 m (5,577 ft), so its digits depend on the step. The message reads “height above sea level, m, at which the wind’s velocity is not finite is outside its domain: 1700.0…”.
This holds while climbing, under a canopy, and for bodies flown apart after a separation
(issue #237, the report that asked for it).
Tests pin each case: a_wind_that_is_not_finite_stops_the_flight and
a_wind_that_is_not_finite_under_a_canopy_stops_the_descent,
and
a_separated_body_refuses_a_wind_that_is_not_finite.
The simulator can’t tell whether a finite wind is right. That’s up to the model.
An atmosphere
An atmosphere of your own works the same way, through Environment::with_atmosphere. The
simulator’s own are the standard atmosphere and a weather
balloon’s sounding (Atmosphere). There’s no
example program for one of your own yet. An atmosphere’s one method, air, gets a height above
mean sea level and returns an AirSample. The sample holds the air’s temperature, pressure,
density, speed of sound and viscosity, and whether the model had to extrapolate past its data.
The simulator refuses air it can’t use wherever it reads the air. Every field must be a finite number. The temperature, speed of sound and viscosity must also be above zero. The density and pressure may be zero, as in a vacuum, but not negative.
The simulator’s standard atmosphere is the reason zero is allowed. Far above its 86 km (282,152 ft) top, its pressure and density shrink to zero.
Air that breaks a rule stops the flight with a SimError::Domain error. Its message names the
field and gives the height above sea level, in meters, where the air was asked. If more than one
field is bad, the first in the order density, pressure, temperature, speed of sound, viscosity is
the one named.
Take a test atmosphere whose density turns to NaN above 1,700 m (5,577 ft). The message reads “height above sea level, m, at which the air’s density is negative or not finite is outside its domain:”. The height of the first step to ask above 1,700 m (5,577 ft) follows it.
This holds while climbing, under a canopy, and for bodies flown apart after a separation
(issue #301, the report that asked for it).
Before, a density that was NaN or negative turned the drag off with no error. In the tests, a
rocket climbed about twice as high, and bodies flown apart landed at about 140 m/s (459 ft/s). Tests pin
each case: air_the_flight_cannot_use_stops_the_climb and
air_the_flight_cannot_use_under_a_canopy_stops_the_descent,
and
a_separated_body_refuses_air_it_cannot_use.
Another test checks that the simulator’s own atmospheres pass, from 5 km (16,000 ft) below sea level to a
million kilometers up
(the_check_on_the_air_takes_every_stock_atmosphere).
The simulator can’t tell whether air that passes is right. That’s up to the model.
Where next
- The API reference’s
guidemodule says the same in five short chapters, each with code that CI runs.hpr_aero::customdocuments the drag trait. - The builder builds the rocket these examples fly.
- Accuracy says how well the simulator’s own models have been checked, which is what a model of your own replaces.
Monte Carlo dispersion
Fly a rocket many times with its uncertain inputs scattered, see how far its apogee and landing spread, and choose each input’s scatter.
No two flights of one rocket are the same. The motor burns a little hotter or cooler than its label, and the rocket weighs a few grams more than the plan. The wind isn’t the forecast’s.
A Monte Carlo run flies the rocket hundreds or thousands of times. Each time it draws the uncertain inputs afresh around their planned (nominal) values. The run shows how far the apogee and the landing spread, and draws the ellipse the landings fall in.
This page runs one, says what each dispersion does to a flight, and how
to choose the numbers. Its examples need some Rust and follow on from The builder.
hpr mc runs the same from the command line, with no code
(below), and hpr.MonteCarlo from Python
(From Python).
Sampling tests check that:
- the same seed gives the same run, bit for bit, however many flights it has and however many threads fly them;
- a run with no dispersion flies the nominal flight in every sample;
- each dispersion moves its input as the table below says;
- a dispersed motor keeps its specific impulse;
- failed flights are counted.
Running a dispersion
Rust, the command line and Python fly the same flights for the same seed.
A run of 200 flights
The example program
crates/hpr/examples/monte_carlo.rs
takes the 54 mm (2.1 in) rocket of The builder on a Cesaroni H54
(motor designation 168H54-10A). It flies at Spaceport America in
a forecast wind of 4 m/s (8.9 mph) from the west, off a rail leaned 5° into the wind. The program
disperses the rocket’s mass, its center of mass, its drag, the motor’s impulse and burn time, the
wind and the rail. It flies 200 flights. Run it from a copy of the repository with:
cargo run --example monte_carlo -p fusionspace-hpr
The heart of it:
let launch = Flight::builder(&rocket, &environment, 1.8)
.inclination_deg(85.0)
.heading_deg(270.0);
let dispersion = Dispersion {
dry_mass_sd_fraction: 0.02, // 2% of the mass without the motor
cg_sd_m: 0.005, // 5 mm
drag_sd_fraction: 0.05, // 5% of the drag coefficient
impulse_sd_fraction: 0.03, // 3% of the motor's total impulse
burn_time_sd_fraction: 0.02, // 2% of its burn time
wind_speed_sd_fraction: 0.25, // 25% of the wind's speed
wind_heading_sd_rad: 15_f64.to_radians(),
rail_elevation_sd_rad: 1_f64.to_radians(),
rail_azimuth_sd_rad: 2_f64.to_radians(),
..Dispersion::default()
};
let monte_carlo = MonteCarlo::new(launch.inputs()?, dispersion)?;
let run = monte_carlo.run(2026, 200); // seed 2026, 200 flights
let apogee = run.apogee()?; // the apogees' spread
let landing = run.landing()?; // where they landed
let ellipse = landing
.prediction_ellipse(0.95)? // where the next flight lands, 95 times in 100
.ok_or("too few landings")?;
It prints:
My 54 mm rocket on a 168H54-10A, from a 1.8 m rail at 85°, heading west into a 4 m/s west wind
200 flights, seed 2026: 0 failed
Not yet validated: see the Accuracy page before trusting these numbers.
nominal mean std dev 5% median 95%
apogee (m) 1113.3 1119.8 47.4 1040.5 1121.3 1198.8
landing distance (m) 662.4 660.3 208.9 329.3 670.5 996.5
landing east (m) 662.4 626.1 209.6 274.9 635.5 957.7
Landing ellipses, centered 626 m east and 23 m south of the pad:
semi-major semi-minor heading landings inside
50% 253 m 239 m 131° 48.0%
95% 525 m 497 m 131° 94.5%
95%, the next flight 532 m 503 m 131° 95.5%
Reached 1,100 m: 65.5% of the flights
Apogee with 5% less drag: +29 m; with 5% more: -27 m
How to read it:
- Nominal is the one flight with every input at its planned value.
- Landing distance is how far from the pad the rocket lands, and landing east is the eastward, downwind, part of it. The nominal flight lands due east, so the two are equal. In the run the wind’s heading has a standard deviation of 15°, which pushes some flights north or south. So the mean landing east is smaller than the mean distance.
- Std dev is the standard deviation. If the spread is normal, about two values in three lie within one standard deviation of the mean. 5% and 95% are percentiles: one flight in twenty went lower than the 5% value, one in twenty higher than the 95% value. So nine flights in ten reached between about 1,040 m (3,412 ft) and 1,200 m (3,937 ft).
The mean isn’t the nominal flight. The mean apogee is 6.5 m (21 ft) above the nominal one. With 200 flights the mean itself is uncertain by about (its standard error). So 6.5 m (21 ft) is 1.9 standard errors, and chance can account for most of it.
Part of the gap is that the apogee doesn’t respond evenly to drag. With 5% less drag it gains 29 m (95 ft), and with 5% more it loses 27 m (89 ft). So an even spread of drag lifts the mean apogee by about 1 m (3.3 ft).
The landing spreads far more than the apogee. The landing distance’s standard deviation is 209 m (686 ft), about a third of its mean of 660 m (2,165 ft). The apogee’s is 47 m (154 ft), 4% of 1,120 m (3,675 ft). Under the parachute the drift is the wind’s speed times the time in the air, and the wind’s speed is the most uncertain input here.
From the command line
hpr mc flies any design hpr sim flies, a staged .ork
included. Each dispersion is an option in the units the command line uses elsewhere: degrees for
angles, a fraction for a percentage (--impulse-sd 0.03 is 3%). It prints the apogee’s and the
landing distance’s spreads, and when a device opens the opening shock’s and opening airspeed’s
(after a separation with nothing left to burn, the part that keeps the
nose counts too, the shock until an ejection parts it;
hpr mc gives the rule), the landing ellipses below and the failed flights.
--export runs.csv writes every flight’s draw and outcome, one row a flight. The command’s runs
are the library’s for the same seed, bit for bit: a test compares them
(mc_flies_a_public_ork_as_the_library_does).
hpr mc my-rocket.ork --runs 200 --seed 2026 --wind 4 --wind-from 270 \
--mass-sd 0.02 --drag-sd 0.05 --impulse-sd 0.03 --wind-sd 0.25 --wind-from-sd 15
From Python
hpr.MonteCarlo in the Python package flies the same run and returns it as
NumPy arrays. Each array is one column of the table hpr mc --export writes. Failed flights are
counted, and their figures are NaN. hpr.MonteCarlo takes the same eleven dispersions as hpr mc’s
options, named for their units (impulse_sd_fraction, wind_from_sd_deg).
A test runs both on 40 flights with every input scattered and finds every number equal, bit for
bit. That holds on one platform, with both built in release mode
(test_a_run_is_hpr_mcs_bit_for_bit).
Landing ellipses aren’t in Python yet; NumPy finds them from the landing arrays.
run.spread(name) gives a column’s spread, and its 5% and 95% with each failed flight placed past
that end (Failed flights are counted). A
configuration that drops a stage can’t be read from Python yet, so it runs only from Rust and
hpr mc.
Landing ellipses
A landing ellipse is the outline a range safety officer or a
competition asks for. It’s an area the rocket lands inside, say, 95 times in 100. Comparing it with
the field’s boundary says whether the field is big enough for this rocket in this wind. For that
check, use the next-flight ellipse below (Scatter::prediction_ellipse).
The ellipse assumes the landings follow a normal distribution. It’s only as good as the run’s landings, which carry the flight models’ errors and those of the dispersions you chose. Neither has been compared with real flights yet.
The simulator draws the ellipse from the run’s landing points (Run::landing, then
Scatter::ellipse) in three steps. Its semi-major and semi-minor axes are its half-lengths
along its long and short directions.
-
The center is the landings’ mean: here 626 m (2,054 ft) east and 23 m (75 ft) south of the pad.
-
The axes come from the landings’ covariance. It gives the direction they spread most, the major axis, and the direction across it, the minor axis, with a standard deviation along each. Here those are about 214.6 m (704 ft) and 203.0 m (666 ft). The spread is nearly round: the wind’s uncertain heading (15°) spreads the landings sideways about as much as its uncertain speed (25%) spreads them downwind.
-
The size is how many standard deviations, , the ellipse reaches along each axis. If the landings follow a two-dimensional normal distribution, that ellipse holds the share
of them. So the ellipse of level has
Level Scale factor 50% 1.177 90% 2.146 95% 2.448 99% 3.035 The 95% ellipse’s semi-axes are and .
In two dimensions it takes more standard deviations to hold 95% than in one: 2.448 against 1.960. That’s because a landing can stray in two directions at once.
Heading is the major axis’s direction, clockwise from north, between 0° and 180°: here 131°, running from north-west to south-east. With axes this close to equal the heading means little: a few landings more or less could turn it a long way. A circle has no heading; the simulator then reports 90°, east.
The next flight. The mean and covariance of 200 flights are only estimates. So an ellipse
drawn from them holds a little less than its level of the flights still to come. For normal
landings Scatter::prediction_ellipse allows for that exactly.
The next-flight ellipse’s comes from Hotelling’s distribution, which accounts for the mean and the spread both being estimated from the same flights. For landings:
With 200 landings the next-flight ellipse’s axes are 1.3% longer: 532 m (1,745 ft) against 525 m (1,722 ft). With 10 they would be 36% longer.
Landings inside counts the run’s landings each ellipse really holds
(Scatter::share_inside). Here they are 48.0%, 94.5% and 95.5%. Those are within the
standard error of a share from a run of 200, :
about 3.5 percentage points at 50%, 1.5 at 95%. So the landings are consistent with a normal
spread, though that doesn’t prove it.
With few landings the shares run high, because the ellipse is fitted to the same points. With three
landings, even the 50% ellipse holds all three. If the share is far from the level in a run of
hundreds of flights, the landings aren’t normal. An uncertain wind heading in a strong wind spreads
them along an arc, and an ellipse is then the wrong shape. Look at the points (Scatter::points).
A failed flight has no landing. It counts as outside for the lower bound and inside for the upper (Failed flights are counted).
The tests can catch a wrong ellipse. Take a spread 200 m (656 ft) long and 30 m (98 ft) wide, one standard deviation each way. Its 95% ellipse, turned 6° off the spread’s axes, holds 90.6%, and the test pins that.
What each dispersion does
Each dispersion is a standard deviation: zero, the default, leaves its input at the nominal value. For each flight the simulator draws a standard normal number (mean 0, standard deviation 1) for each input. It moves the input by , with the standard deviation you gave. A rocket of more than one stage gets a draw for each stage, whether its stages fly together or separate. Each motor and each parachute gets its own draw.
| Field | What each flight flies |
|---|---|
dry_mass_sd_fraction | Each stage’s mass without motors times . Its moments of inertia scale with it. |
cg_sd_m | Each stage’s center of mass moved meters towards the tail (towards the nose when negative). |
drag_sd_fraction | The rocket’s zero-lift drag coefficient times , whether HPR Sim’s own, a drag table’s or a drag model’s. |
impulse_sd_fraction | Each motor’s thrust and propellant mass, both times . Its total impulse changes and its specific impulse doesn’t, as for a motor that holds a little more or less of the same propellant. |
burn_time_sd_fraction | Each motor’s thrust curve stretched in time by and its thrust divided by the same: a longer, softer burn of the same impulse. |
ejection_delay_sd_s | Each motor’s ejection delay plus seconds, never below zero. |
wind_speed_sd_fraction | The wind at every height times , never below calm. A calm forecast stays calm. |
wind_heading_sd_rad | The wind at every height turned clockwise: the forecast’s direction, give or take. |
rail_elevation_sd_rad | The rail’s angle above the horizon plus . Past vertical, it leans the other way. |
rail_azimuth_sd_rad | The rail’s heading plus , clockwise. |
deployment_lag_sd_s | Each recovery device’s lag after its trigger plus seconds, never below zero. A part’s tumble, which the simulator adds to a separated part with no device open, starts at the split and has no lag to scatter. |
Five cases need a word:
- A draw that makes an input impossible fails that flight. With a 60% mass spread, a draw of below −1.67 gives a negative mass; a rail drawn below the horizon is another. That flight is kept in the run as failed, with its reason, and counted (next section). The two delays and the wind’s speed are the exceptions. A charge can’t fire before its event and a wind can’t blow at less than calm, so a draw below zero is flown as zero.
- A cluster is one draw. The simulator holds a cluster as one motor in a mount with several tubes, so all its motors get the same impulse and burn time.
- A vertical rail leans along one line. The elevation is dispersed in the plane of the rail’s
heading. So on a vertical rail with only its elevation dispersed, every flight leans towards or
away from that heading, never sideways. RocketPy disperses its rail the same way, an inclination
and a heading (
rocketpy/stochastic/stochastic_flight.py:21-24, version 1.13.0). Disperse the heading too for leans in every direction. - Every flight of a staged run separates where the nominal one does. It separates at the same
event, or at the same time for a split the file times in seconds. A split timed by a burnout
follows the dispersed burn; one timed in seconds doesn’t. If a booster still burns at a split
timed in seconds, the flight stops with its error and counts as failed. The exception is a split
that may drop a burning motor, as OpenRocket’s first burnout of a stage does
(the decision record).
--delay-sdmoves a booster’s ejection charge, and the parachute it fires, but not a split the file times in seconds. - A part dropped on the way up needs its device open. After a split with nothing left to burn, each part flies as a point with only its open devices’ drag. A part whose device fired by the split but waits out a dispersed lag would climb through the lag with no drag. So the simulator refuses that flight, and it counts as failed.
How a run behaves
Failed flights are counted
A run never drops a flight. Run::failed lists those that failed, saying whether the draw made
an impossible input or the flight refused it. A spread like Run::apogee counts every flight
tried: attempted() is the run’s size, count() the flights that gave a value, and missing()
the rest. Its mean and percentiles are over the flights that gave a value, so many failures can
bias them: check missing() first.
How much a failure can move a percentile has a bound. If every failed flight had gone past one end, the 95th percentile of all the flights tried is the percentile of the flown ones with the failed ones counted as infinitely high. The percentile is the straight-line rule NumPy uses by default: with values sorted, the percentile sits at position , counted from 0.
Say 100 flights are tried and 2 fail. The 95th percentile of all 100 sits at position . With the 2 failures placed last, positions 94 and 95 are the 95th and 96th smallest flown values, so it lies 0.05 of the way from one to the other. Over the 98 flown flights alone it sits at , 1.9 places lower. With 5 or more of the 100 failed, position 95 is a failed flight, and the answer can’t be bounded.
hpr mc prints both ends whenever a flight has no value (its output), and
Python’s MonteCarlo.spread gives the same numbers. From Rust,
quantile_counting_missing(0.95, MissingEnd::Above) gives the 95th percentile’s worst case, and
MissingEnd::Below the 5th’s; too many failures give CountedQuantile::Unbounded.
A share such as “reached 1,100 m (3,609 ft)” is given as two bounds, share_at_least(1100.0):
lowcounts a failed flight as not reaching it;highcounts it as reaching it.
With no failures the two are equal. With some, the truth lies between them, and a wide gap says the run can’t answer the question.
The same seed, the same run
Every number a flight draws comes from its own stream of random numbers. The stream is picked out by the run’s seed, the flight’s number in the run and the input it’s for. So:
- flight 37 of a run is the same flight in a run of 100 or of 10,000;
- a run flown on one thread or on twelve is the same, bit for bit (with the
parallelfeature,run_parallel); - turning a dispersion on or off doesn’t change what the other inputs draw.
To fly on several threads, turn on the parallel feature where your program depends on the hpr
library. Using it from your own program describes how.
Then call run_parallel instead of run:
[dependencies]
fusionspace-hpr = { git = "https://github.com/nrdptel/fusionspace-eridanus", rev = "<commit>", features = ["parallel"] }
On another platform (operating system and processor) a draw can differ in its last binary digit, because the normal numbers use the platform’s logarithm. A run then agrees to many digits, not to the bit. The decision record on Monte Carlo dispersion sets out the draws.
How long a run takes
On the development machine, an Apple M5 with 10 cores, these are the times for 10,000 flights of a Level 2 rocket. That’s a rocket on a J, K or L impulse class motor. Each flight runs from ignition to the ground, under a drogue and a main:
| rocket | peak Mach | 10,000 flights, 10 threads | one flight, one thread |
|---|---|---|---|
| Valetudo, one of RocketPy’s examples: 9.7 kg on a K400C | 0.3 to 0.4 | 3.0 s | 1.9 ms |
| a 66 mm (2.6 in) rocket with a 54 mm motor mount on a K940 | 1.6 to 2.0 | 9.4 s | 5.7 ms |
No flight failed. These are release builds, with optimization on: add --release to
cargo run, or build your program with it. A debug build, what plain cargo run gives, is
many times slower. To time it on your own machine, from a copy of the repository:
cargo bench -p fusionspace-hpr --features parallel --bench ten_thousand
It takes about a minute. Its output, the before-and-after numbers and where the time goes are on Performance. Other machines haven’t been timed.
A rocket that passes Mach 1.2 flies on a supersonic table. The table holds the body’s lift and center of pressure by the shock-expansion method (The body faster than sound in a flight). They’re worked out once at every 0.05 Mach and then looked up. Building the table takes about a fifth of a second for the rocket above.
A dispersion changes the rocket’s masses, its motor, the weather and a scale on its drag, never
its shape. So the flights of a run share the nominal flight’s table: the run builds it once. Each
flight also reuses the nominal rocket’s layout, its parts placed and weighed. Every flight flies
exactly as it would alone, bit for bit. A unit test holds a supersonic flight to that, on one, two
and five threads (samples_share_the_nominal_table_and_fly_as_alone).
Before this speed-up (sharing the table, October 2026), each
flight built its own table. The supersonic run above then took 264 s. To fly draws of your own, as a
sensitivity analysis does, use monte_carlo.fly(&draw), which shares the work.
Flying a draw’s inputs yourself, monte_carlo.inputs(&draw)?.fly(), builds its own table and
layout.
A two-stage rocket’s sustainer, built when the stages separate, still builds its own table in every flight. Issue #285 is about making each flight itself faster.
The times say nothing about how accurate a Mach 2 flight is. No validation flight goes past Mach 1.06 (The body faster than sound in a flight).
Choosing the numbers
The spread a run gives is the spread you put in. Some places to start:
- Motor impulse has its limit in NFPA 1125, the code commercial motors are certified to (§8.1.7 and §8.2.7). Over a motor type’s certification firings, the “standard deviation of the total impulse data shall be no greater than 6.7 percent of the mean”. Four National Association of Rocketry (NAR) certification reports measured 1.3% to 3.1%: an Estes C6 (2.0%), D12 (3.1%), E12 (1.28%) and an AeroTech G80 (2.3%). The G80’s report is hosted on ThrustCurve.org. So 2% to 3% is a fair guess, and 6.7% the most the code allows.
- Ejection delay. The code lets a measured delay differ from its label by “1.5 seconds or 20 percent (whichever is greater, but not to exceed 3 seconds)”. The E12 and G80 reports’ firings of one delay scatter by 0.2 to 0.9 s. A delay’s average can sit more than a second from its label: the G80’s 7 s delay averaged 5.88 s. A dispersion is about the nominal value, so give the delay you expect, not only the one printed on the motor.
- Burn time. The code sets no limit of its own. The four reports disagree: the E12’s and G80’s burn times scatter by 1.5% and 1.8%, the older C6’s and D12’s by 17% and 18%. Why isn’t recorded; the older sheets may time the burn differently. Start from a few percent for a composite motor, and try a larger value to see whether it matters to your flight.
- Mass, center of mass and drag depend on how well you know your rocket. A rocket weighed ready to fly needs a smaller mass dispersion than one weighed on paper. Drag is usually the least certain of the three: Accuracy shows how far HPR Sim’s drag sits from other programs’ and from wind-tunnel data.
- Wind depends on the forecast, its age and the hour. A sounding of the day, or a forecast’s spread between models, is a better guide than a guess.
The NFPA wording is the 2019 edition’s. It’s quoted in the public first-draft documents of the
code’s next revision
(public inputs 4 and 5).
The draft’s first revisions, FR-7 and FR-8, keep both sentences
(1125_A2021_PYR_AAA_FD_FRStatements.pdf).
The edition in force today hasn’t been checked.
What is not dispersed
- Inputs are independent: a heavier rocket isn’t also draggier.
- Every dispersion is normal; there are no uniform or skewed ones.
- Moving a stage’s center of mass keeps its inertia about the center.
- The drag dispersion scales the zero-lift drag only, not the normal force or the moments; a recovery device’s drag isn’t dispersed.
- A stretched thrust curve keeps its shape.
- The atmosphere’s temperature and pressure, a motor’s ignition time, a separation’s trigger or time, and events of your own.
What comes next
The run gives each flight’s whole FlightSummary,
so any number a flight reports can be spread with run.distribution(...), as the example does for
the landing. To find which input moves the apogee most, see
Sensitivity analysis.
The API reference is hpr_analysis::montecarlo,
hpr_analysis::statistics and
hpr_analysis::ellipse.
Sensitivity analysis
Rank a rocket’s uncertain inputs by how much each moves a result, with Morris screening and Sobol’ indices, so you know what to measure.
A Monte Carlo run shows how far a rocket’s apogee spreads. It doesn’t say which input causes the spread. Sensitivity analysis does: it ranks the uncertain inputs by how much each moves a result. Then you know which to measure more carefully, and which you can stop worrying about.
This page shows HPR Sim’s two methods: Morris’s screening, which is cheap, and Sobol’ indices, which cost more and say more. It runs both on two test functions whose answers are known, then screens a rocket’s apogee and landing. It needs some Rust, and follows on from Monte Carlo dispersion.
A Sobol’ analysis costs thousands of runs per input: 65,536 flights for this page’s rocket, against Morris’s 70. So the rocket example uses only the Morris screening.
Inputs as factors
Each uncertain input is a factor: a name and a range, with every value in the range equally
likely (Factor). The drag might be anywhere from 10% below its estimate to 10% above, say, or
the wind anywhere from calm to 8 m/s (18 mph). Factors are independent: a heavier rocket isn’t
also draggier.
Both methods work the same way. They lay out the points to try (a design), you run your model at each point in order, and they analyze what came back. The model can be a whole flight, with the factors set into its inputs, or any function. So you can run the points however you like, on many threads or machines. Each method also has a shortcut that takes a closure and runs the points itself.
The two methods
Morris’s screening ranks the factors cheaply; Sobol’ indices split the output’s variance among them.
Morris screening
Morris’s method nudges one factor at a time and watches the output move. It works on a grid: each factor’s range is cut into evenly spaced levels (4 is usual). A step moves one factor levels (two of four), which is a fraction of its range: 2/3 for four levels.
The change in the output over one step, divided by , is an
elementary effect. It’s the change the factor would cause across
its whole range, at the slope measured over the step. A path starts at a random grid point and
steps each factor once, in a random order, so factors take runs per path. Each step
gives one effect. After paths, each factor has effects, and the screening reports three
numbers for each factor (ElementaryEffects):
| Number | What it is | What it says |
|---|---|---|
(mean_absolute) | the mean of the effects’ sizes | how much the factor matters: the ranking |
(standard_deviation) | how much the effects vary | a large means the factor’s effect bends, or depends on other factors |
(mean) | the mean of the effects, with their signs | effects of opposite sign cancel here, so use to rank |
A factor with near zero can be left at its planned value. The screening also gives ’s standard error, which shrinks as : ten paths are usually enough to rank, and the cost is runs.
For example, Ishigami’s test function (below) has the term , with . On a four-level grid from to , a step of moves by exactly 3/4, up or down. So every effect of is . The example’s screening finds with no error, and near zero.
M. D. Morris, “Factorial sampling plans for preliminary computational experiments”, Technometrics 33(2), 161–174, 1991, defines the effects, the grid and the paths. F. Campolongo, J. Cariboni and A. Saltelli, “An effective screening design for sensitivity analysis of large models”, Environmental Modelling & Software 22, pp. 1509–1518, 2007, add . They found, by experiment rather than proof, that it ranks factors in the same order as the total Sobol’ index.
That’s usual, not certain. A step spans about half of each range, so it can miss a response that repeats over about half the range. Ishigami’s repeats every , half of its range from to . At four levels, Morris puts first ( 7.875 against 7.704 for ), while the total index puts first (0.558 against 0.442). At six levels or more, Morris puts last (2.687 at six levels), though it causes the largest share of the variance alone.
A rocket’s outputs rarely repeat like that. Still, treat factors whose s are close as tied, and use Sobol’ indices to settle an order that matters.
hpr_analysis::sensitivity::morris gives the
equations and page numbers.
Sobol’ indices
Sobol’s method splits the output’s variance (the square of its
standard deviation) among the factors. It reports two shares for
each factor (SobolIndex):
- The first-order index is the share of the variance the factor causes alone. If you could pin the factor to its true value, the variance would drop by this share, on average.
- The total index is the share it has any part in, alone or together with others. If you pinned every other factor, this share of the variance would remain, on average.
. The gap is how much the factor acts through others. A factor with a total index near zero can be left at its planned value.
The analysis draws two independent tables, and , each of rows with every factor spread over its range. Then, for each factor , it builds a third table: with factor ’s column taken from . Comparing the outputs of the three tables row by row gives both indices.
The estimates used here are from A. Saltelli and others (“Variance based sensitivity analysis of model output”, Computer Physics Communications 181, 259–270, 2010). They’re the best the paper compared. The cost is runs, and the error shrinks as : with , an index comes out to about ±0.01.
Each index comes with its standard error, found by the
delta method from how much the rows scatter.
hpr_analysis::sensitivity::sobol gives the
formulas.
Checked against
Two test functions have Sobol’ indices known in closed form
(hpr_analysis::sensitivity::benchmark):
-
Ishigami and Homma’s function,
each from to . does nothing alone (), yet it’s part of a quarter of the variance, through . The closed forms are I. M. Sobol’ and Y. L. Levitan’s (Computer Physics Communications 117, 1999, p. 57).
-
Sobol’s g function, a product of one term per factor, each with a weight . The factor matters most at and hardly at all at 99. The closed forms are Saltelli and others’ (2010, p. 268). The tests use = 0, 1, 4.5, 9 and four 99s, spanning the four classes Marrel and others (2008) name. The SFU library of test functions quotes the classes: very important at 0, relatively important at 1, non-important at 9 and non-significant at 99.
For Morris there is also an exact answer. A screening estimates the moments of a finite set of
effects: every step on the grid. Morris::population runs the model at every grid point and
computes them exactly: the example’s “whole grid” column. For both functions they also follow in
closed form, which the tests check.
The tests in
tests/sensitivity.rs
check four things:
- Every Sobol’ index of both functions, from 32,768 and 16,384 rows, lies within four standard errors of its closed form.
- Every Morris , from 1,000 paths, lies within four standard errors of the exact one.
- The standard errors are honest. The test divides each estimate’s distance from the known answer by its standard error. Over seeds, these have a mean within of 0 and a standard deviation within of 1. This holds for every Sobol’ index of Ishigami’s function (1,000 seeds) and of the g function’s first four factors (500 seeds). It holds for Morris’s of those four too (1,000 seeds). The same test checks that standard errors 15% too small would fail. A separate unit test computes each Sobol’ standard error a second way, from the raw row means.
- On the g function, twenty Morris paths rank the four factors that matter in the order of their total indices.
An example
The example program
crates/hpr/examples/sensitivity.rs
runs both methods on the two test functions and prints them beside the known answers. Then it
screens the rocket of Monte Carlo dispersion over six inputs. Run it from a copy
of the repository with:
cargo run --example sensitivity -p fusionspace-hpr
Excerpts from it follow. The test functions take a closure:
let ishigami = Ishigami::STANDARD;
let sobol = Sobol::new(Ishigami::factors()?, 8192)?; // N = 8,192 rows: 40,960 runs
let indices = sobol.indices(seed, |x| ishigami.evaluate(x))?;
For the rocket, the screening lays out its points and the program flies each one. A Monte Carlo
set-up with no dispersion turns a draw (each input’s factor or offset) into the flight it flies
(MonteCarlo::inputs):
let monte_carlo = MonteCarlo::new(launch.inputs()?, Dispersion::default())?;
let nominal = monte_carlo.draw(seed, 0); // every input as planned
let factors = vec![
Factor::new("dry mass factor", 0.95, 1.05)?,
Factor::new("drag factor", 0.9, 1.1)?,
Factor::new("impulse factor", 0.94, 1.06)?,
Factor::new("wind speed (m/s)", 0.0, 8.0)?,
Factor::new("wind turn (°)", -30.0, 30.0)?,
Factor::new("rail angle (°)", 80.0, 90.0)?,
];
let morris = Morris::new(factors, 4, 10)?; // 4 levels, 10 paths: 70 flights
let design = morris.design(seed);
for x in design.points() {
let mut draw = nominal.clone();
draw.drag_scale = x[1]; // a factor on the drag
draw.wind_speed_scale = x[3] / 4.0; // a factor on the 4 m/s forecast
draw.rail_elevation_offset_rad = (x[5] - 85.0).to_radians(); // an offset from 85°
// ... and the dry mass, impulse and wind turn the same way
let flight = monte_carlo.fly(&draw)?;
apogees.push(flight.apogee.as_ref().ok_or("no apogee")?.height_above_ground_m);
}
let apogee = design.analyze(&apogees)?; // the same flights, any output
The six inputs, with ranges made up for the example:
| Input | Range (factor, m/s, °) | Planned value (factor, m/s, °) | What it is |
|---|---|---|---|
| dry mass factor | 0.95 to 1.05 | 1 | the rocket’s mass without its motor, ±5% |
| drag factor | 0.9 to 1.1 | 1 | the zero-lift drag, ±10% |
| impulse factor | 0.94 to 1.06 | 1 | the motor’s total impulse, ±6%; NFPA 1125 caps a motor type’s standard deviation at 6.7% |
| wind speed | 0–8 m/s (0–18 mph) | 4 m/s (8.9 mph) | the wind at every height |
| wind turn | −30° to 30° | 0° | the wind’s direction, turned clockwise from the forecast’s (a wind from the west) |
| rail angle | 80° to 90° | 85° | the rail’s angle above the horizon; 90° is vertical |
A Draw can also move a stage’s center of mass, and the motor’s burn time and ejection delay.
It can move the rail’s heading and a recovery device’s delay too
(What each dispersion does).
It prints:
Sobol' indices of Ishigami's function (a = 7, b = 0.1), 8192 rows, 40960 runs
first order: known estimate ± error total: known estimate ± error
x1 0.3139 0.3101 ± 0.0108 0.5576 0.5453 ± 0.0154
x2 0.4424 0.4549 ± 0.0098 0.4424 0.4494 ± 0.0074
x3 0.0000 -0.0071 ± 0.0099 0.2437 0.2404 ± 0.0050
Sobol' indices of the g function, a = 0, 1, 4.5, 9, 99 (four times), 8192 rows, 81920 runs
first order: known estimate ± error total: known estimate ± error
x1 0.7162 0.7162 ± 0.0124 0.7871 0.7844 ± 0.0127
x2 0.1790 0.1683 ± 0.0077 0.2422 0.2444 ± 0.0050
x3 0.0237 0.0246 ± 0.0029 0.0343 0.0353 ± 0.0008
x4 0.0072 0.0059 ± 0.0017 0.0105 0.0109 ± 0.0003
x5 0.0001 0.0001 ± 0.0002 0.0001 0.0001 ± 0.0000
(x6 to x8 are as x5)
Morris screening of Ishigami's function, 4 levels, 100 paths, 400 runs
μ*: whole grid estimate ± error σ: whole grid estimate
x1 7.704 7.079 ± 0.625 6.249 6.249
x2 7.875 7.875 ± 0.000 7.875 7.915
x3 6.249 6.124 ± 0.628 8.837 8.784
Morris screening of the Monte Carlo page's rocket, 4 levels, 10 paths, 70 flights
Not yet validated: see the Accuracy page before trusting these numbers.
Each effect is the change across the input's whole range, m.
apogee: μ* ± error σ landing distance: μ* ± error σ
dry mass factor 36.0 ± 1.8 5.6 70.0 ± 22.5 72.0
drag factor 112.9 ± 3.2 10.3 80.5 ± 18.0 57.0
impulse factor 118.3 ± 2.3 7.1 107.5 ± 23.7 75.1
wind speed (m/s) 50.3 ± 4.1 13.1 1417.5 ± 101.4 320.7
wind turn (°) 4.4 ± 1.0 5.4 53.4 ± 10.5 64.5
rail angle (°) 68.4 ± 3.1 9.9 350.2 ± 17.6 231.0
How to read it:
- The test functions land within 1.4 standard errors of the known answers, from the printed
digits. comes out slightly below zero: the estimate of a share that’s really zero scatters
around zero. The g function’s
x5shows “± 0.0000” because its error is below 0.00005. - Ishigami’s Morris screening at 400 runs puts
x2,x1,x3in the whole grid’s order. But the gaps are only about one standard error, so at 100 paths they aren’t really ranked. Its s are as large as its s, the sign of a function that bends or whose factors act together. - The rocket’s apogee moves most with the motor’s impulse, 118 m (387 ft) across ±6%, and the drag, 113 m (371 ft) across ±10%. Then comes the rail’s angle, 68 m (223 ft) across 80° to 90°. Next come the wind’s speed, 50 m (164 ft), and the dry mass, 36 m (118 ft) across ±5%. The wind’s direction hardly matters, 4 m (13 ft).
- The apogee’s s are small beside its s: each input acts nearly in a straight line and alone. The exception is the wind’s direction. Its , 5.4 m (18 ft), exceeds its , 4.4 m (14 ft), so its effects differ in size or sign from path to path. The impulse and the drag are 1.4 combined standard errors apart: ten paths don’t settle which comes first.
- The landing is the wind’s: 1,418 m (4,652 ft) across calm to 8 m/s (18 mph), then the rail’s angle, 350 m (1,148 ft). Here the s are large, so these effects bend or depend on the other inputs.
With your own rocket, use the ranges your measurements support; a factor’s effect grows with its range.
Choosing the numbers
- Levels: four, an even number as the method needs. More levels let a path start from more places in each range, at the same cost per path. But the step stays about half the range, so more levels don’t help with a response that repeats (see Morris screening).
- Paths: ten to twenty to rank. Check ’s standard error: two factors whose s differ by less than a couple of errors aren’t ranked yet.
- Rows: a Sobol’ analysis needs about 8,000 rows, each runs, to pin an index to about ±0.01 to ±0.015 (one standard error). Use Morris to find the few factors that matter, then Sobol’ on those if you need the shares or the order of two close ones.
- Normal inputs: give each one the same multiple of its standard deviation, such as ±2, so they’re compared alike. A range weighs its ends more than a normal spread does.
Left out
- Factors are uniform over their ranges and independent. A normal input can be given as a range about its mean, such as ±2 standard deviations. That weighs its ends more than a normal spread does.
- Sobol’ rows are plain pseudo-random draws, not quasi-random ones (evenly spread sequences, such as Sobol’s own), which converge faster.
- No second-order Sobol’ indices (the share of each pair alone).
- No choice of the most spread-out Morris paths among many (Campolongo’s improvement).
- No command-line or Python front end yet.
The API reference is
hpr_analysis::sensitivity.
Optimization
Search for the design that gives the result you want, such as a target apogee or the lightest stable fins, with HPR Sim’s optimizers.
Sometimes you know the result you want and need the design that gives it: that’s optimization. That might be a rocket that reaches exactly 3,048 m (10,000 ft) for a competition, or the lightest fins that keep it stable. An optimizer searches for that design. It tries designs, flies each one, and uses what it learns to choose better ones, until it finds the best it can.
This page shows HPR Sim’s optimizer, CMA-ES. It runs on test functions whose answers are known. Then it finds the nose ballast and body length that send a rocket to 3,048 m (10,000 ft) with a chosen stability margin. Then it chooses a motor and a catalog nose cone, within a competition’s limits on stability and speed off the rail.
Then a second optimizer, NSGA-II, weighs two goals against each other: how much apogee each extra caliber of stability costs. A third, EGO, is for models so slow that only tens of evaluations can be afforded. Using any of them needs some Rust.
What was checked:
- Tested: four standard test functions of ten variables are run from 20 seeds each. Every
run reaches a value of or less, which puts its best point within of the known
minimum ( for Rosenbrock’s function). The exception is 3 of the 20 Rosenbrock runs, which
end in that function’s known local minimum instead. An evaluation is one call of your model:
here, one flight. Over the 20 seeds, the median number of evaluations is within 25% of
pycma’s, the method’s author’s own Python implementation run from the same starts. That 25% is
the test’s bound; measured, they are within 5%. Twelve generations of a three-variable run are
recomputed by a separate implementation of the published formulas, and agree to rounding
(
tests/optimize.rs). A run is repeated bit for bit from its seed (a_seed_fixes_the_runinoptimize/cmaes.rs). - Checked by re-flying: the design each of the first two examples finds is flown again from scratch. It’s flown once more with the flight’s numerical integration 100 times stricter (tolerances). Both examples’ designs reach apogee within 0.1 m (0.3 ft) of 3,048 m (10,000 ft); the first example’s within 2 mm (0.079 in), measured.
- Limits (a minimum stability margin, say): held to three test problems whose answers on
their limits are known exactly. Each is run from 20 seeds and held to
(
tests/constrained.rs). The second example’s winner is flown again and keeps its margin limits over the whole ascent and its rail-exit limit. - Choices (which motor, which catalog part): held to three test functions mixing
continuous and whole-number variables, at two sizes, from 20 seeds each. Every run reaches
the known minimum, with every whole number exactly right. The median evaluations are within
25% of an outside implementation’s (the test’s bound; measured, within 5%;
tests/mixed.rs). The second example chooses a motor and a nose cone that hit 3,048 m (10,000 ft), checked by flying them again (Choices). It finds a design that does; it doesn’t promise the best of several that would. - Trade-offs between goals (a Pareto front): NSGA-II is held to three test problems whose fronts are known exactly, from 20 seeds each. It’s also held to pymoo, an outside implementation run with the same settings. Every run’s front lies within twice pymoo’s worst distance from the true front (the test’s bound). At the median, HPR Sim’s fronts lie 1% to 8% closer to the true front than pymoo’s, and cover it as evenly, within 3%. For the medians, the test allows a factor of 1.25 either way (Trade-offs). The third example’s front designs are flown again and give the same apogee and margin to the bit. That shows the result repeats, not that it’s right. At 2.5 calibers the front is within 0.5% of the apogee CMA-ES finds alone (the example’s check).
- Few evaluations (EGO): two standard test functions with several local minima, Branin’s (two variables) and Hartmann’s (three), are run from 20 seeds each. They end within 1% of their known minima in 50 evaluations (the test’s bound; measured, within 0.12%). Hartmann’s six-variable function needs its values transformed first, as the method’s authors did. Then all 20 runs end within 1% in 250 evaluations (measured, within 0.29%), against 6 of 20 without. That check takes minutes in a release build, so the local gate runs it, not CI (Few evaluations).
- Left out, for now: optimizing a Monte Carlo run’s statistics, and EGO beyond six variables. Also left out is a rule that stops NSGA-II when its front has settled (it runs the generations it’s given). All three are the next steps of the optimization milestone. There’s no command-line or Python front end yet.
The optimizer
What the optimizer does
The optimizer changes variables: numbers in the design, such as a ballast mass or a body length
(Variable). For each variable you give three things:
- a start, the value to begin from;
- a step, how far to try from the start at first;
- optional bounds, the range the variable must stay in.
It minimizes one number your model returns. To maximize something, minimize its negative. To hit a target, minimize the squared miss: is smallest, zero, on the target.
How CMA-ES searches
CMA-ES is the covariance matrix adaptation evolution strategy, N. Hansen’s method (“The CMA Evolution Strategy: A Tutorial”, arXiv:1604.00772, 2023). It keeps a cloud of likely designs, shaped like a stretched, tilted ball (a normal distribution). Each generation, it repeats four steps:
- Sample. Draw a handful of designs from the cloud: of them for variables, so 6 for two variables and 10 for ten.
- Rank. Fly each one and sort them by the number to minimize. Only the order matters, not the values.
- Move. Move the cloud’s center to a weighted average of the better half, the best weighted most.
- Learn. Stretch and tilt the cloud toward the directions the good designs lay in. Widen it when successive moves go the same way, which means the steps are too short. Shrink it when they cancel out, which means the steps overshoot.
So the cloud learns the problem’s shape. If the apogee depends far more on one variable than on another, or on a combination of them, the cloud stretches to match. No derivatives are needed, which suits flights. Their outputs wobble slightly in the last digits as the integrator’s steps change, which would spoil a slope.
The formulas and default settings are the tutorial’s (Appendix A and Table 1). Table 1 also gives the worse half of each generation negative weights, which push the cloud away from them: the active variant. HPR Sim gives them zero weight, as the tutorial’s own code does.
The cloud is shaped in each variable divided by its step, as the tutorial advises. So variables
in meters and in kilograms start on an equal footing.
hpr_analysis::optimize::cmaes lists every equation.
Bounds
A sampled design outside a variable’s bounds is thrown away and drawn again, the tutorial’s simplest way of handling bounds. It works well while the answer lies inside the range. If it lies on a bound, the run slows down near it. If any design of a generation is still outside after 1,000 tries, the run stops and says so. With many variables near their bounds this comes soon: each such variable halves the chance that a draw falls inside.
When a run stops
A run stops at the first of these (Stop):
| Stop | When |
|---|---|
Target | a value at or below the target you set: a miss small enough |
Evaluations | the number of evaluations you allowed is used up (10,000 by default) |
TolX | the cloud has shrunk below of each variable’s step: the run has converged |
TolFun | the values have stopped changing by more than , in your model’s units |
Condition | the cloud is times longer than it is wide, too thin to keep accurate, or its numbers have overflowed |
Bounds | a design of a generation couldn’t be drawn inside the bounds (in the first generation, start returns an error instead) |
Both tolerances can be changed or turned off (with_tolerance_x, with_tolerance_value).
The result (Optimum) gives the best design found, its value, how many evaluations the run made,
and why it stopped. If every design so far failed (your model returned infinity for each), the
value is infinite: check it before using the design.
Checked against
Four test functions from CMA-ES’s authors (N. Hansen, S. D. Müller and P. Koumoutsakos,
Evolutionary Computation 11(1), 2003, Table 1), each with ten variables
(hpr_analysis::optimize::benchmark):
| Function | What it tests | Minimum |
|---|---|---|
| sphere, | the step size alone | 0 at |
| ellipsoid | stretching the cloud: coefficients from 1 to , so the cloud must grow 1,000 times longer one way than the other | 0 at |
| rotated ellipsoid | the same, tilted so that no single variable lines up with it | 0 at |
| Rosenbrock’s function | following a long, curved valley | 0 at |
Each run starts with every variable at 1 (at 0 for Rosenbrock’s function) and steps of 0.5. It
goes until the value is or less, the stopping value of the 2003 paper. The tests in
tests/optimize.rs
run each function from 20 seeds and check:
- Every sphere and ellipsoid run reaches the minimum, which puts its best point within of .
- 17 of 20 Rosenbrock runs reach the minimum at . The other 3 end in the function’s local minimum near . The test requires at least 17. CMA-ES’s authors report 1 to 3 runs of 20 missing the global one at 4 to 16 variables (Kern, Hansen and Koumoutsakos, 2006). In 1 of 20 runs, pycma ends in the local minimum. Measured once over seeds 1 to 300, HPR Sim reaches the global minimum in 290 (97%). So 17 of 20 is at the low end of what chance gives.
- The median number of evaluations is within 25% of pycma’s from the same starts (the test’s bound). Measured, they’re within 5%:
| Function | HPR Sim, median evaluations | pycma 4.5.0, median evaluations |
|---|---|---|
| sphere | 1,635 | 1,640 |
| ellipsoid | 5,920 | 5,910 |
| rotated ellipsoid | 6,010 | 5,930 |
| Rosenbrock | 6,445 | 6,195 |
- Tilting the ellipsoid changes the count by under 10%: the cloud learns the tilt.
- A second, separate implementation of the tutorial’s formulas checks twelve generations, with steps that differ 200-fold. Every generation’s mean, cloud size and shape match it to rounding. That implementation takes the cloud’s inverse square root by a different method (the Denman-Beavers iteration). The check passes through both branches of the step that pauses the shape’s learning when the cloud grows fast.
- The default settings that pycma also takes from the tutorial’s Table 1 match its values to rounding. In a few places, pycma departs from the table by its author’s choice, such as how fast the cloud’s size adapts. That’s why the counts differ a little.
The tests catch real faults. Take out the step that learns the cloud’s shape from a generation’s better half (the rank- update, being the size of that half). Then the ellipsoid takes a third more evaluations (7,875), and the pycma comparison fails.
A reviewer found three faults the pycma comparison misses. The shape’s learning never paused, the pause’s test was off by one generation, and the mean’s step wasn’t scaled back to the variable’s units. Each fails the second implementation’s check. These were one-off checks, recorded in the decision record for this work, not run in CI.
pycma is run by
validation/oracles/cmaes/pycma_runs.py,
whose results are committed beside the test.
Using the optimizer
An example
The example program
crates/hpr/examples/optimization.rs
runs CMA-ES on three of the test functions. Then it takes a 66 mm (2.6 in) rocket on a J760. The
rocket starts from a 3 m (9.8 ft) rail at 85°, into 5 m/s (11 mph) of wind.
The example finds the nose ballast and body tube length that give the rocket two things at once. One is an apogee of 3,048 m (10,000 ft) above the pad. The other is a static margin of 2.20 calibers at launch mass (at Mach 0.3). Run the example from a copy of the repository with:
cargo run --example optimization -p fusionspace-hpr
Why two goals? With one goal, the apogee, and two variables, there’s a whole curve of answers. More ballast and a shorter body cancel out, and the run would stop at whichever hit it reached first. A second goal, the margin, leaves one design that meets both. So the answer is the rocket’s, not the run’s.
The heart of it, abridged from the example:
let variables = vec![
Variable::new("nose ballast (kg)", 0.3, 0.15)?.within(0.0, 1.0)?,
Variable::new("body tube (m)", 1.0, 0.1)?.within(0.6, 1.4)?,
];
let optimizer = Cmaes::new(variables)?
.with_target(1e-4)? // stop within a centimeter and a ten-thousandth of a caliber
.with_max_evaluations(2_000)?;
let optimum = optimizer.minimize(seed, |x| {
// (apogee miss in m)² + (margin miss in hundredths of a caliber)²;
// a design the simulator refuses ranks last
miss(x[0], x[1], FlightSettings::default()).unwrap_or(f64::INFINITY)
})?;
miss builds the rocket with that ballast and body length, flies it, and adds the two squared
misses. Each miss is in a unit that makes a miss of one about equally bad. A design that can’t fly
returns infinity, which ranks below every real flight.
Then the example flies the winner twice more. The first flight is from a fresh build, and must give the optimizer’s result to the last bit. The second has the integrator’s tolerances 100 times tighter, and must still reach apogee within 0.1 m (0.3 ft) of 3,048 m (10,000 ft).
The example prints whether each test function reached its minimum, not how many evaluations it
took. Operating systems round the last bit of ln and exp differently, and an optimizer’s path
amplifies that. So the counts move by a few per cent between macOS, Linux and Windows. The
medians above are the test’s, on the development machine. The example prints:
CMA-ES on three test functions, 10 variables from 1.0, run to f ≤ 1e-10 (seed 2026)
function reached f ≤ 1e-10 best point within 1e-5 of x = 0
sphere yes yes
ellipsoid yes yes
rotated ellipsoid yes yes
A 66 mm rocket on a J760: find the nose ballast and body length for a 3,048 m apogee
and a static margin of 2.20 calibers at launch mass, at Mach 0.3
Not yet validated: see the Accuracy page before trusting these numbers.
Start: 0.30 kg of ballast, a 1.00 m body: apogee 3128.8 m, margin 1.79 calibers
Found: 0.34 kg of ballast, a 1.11 m body (stopped: Target)
Flown again: apogee 3048.0 m, margin 2.20 calibers
Flown again, tolerances 100 times tighter: apogee 3048.0 m
The rocket started 81 m (266 ft) too high, with a margin of 1.79 calibers. The optimizer found the design in 300 flights on the development machine, about 50 generations. Flown again with tighter tolerances, its apogee moves by 1.4 mm (0.055 in). Limits on other things, such as the rail-exit speed, are the subject of Limits on a design. The second example uses them.
Evaluating designs your own way
minimize flies one design after another. To fly a generation’s designs on several threads or
machines, use the run’s steps yourself (Run). Cmaes::start draws the first generation, and
candidates lists its designs. tell takes their values, in the same order, and draws the next.
tell returns the result once the run stops.
Choosing the numbers
- Steps: about a quarter to a third of the range the answer is likely in, in the variable’s own units. Steps of very different sizes are fine.
- Target: for a target apogee, the squared miss you accept:
0.1 * 0.1for 0.1 m (0.3 ft). Without a target, a run goes on until it converges, which can take many more flights than a hit needs. - Evaluations: a cap on flights, 10,000 by default. The first example’s two variables needed 300 flights, and the second example’s four variables 360. The ten-variable test functions take 1,600 to 6,500 evaluations to converge.
- Population: leave it at the default unless the output has many local minima. Then a larger
population (
Cmaes::with_population) searches more widely, at more flights per generation. - Seed: a different seed gives a different run. Rerun with two or three seeds if the answer matters: if they agree, the answer isn’t luck.
- NSGA-II’s population and generations: the number of flights is the population times the generations. The defaults, 100 designs for 250 generations, are 25,000 flights, sized for 30 variables. The third example’s two variables needed 20 designs for 25 generations, 500 flights, to pass its 0.5% check. The population is also how many designs the front can hold.
Limits on a design
A design usually has limits as well as a goal. It needs a stability margin of at least 1.5 calibers, say, or at least 15 m/s (49 ft/s) off the rail. The optimizer takes them as constraints, each written as a number that must not be above zero. A margin of at least 1.5 calibers is .
Your model returns an Evaluation: the value, and the violation, the sum of every that is
above zero. Evaluation::constrained(value, &[g1, g2]) adds them up.
Candidates are ranked by K. Deb’s feasibility rules, from Deb’s 2000 paper (the decision record):
| Comparing | The better one is |
|---|---|
| one that keeps every limit, one that doesn’t | the one that keeps them |
| two that keep every limit | the smaller value |
| two that break some | the smaller violation |
No penalty weight is needed, because a value is never weighed against a violation. Do scale the limits so they count alike. A margin 0.1 caliber short and a rail speed 0.1 m/s (0.3 ft/s) short aren’t equally bad. So divide each by a size you care about, such as the 1.5 calibers or the 15 m/s (49 ft/s).
Candidates that break a limit are kept and ranked, not redrawn. So a run can close in on an answer
that sits on a limit, as most good designs do. Only a point that keeps every limit counts as
reaching a target. The Optimum reports its violation, zero when it keeps them all.
For a bound the answer will sit on, leave the variable unbounded on that side and write the bound as
a limit. Clamp the value you fly (no negative ballast), and work the limit out from the unclamped
one. A design that can’t be flown at all returns Evaluation::failed(), which ranks behind every
other. A run that never keeps every limit says so: its violation is above zero.
The tests hold this to three problems whose answers on their limits are known exactly:
| Problem | Limit | Answer |
|---|---|---|
| , 10 variables | 1, at | |
| , 10 variables (the “tangent” problem) | 10, at every | |
| g06 of the CEC 2006 benchmark, 2 variables | inside one circle, outside another | −6,961.81388, where the circles cross |
From each of 20 seeds the run reaches the answer to of its size, and to within of the point. That holds also when the run starts where the limit is broken.
Choices: a motor, a catalog part
Some variables are choices from a list rather than amounts: which motor, which nose cone from a
maker’s catalog. Make each one an integer variable (Variable::integer). It takes only the
whole numbers from its low bound to its high one. Your model uses the number as a place in your
list: 0 for the first motor, 1 for the second, and so on.
The optimizer still draws a real number for the variable, and gives your model the nearest whole number. Left at that, the cloud would shrink in that variable until every draw rounded to the same number. The choice would then freeze, even with a better one next to it.
CMA-ES with margin (R. Hamano, S. Saito, M. Nomura and S. Shirakawa, GECCO 2022, arXiv:2205.13482) prevents that. After each generation it keeps at least a small chance that a draw lands on another value. That chance is the margin, which has nothing to do with a stability margin. The method keeps it by moving the cloud’s center towards the edge between two values, or by widening the cloud in that variable.
The margin is , for variables and designs a generation: 1 in 32 for the example below. So a choice is never final: its neighbors keep being tried.
Put the list in an order where neighbors are alike, such as motors by total impulse. The optimizer steps between neighboring numbers, so in that order a step up means a little more motor. A list in no order still works, but the search has less to go on.
The example
The example program
crates/hpr/examples/motor_and_nose.rs
builds a 2.6 in rocket from Madcow Rocketry’s parts in the built-in
catalog. The parts are a 1.0 m (39 in) fiberglass body
tube, an 18 in motor tube and three fiberglass fins. The example flies the rocket from a 3 m
(9.8 ft) rail at 85° into 5 m/s (11 mph) of wind. The optimizer chooses four things:
| Variable | Kind | Range |
|---|---|---|
| the motor | integer | the five 54 mm motors of the built-in catalog that fit, by total impulse |
| the nose cone | integer | four Madcow nose cones for 2.6 in, shortest first |
| the nose ballast | continuous | 0 to 1.5 kg |
| the fins’ span | continuous | 3–15 cm (1.2–5.9 in) |
The goal is the squared miss from 3,048 m (10,000 ft). The limits come from the International Rocket Engineering Competition’s rules (its Design, Test & Evaluation Guide, 2025). The limits hold over the whole ascent, from the rail exit to apogee (§10.3.1 says “from launch”; on the rail, the rail holds the rocket):
- a stability margin of at least 1.5 calibers in flight (§10.3.1 asks for a “dynamic” margin). The example takes the flight margin, the margin at the flight’s own Mach number, as the flight metrics define it;
- a static margin, the one at Mach 0, of at most 4 calibers, and a flight margin of at most 6. Both keep the rocket from being over-stable (§10.4.1);
- at least 30 m/s (98 ft/s) off the rail (§10.2.1).
The margins change through the flight. The center of mass moves forward as the motor burns, so the margin grows, and the flight margin changes with speed. For the lower limit the example uses the least flight margin of the ascent. The flight finds that least value inside its steps, not only at their ends.
For the upper limits the example uses the largest static and flight margins seen at the end of each integration step. The static margin only grows during the burn and stays put after it, so its largest is exact. A peak of the flight margin between two step ends could be missed. The winner’s largest, 4.83 calibers, is well under its limit of 6.
The heart of it, abridged from the example. Set a choice’s bounds with within, then mark it
integer. With limits, use the run’s steps yourself (Run) and give tell_constrained an
Evaluation per design:
let variables = vec![
Variable::new("motor", 2.0, 1.0)?.within(0.0, 4.0)?.integer()?, // a place in the motor list
Variable::new("nose", 1.0, 1.0)?.within(0.0, 3.0)?.integer()?, // a place in the nose list
Variable::new("nose ballast (kg)", 0.4, 0.15)?.within(0.0, 1.5)?,
Variable::new("fin span (m)", 0.07, 0.015)?.within(0.03, 0.15)?,
];
let mut run = Cmaes::new(variables)?.with_target(1e-4)?.with_max_evaluations(3_000)?.start(seed)?;
let optimum = loop {
let mut evaluations = Vec::new();
for x in run.candidates() {
// x[0] and x[1] are whole numbers within their bounds
let (motor, nose) = (x[0] as usize, x[1] as usize);
let design = Design { nose, ballast_kg: x[2], fin_span_m: x[3] };
evaluations.push(match flyer.fly(&motors[motor], &design) {
Ok(flown) => {
let miss = flown.apogee_m - 3048.0;
Evaluation::constrained(miss * miss, &flown.limits()) // each limit g ≤ 0
}
Err(_) => Evaluation::failed(), // a design that can't fly ranks last
});
}
if let Some(optimum) = run.tell_constrained(&evaluations)? {
break optimum;
}
};
Design, Flyer::fly and limits are the example’s own. They build the rocket, fly it, and write
each limit as a number that must not be above zero (Limits on a design).
A draw for an integer variable outside its bounds is clamped to the nearest end, not drawn again.
Run the example from a copy of the repository with:
cargo run --example motor_and_nose -p fusionspace-hpr
It takes about half a minute in a debug build. It prints:
A 2.6 in rocket of Madcow Rocketry's parts: choose the motor, the nose cone, the nose
ballast and the fin span for a 3,048 m apogee, with margins over the ascent of at
least 1.5 calibers (flight), at most 4 (static) and 6 (flight), and at least 30 m/s off a 3 m rail
Not yet validated: see the Accuracy page before trusting these numbers.
motor total impulse (N·s) designs flown nearest apogee within the limits
J450DM 1061.6 3 2648 m
J300LR 1212.8 6 none
J760 1267.3 25 3057 m
K400C 1307.3 307 3048 m
K940 1636.1 19 3150 m
Found: the K400C with the PNC26K-W nose (3:1 ogive, plastic), 0.35 kg of ballast, fins 8.9 cm in span
(stopped: Target, after 360 flights)
Flown again: apogee 3048.0 m, top speed Mach 1.23, rail exit 33.8 m/s, liftoff mass 2.60 kg;
margins over the ascent: flight 3.04 to 4.83 calibers, static at most 3.88
Flown again, tolerances 100 times tighter: apogee 3048.0 m, rail exit 33.8 m/s
Both flights within 0.1 m of 3,048 m and within every limit: yes
The table counts the designs the run flew with each motor. The total impulse is from the motor’s thrust curve. The last column is the apogee nearest 3,048 m (10,000 ft) among the designs that kept every limit.
The run tried every motor. Its few J450DM designs that kept the limits fell well short. None of its J300LR designs kept them all. It settled on the K400C and stopped once it was within a centimeter of the target.
The winner was flown again, with the integrator’s tolerances as set and then 100 times tighter. Both flights are within 0.1 m (0.3 ft) of 3,048 m (10,000 ft), and keep every limit over the whole ascent.
Read the table as what this one run saw, not as what each motor can do. A few designs, or a few dozen, say little about a motor.
The answer isn’t unique. A scan of every motor and nose over the ballast and the fin span was run once on the development machine, and not kept. The scan found the J760, the K400C and the K940 can each hit 3,048 m (10,000 ft) within the limits. Each can do it with any of the four noses.
A hit with any of them scores the same, so another seed may settle on another. To prefer one, say so in the goal. A small cost for liftoff mass is one way.
Unlike the first example’s counts, this run’s come out the same on every platform CI runs. CI
checks the output on macOS, and on Linux and Windows on x86-64 and ARM, whose last bits of ln
and exp differ. On the development machine the run was also tried with every flight perturbed
(the integrator’s tolerance changed by up to 1%). It was tried, too, with the step size moved by
a few bits each generation. Neither changed a line of the output; those trials aren’t kept.
Your own runs repeat bit for bit on one machine from the same seed. On another machine, a run can take another path.
Some goals change only when the choice changes, such as “the smallest motor that can do it”. Such a goal gives the search nothing to follow between choices. For that question, run the optimizer once for each motor, the motor fixed, and compare. The continuous search then only has to find a design that keeps the limits.
The body tube’s length is fixed on purpose. Past Mach 1.2 a flight needs a table of the body’s supersonic pressures, which takes a fifth of a second or more to build. Designs with the same outside shape can share one table. So with the length fixed, the example builds at most three, one per fiberglass nose cone; the plastic one has none (below).
With the length a variable, every design would build its own, and the run would take minutes.
The example shows how to share the table, in its Flyer::fly.
The winning plastic nose cone gets no table. The catalog lists it 0.05 mm (0.0020 in) narrower than the tube (2.638 in against 2.640 in). The method behind the table doesn’t yet take a step in the body’s outline larger than a millionth of its area (issue #87).
So the simulator falls back on slender-body theory for the body’s normal force, its lift at an angle (Bodies faster than sound). It does so for the short stretch of the flight past Mach 1.2 (the rocket’s top speed is Mach 1.23). How much that moves the apogee hasn’t been measured; the flight spends only a moment above Mach 1.2.
Checked against
Three test functions of Hamano and co-authors (§5.1 of their paper), each with half its variables
continuous and half whole numbers
(benchmark::mixed):
| Function | Whole-number variables | Minimum |
|---|---|---|
| SphereInt, | −10 to 10 | 0 at |
| EllipsoidInt, the ellipsoid above | −10 to 10, with the largest coefficients | 0 at |
| SphereOneMax, + the number of zeros | 0 or 1 | 0 at continuous 0, every whole number 1 |
Each runs with 10 and with 20 variables, from 20 seeds, to a value of . The starts and
settings are those of
validation/oracles/cmawm/cmawm_runs.py.
That script runs the same functions with cmaes 0.13.1, an outside implementation (MIT) adapted
from the method’s authors’ code. The script’s runs have the active weights off, as HPR Sim’s are.
Every run of every case reaches the minimum, with each whole number exactly right. The median evaluations are within the test’s 25% of the outside implementation’s, and measured within 5%:
| Function | Variables | HPR Sim, median evaluations | Outside cmaes 0.13.1, median evaluations |
|---|---|---|---|
| SphereInt | 10 | 1,855 | 1,850 |
| SphereInt | 20 | 3,870 | 3,798 |
| EllipsoidInt | 10 | 3,460 | 3,625 |
| EllipsoidInt | 20 | 9,246 | 9,372 |
| SphereOneMax | 10 | 1,925 | 1,955 |
| SphereOneMax | 20 | 3,828 | 3,726 |
A unit test checks the margin itself after every generation of a mixed run, with each kind of
whole-number variable (integer_draws_keep_the_margin in
optimize/cmaes.rs).
Another sets up a run’s state by hand. It checks one correction of each kind against the paper’s
equations, worked out to 40 digits (margin_correction_matches_the_equations). With the margin
taken out, three of the six cases fail: some runs stall with a whole number stuck on a wrong
value. That was a one-off check, recorded in
the decision record for choices,
not run in CI.
Trade-offs: a Pareto front
Often two goals conflict. Bigger fins or more nose weight make a rocket more stable, and both cost apogee. There’s no single best design then. Instead there’s a set of designs, none of which can improve one goal without giving up some of the other: the Pareto front.
A design dominates another when it’s no worse in either goal and better in at least one. The front is the designs nothing dominates. Knowing the front shows what each extra caliber of stability costs, before you pick one design from it.
CMA-ES finds one design. For a front, HPR Sim has NSGA-II, a genetic algorithm by K. Deb and co-authors (2002). It keeps a population of designs and, each generation:
- breeds as many children as there are parents. Each pair of parents is chosen by two tournaments. In each, of two designs picked at random, the one on a better front wins. On the same front, the one further from its neighbors wins, by its crowding distance. It adds up the gaps between the design’s two neighbors’ values of each goal. Each gap is taken as a share of that goal’s range in the front. Every design plays two tournaments a generation. A pair’s children mix their parents’ values (crossover), then a few values are nudged at random (mutation);
- flies the children;
- sorts parents and children together into fronts: the designs nothing dominates, then those only the first front dominates, and so on;
- keeps the best half, front by front. The front that doesn’t fit whole keeps its designs with the most room around them. So the front stays spread out instead of bunching up.
Each variable needs a low and a high bound. The first generation is drawn evenly between them,
and the variable’s start and step aren’t used. The defaults are the paper’s: 100 designs, 250
generations and crossover of 90% of pairs. The default mutation is of one variable in , the
number of variables, on average (Nsga2).
NSGA-II makes every goal as small as it can; to maximize one, give its negative. It runs the generations it’s given, and has no test of when the front has settled. Run it again from a second seed, or for more generations, and compare the fronts.
Limits work as they do for CMA-ES. Goals::constrained takes each limit as a number
, and a design that keeps every limit beats one that doesn’t. A design that can’t be
flown is Goals::failed, behind every other.
The example
The example program
crates/hpr/examples/pareto_front.rs
takes the 66 mm (2.6 in) rocket on a J760 from An example. The rocket’s body is
fixed at 1.0 m (39 in). The example varies two things, the nose ballast (0 to 0.8 kg) and the
fins’ span, 4–10 cm (1.6–3.9 in).
The two goals are the highest apogee, and the largest static margin at launch mass, at Mach 0.3. Every design must keep at least 1.5 calibers. The heart of it, abridged:
let variables = vec![
// A start and step are required by `Variable`; NSGA-II uses only the bounds.
Variable::new("nose ballast (kg)", 0.3, 0.15)?.within(0.0, 0.8)?,
Variable::new("fin span (m)", 0.06, 0.015)?.within(0.04, 0.10)?,
];
let optimizer = Nsga2::new(variables, 2)?.with_population(20)?.with_generations(25)?;
let front = optimizer.minimize_constrained(seed, |x| match flyer.design(x[0], x[1]) {
// Both goals as large as they can be: their negatives as small.
Ok((apogee, margin)) => Goals::constrained(vec![-apogee, -margin], &[1.5 - margin]),
Err(_) => Goals::failed(), // a design that can't fly ranks last
})?;
for member in &front.members {
// member.point: ballast and span; member.objectives: −apogee and −margin
}
flyer.design is the example’s own: it builds the rocket, works out its margin and flies it. Run
the example from a copy of the repository with:
cargo run --example pareto_front -p fusionspace-hpr
It takes about a minute in a debug build. It prints:
A 66 mm rocket on a J760: how much apogee each caliber of static margin costs, over
its nose ballast (0 to 0.8 kg) and fin span (4 to 10 cm), with a margin of at least
1.5 calibers at launch mass, at Mach 0.3
Not yet validated: see the Accuracy page before trusting these numbers.
NSGA-II: 20 designs a generation, 25 generations, 500 flights (seed 2026)
The front: 20 designs, each flown again to the same apogee and margin
margin (cal) apogee on the front (m), interpolated between the two designs either side
2.0 3100
2.5 3050
3.0 2990
3.5 2940
At 2.5 calibers, CMA-ES alone (200 flights): apogee 3050 m; the front within 0.5%: yes
Between 2 and 3.5 calibers, each extra half caliber of margin costs this rocket 50 m (164 ft) to 60 m (197 ft) of apogee. Each apogee in the table is interpolated in a straight line between the two front designs whose margins bracket it. Two checks back the front up:
- Every one of its 20 designs is flown again from a fresh build and gives the same apogee and margin to the last bit. That shows the result repeats; it doesn’t show it’s right.
- At 2.5 calibers, CMA-ES alone is told to find the highest apogee with at least that margin. In 200 flights it gets the same 3,050 m (10,007 ft), to the nearest 10 m (33 ft). The front is within 0.5% of that apogee, the example’s check.
How much that depends on the seed was measured once, on the development machine, and isn’t checked in CI. From each of the 26 seeds 2020 to 2045, the front came within the 0.5%. The front ranged from 0.46% below CMA-ES’s apogee to 0.18% above. CMA-ES’s own answer in 200 flights varies by 0.24% over those seeds.
An earlier version of the example missed the check. With 20 designs for 12 generations its front fell 0.66% short, and the generations were raised to 25. (Before that, 24 designs over wider ranges spread the front from 1.5 to 5.3 calibers, too thinly, and the ranges were narrowed.) The 0.5% wasn’t changed (the decision record for trade-offs).
Checked against
Three test problems of E. Zitzler, K. Deb and L. Thiele (2000), whose fronts are known exactly
(benchmark::zdt). Each has 30
variables, each from 0 to 1:
| Problem | The front | What it tests |
|---|---|---|
| ZDT1 | , from 0 to 1 | a convex front |
| ZDT2 | a concave front | |
| ZDT3 | , in five separate pieces | a broken front |
Each is run from 20 seeds with the paper’s settings: 100 designs for 250 generations, 25,000 evaluations. Two numbers measure a run’s front against the true one:
- the generational distance (GD): the mean, over the front’s designs, of each one’s distance to the true front. Small when the front lies on the true one.
- the inverted generational distance (IGD): the mean, over points spread along the true front, of each one’s distance to the nearest design. Small only if the front also covers all of the true one, evenly. The points are at 1,000 evenly spaced ; on ZDT3, the 265 of them that fall on its pieces.
HPR Sim measures GD to the true front’s curve itself, not to points along it. The same problems
are run with pymoo 0.6.2, an outside implementation (Apache-2.0) by J. Blank and K. Deb. It’s set
up as the paper describes and run from seeds 1 to 20
(pymoo_runs.py).
Both sets of columns below are scored by HPR Sim’s measures; the pymoo columns are pymoo’s
fronts.
The rules were set from pymoo’s runs before HPR Sim’s were measured. Every HPR Sim run must be within twice pymoo’s worst. HPR Sim’s median must be at most 25% above pymoo’s, the margin CMA-ES’s tests allow against pycma.
Review of the first results added a second rule: the median at most 20% below pymoo’s, a factor of 1.25 either way. On these problems every variable but the first is best at its lower bound. An optimizer that drifts toward its bounds would score better than pymoo without being better. Both measures are distances in the objectives’ own scale, pure numbers with no unit. Measured:
| Problem | Measure | HPR Sim median (no unit) | HPR Sim worst (no unit) | pymoo median (no unit) | pymoo worst (no unit) | Bound on every run (no unit) |
|---|---|---|---|---|---|---|
| ZDT1 | GD | 1.07e-3 | 1.36e-3 | 1.10e-3 | 1.46e-3 | 2.92e-3 |
| ZDT1 | IGD | 4.90e-3 | 5.66e-3 | 4.96e-3 | 5.48e-3 | 1.10e-2 |
| ZDT2 | GD | 9.78e-4 | 1.40e-3 | 9.85e-4 | 1.41e-3 | 2.82e-3 |
| ZDT2 | IGD | 5.01e-3 | 5.44e-3 | 5.08e-3 | 5.35e-3 | 1.07e-2 |
| ZDT3 | GD | 4.13e-4 | 7.02e-4 | 4.50e-4 | 6.53e-4 | 1.31e-3 |
| ZDT3 | IGD | 5.38e-3 | 3.40e-2 | 5.51e-3 | 3.39e-2 | 6.78e-2 |
At the median, HPR Sim’s fronts lie 1% to 8% closer to the true front than pymoo’s. They cover it as evenly (IGD 1.3% to 2.3% smaller). Each problem’s worst HPR Sim run is 1.9 to 2.1 times inside its bound.
The worst ZDT3 run of each has an IGD six times its median. Each of those runs missed part of the front, a known hazard on a front in pieces. The per-run bound on ZDT3’s IGD is loose for the same reason, set by pymoo’s one such run. The median rule is what holds ZDT3’s coverage.
The table’s numbers come from
cargo test -p fusionspace-hpr-analysis --test nsga2 -- --nocapture
(tests/nsga2.rs).
The same test checks HPR Sim’s generational_distance against pymoo’s own, on pymoo’s fronts
and 500 reference points, to .
Deb and co-authors’ own runs (their Table II) report a mean distance of 0.033, 0.072 and 0.115 on these three problems. They measured it to 500 points of the true front. Their means are 18 to 87 times pymoo’s mean here, to the same 500 points (0.0013 to 0.0019). Why the paper’s are so much larger wasn’t investigated.
Unit tests check the pieces by hand
(optimize/nsga2.rs):
- fronts and crowding distances of small sets worked out on paper;
- that crossover spreads children by its authors’ distribution, far from a bound and cut at one, within five standard errors over 100,000 draws;
- that mutation steps do likewise, cut at each side’s bound, also within five standard errors over 100,000 draws;
- that crossover’s two children come out in either order;
- that children never leave a variable’s bounds, nor pile up on them;
- that a failed design, or one breaking a limit, ranks behind every design that keeps them.
ZDT3’s five pieces were solved to 40 digits and are checked against the equations that define
their ends (benchmark.rs).
They agree with pymoo’s to its ten digits, except where pymoo prints the second piece’s start as
0.182228780, a digit short of 0.1822287280.
Few evaluations: EGO
CMA-ES and NSGA-II spend hundreds of flights. That’s fine when a flight takes a tenth of a second. It’s not when one evaluation is a long Monte Carlo run, or a slow outside program. EGO (efficient global optimization; D. R. Jones, M. Schonlau and W. J. Welch, 1998), a form of Bayesian optimization, is built for that case. It spends its effort thinking between evaluations, so it needs only tens of them.
It works like this:
- It evaluates an initial design: 10 points per variable, spread evenly over the box the variables’ bounds make. The design is a Latin hypercube. Each variable’s range is cut into as many equal slices as there are points, and each slice gets one point.
- It fits a surrogate: a smooth guess at the model, drawn through every point evaluated so far. The surrogate is kriging (a Gaussian process). Besides its guess at any point, it gives a standard error : zero at the points already evaluated, and growing away from them.
- It asks where an evaluation is most worth making. The expected improvement at a point is the average amount by which an evaluation there would beat the best value so far. Outcomes that don’t beat it count as zero. Expected improvement is large where the guess is low, and where the guess is unsure.
- It evaluates the point of largest expected improvement, refits, and repeats.
Each variable needs a low and a high bound, as for NSGA-II; its start and step aren’t used.
By default a run stops after 20 evaluations per variable. Ego::with_max_evaluations sets
the budget, and Ego::with_target stops at a good enough value.
Ego::with_tolerance_improvement stops once no point is expected to gain more than a set
amount. The amount is in the model’s units (with a transform, below, in the transformed units).
The tolerance is off by default.
Jones and co-authors stop at 1% of the best value’s size. That can end a run well short of 1% from the minimum. On Hartmann’s three-variable function, 8 of 20 runs (seeds 1 to 20) stopped more than 1% away, the worst 4.7% (a reviewer’s measurement). Use a smaller amount (the paper suggests 0.1%) where it matters.
A stop at a share of the best value’s size never fires for a goal near zero (a miss): there, give an amount. A model that fails at a design returns ; EGO fits it as the worst value so far and goes on.
A worked example, on Branin’s function of two variables: its least value is
, at three points. The initial design is 20 points, and 30 more follow.
The 1 is the seed. This is the example on Ego’s API page, which runs as a
test from seed 1; tests/ego.rs runs seeds 1 to 20:
use hpr_analysis::optimize::Variable;
use hpr_analysis::optimize::benchmark::global::{BRANIN_MINIMUM, branin};
use hpr_analysis::optimize::ego::Ego;
let variables = vec![
Variable::new("x0", 2.5, 3.0)?.within(-5.0, 10.0)?,
Variable::new("x1", 7.5, 3.0)?.within(0.0, 15.0)?,
];
let optimum = Ego::new(variables)?.with_max_evaluations(50)?.minimize(1, branin)?;
assert_eq!(optimum.evaluations, 50);
assert!(optimum.value < 1.01 * BRANIN_MINIMUM);
Transforming the values
The surrogate assumes the model varies about as much everywhere. Some models don’t. Hartmann’s six-variable function is nearly flat at values near zero over most of its box, then drops into narrow wells, the deepest at −3.32237. Fitted to the raw values, the surrogate misjudges how deep an unexplored well could be, and EGO settles in the second-deepest, near −3.20.
Jones and co-authors meet this by fitting the surrogate to a transformation of the values. They
choose the transformation by checking how well the fit predicts points left out of it. They
“typically try the log transformation, , or the inverse transformation, ” (§3,
p. 468). On their test functions this chose for Goldstein and Price’s function and
for Hartmann’s six-variable function (§4.2, p. 474). Ego::with_transform offers
the two log transformations:
Transform::Log, , for a model whose values are all positive;Transform::NegativeLog, , for one whose values are all negative.
Both rise with , so the least is at the least . The surrogate, its guess and the expected improvement are all on the scale, as in the paper. The best point, a target and the result stay in the model’s units.
turns −3.32 into −1.20 and −0.01 into 4.6. It pulls the deep wells close together and pushes the near-zero plateau far out. So the wells no longer look like narrow spikes against a flat floor. Jones and co-authors chose it after checking the fit (§4.2) and give no deeper reason; neither does HPR Sim.
A value outside the transform’s range (zero or positive under ) is an error, not something to fit. The simulator doesn’t choose a transform for you: it runs none of the paper’s checks of the fit.
A worked example: Hartmann’s six-variable function from seed 10, in 100 evaluations, the initial design’s 60 included. Its second-lowest minimum is −3.20316, a well 3.6% above the deepest one. With the transform, the run’s best value is −3.30740 on macOS, 0.45% above the minimum, so it found the deepest well. Without the transform, the same seed ends at −3.20245, inside the shallower well.
How close the run gets inside the deepest well depends on the computer. The same run ended 1.01%
above the minimum on Linux and 1.47% on Windows. That’s most likely because a seeded run
magnifies the last-bit differences between the systems’ maths libraries; Rust’s arithmetic is the
same on all three. So the test in tests/ego.rs checks only which well the run ends in, a value
below −3.2032. The test accepts any run up to 3.59% above the minimum:
use hpr_analysis::optimize::benchmark::global::hartmann6;
use hpr_analysis::optimize::ego::{Ego, Transform};
// `variables`: six, each within [0, 1].
let optimum = Ego::new(variables)?
.with_max_evaluations(100)?
.with_transform(Transform::NegativeLog)
.minimize(10, hartmann6)?;
assert!(optimum.value < -3.2032); // below the second-lowest minimum
Checked against
tests/ego.rs
runs EGO from seeds 1 to 20 on two test functions. Branin’s has three minima of one value, and
Hartmann’s has local minima above its least. The rule is Jones and co-authors’ measure of
success: the best value within 1% of the minimum’s size. The budget was set from a probe on
seeds 1 to 10 at 40 evaluations, where Branin’s worst run missed by 1.03%. At 50, the 20 seeds
gave the gaps below (macOS debug build; print them with
cargo test -p fusionspace-hpr-analysis --test ego -- --nocapture).
| Function | Variables | Minimum (no unit) | Budget | Worst of 20 runs |
|---|---|---|---|---|
| Branin | 2 | 0.397887 | 50 evaluations | 0.118% above |
| Hartmann 3 | 3 | −3.86278 | 50 evaluations | 0.124% above |
| Hartmann 6, | 6 | −3.32237 | 250 evaluations | 0.289% above |
Branin’s minimum is exact. Hartmann’s is the value printed to six figures, and the test checks it by polishing with CMA-ES from the printed point.
Unit tests in
optimize/ego.rs
check:
- that the surrogate passes through its points;
- its fit, guess and standard error on three points, against the formulas worked by hand;
- the expected improvement’s limits;
- that the initial design fills every slice.
Unlike CMA-ES and NSGA-II, EGO isn’t compared with an outside implementation. The minima are known exactly, which is what the milestone asks for.
Hartmann’s six-variable function is held to the same rule with the transform, from
seeds 1 to 20. That runs in a program of its own,
benches/ego_hartmann6.rs
(cargo bench -p fusionspace-hpr-analysis --bench ego_hartmann6).
Every run ended within 1%. The last got there at evaluation 205. The budget of 250 was set from these same runs, with 45 to spare, so treat the 20 of 20 as in-sample. Jones and co-authors needed 121 evaluations from one run. They used an initial design of 65 points and an exact search for the largest expected improvement.
Without the transform, 14 of the same 20 runs ended at the local minimum near −3.20 after 250 evaluations. They ended 3.6% to 3.7% above the minimum. The 6 that found the deepest well got within 1% by evaluation 78 in 5 of them, and at 241 in the sixth. So the transform is the more reliable route, not always the faster one.
The 20 runs take about 3 minutes spread over 10 cores in a release build. CI’s tests use a debug
build, about 20 times slower, where they would take hours. So the local gate runs the program
whenever EGO’s code changes (scripts/gate.sh ego). CI runs only the one-seed example above,
with and without the transform.
The program’s numbers are from macOS; the debug and release builds gave the same runs bit for bit there. Nobody has run the 20 on Linux or Windows. A run there may end further from the minimum, or even in the shallower well, 3.6% away. The one-seed example’s spread above (0.45% to 1.47%) shows that runs move; it doesn’t bound how far.
EGO takes no limits, whole-number variables or noisy outputs yet (the decision record for EGO; for the transform, a second record).
Left out
- A choice is a whole number in a list you order. There’s no separate handling for choices with no order, beyond putting alike ones next to each other.
- Limits are inequalities only. For an equality , write with a small .
- NSGA-II takes only continuous variables with two bounds: no choices from a list yet. It runs the generations it is given, with no test of when its front has settled.
- EGO is checked on two, three and six variables only. It doesn’t choose a transform of the values for you (the paper checks the fit to choose one), and offers no . It takes no limits, whole-number variables or noisy outputs.
- No optimizing of a Monte Carlo run’s statistics, such as the chance of landing within a distance.
- No command-line or Python front end yet.
The API reference is
hpr_analysis::optimize.
The command line
This reference shows what each hpr command does and prints, and which exit codes it returns, for
use from a terminal or a script.
hpr is HPR Sim’s command-line tool. Today it does seven things:
- It flies a design, read from an OpenRocket file or a design file in the HPR design format, and prints how the flight went. It flies a separation under power, or several in turn.
- It flies a design many times, its uncertain inputs scattered at random (Monte Carlo), and prints how far its apogee and landing spread.
- It looks up motors in the catalog built into it or in a motor file of your own. It searches vendors’ stock and prices from motor.fusionspace.co.
- It converts motor files between the two common formats. It converts designs between OpenRocket’s
.orkand the HPR design format (.hpr, and.hprzwith other files beside the design). - It reads a flight log from an altimeter and prints what it says about the flight, with no design file and no simulation.
- It fetches a launch day’s weather, or reads a weather file, and writes the air and wind over the site as a profile.
- It writes shell completion scripts.
Its other commands are registered but not available yet. Each refuses and names the milestone, the step of the roadmap, that brings it (the table below).
Whether RockSim opens the converted motors is not checked. Accuracy says how close
hpr sim’s flights are to a real flight.
hpr motors show works out each figure with the code a flight uses. For a catalog motor it also
prints the warnings hpr sim --motor gives for flying the curve file a flight uses: a failing 1%
check, a light propellant mass, a loaded or burnout mass far from ThrustCurve.org’s record, and a
propellant share outside the span its records give
(Solid motors). On the 412 files that pass
the 1% check, it matches ThrustCurve.org’s statistics code to 3e-15, relative. On the 8 files
with two or more samples at the same time, that code’s averaging of them is turned off for this
comparison (Solid motors). hpr doesn’t re-run the
validation cases. To run the project’s automated check, clone the repository and run
cargo xtask validate --check (what it checks). The tests in
crates/hpr-cli/tests/
run every command as a user would, and check each --json document against its
published schema. hpr weather and hpr motors search carry their own notes on
how far to trust them (weather, stock).
Running it
Release 0.1 has downloads for Linux and Windows on x86-64 and for Macs with Apple silicon
(Install a release). To run hpr from a copy of the
repository instead, set it up as Getting started shows,
then run it through Cargo:
cargo run -p fusionspace-hpr-cli -- motors list
Or install it once, so that hpr works from any directory:
cargo install --path crates/hpr-cli --locked
hpr --help
hpr --help says what the tool does, then how to call it, and its commands and options. Two or
three examples of real use follow, each with what it does, and last the address of this page. Every
command’s --help has the same parts. It ends with the address of its own section of this page:
hpr sim --help ends with the one on hpr sim below.
-h is the short version: one line per option, and the examples’ command lines without the words
about them. A test parses every example as hpr does, so none names an option that isn’t there. It
doesn’t run them.
hpr --version prints its version and its designation, FS-ACHERNAR · SW · TOOL 001. Achernar is
the simulator’s internal name among FusionSpace’s products. The rest is its number as a software
tool
(project Eridanus).
FusionSpace is the family of programs whose design rules the simulator follows
(the product system).
It named its products after the stars of project Eridanus in October 2026
(the new designation). Before that, the simulator wrote
FS · SW · TOOL 005, and files stamped that way still read.
The accuracy note on every result
hpr sim and hpr mc end their text result, and the plot, with a three-part trust note. It says
what kind of figure this is, what the apogee was checked against, with numbers, and what to rely on
instead. The note is on standard output, so > flight.txt keeps it. --json carries it as trust,
with kind set to simulated. So do the files --export writes: a JSON recording, and the sidecar
beside a CSV
(the decision).
hpr weather, hpr analyze and hpr motors show end the same way. Each note has the same three
parts and a link to the page that says more. kind names what their figures are:
forecastfor Open-Meteo, GFS and RAP;measuredfor a Wyoming balloon sounding and a flight log;reanalysisfor an ERA5 file;copiedfor a motor’s figures, taken from its curve file or computed from it.
Where nothing has compared a figure with a measurement of what it stands for, the note says “not yet checked” (the decision). A forecast’s winds are one such figure: nothing has compared them with measured ones.
The numbers cover the apogee only, on 60 logged flights of fliers’ own designs, each flown in its
day’s air from ERA5. Each logged apogee is the height climbed in that air. The simulated apogee
averaged 8.0% above the logged one. It was within 10% on 31 and read low on 15, by at most 20%
(Accuracy: real flights of the private collection).
A run without --weather flies the standard atmosphere, and its note adds that on a warmer day
the rocket can climb higher than its apogee; a run with --weather doesn’t. Speed, drift and the
margin have no measured spread yet.
The note asks for room above the apogee when planning a waiver, the permission to fly above a height limit. It leaves the call to the RSO, the range safety officer.
Colors and messages
The result alone goes to standard output. Every message line goes to standard error: a refusal, and
the warning:, note: and help: lines printed beside a result. With --json, standard output
gets one JSON document instead, holding the warnings in its own fields. Standard error stays empty
(JSON output).
Each message line starts with a word that says what it is. So it reads the same with or without color:
| prefix | meaning | color |
|---|---|---|
error: | what went wrong; the command stopped | bold red |
warning: | something to check; the command went on | bold yellow |
note: | something worth knowing about the result | bold |
help: | what to do next, or where to read more; in a refusal, the last lines | bold blue |
The result itself is plain text, with two marks of emphasis when its stream gets color. Its first
line, which names what was read, and each table’s header row are bold. In a help: or note: line,
what to type is bold blue. That covers a command in backticks, such as `hpr motors list`, and
an option the line names, such as --config.
A name read from a file shows each control character in it as ?, or inside quotes as \u{1b},
\n and the like, so a downloaded file can’t send escape sequences to your terminal. Outside quotes,
line breaks are kept, and a result’s tabs.
The colors are your terminal’s own red, yellow and blue, so its theme decides how they look.
hpr decides for standard output and standard error separately, in this order:
--color alwaysor--color never, if given.NO_COLORset to anything but an empty value: no color.FORCE_COLORset to anything but an empty value: color, even into a file or a pipe.CLICOLOR_FORCEdoes the same, set to anything but an empty value or0.- Otherwise (
--color auto, the default) a stream gets color only when it is a terminal andTERMisn’tdumb.
So hpr sim rocket.ork > flight.txt writes the flight alone to the file, in plain text. Its
warning:, note: and help: lines stay on the terminal, in color. 2> messages.txt keeps those
in a file of their own. > run.txt 2>&1 keeps the flight and its messages together, in order. A
pipe is the same: hpr sim rocket.ork | less pages the flight while the messages print on the
terminal.
The examples on this page show what a terminal shows: both streams, in the order hpr writes them.
So a warning: line appears among the result’s lines, though it went to standard error. --json
output never has color, whatever the flag or the variables say. To turn color off everywhere, set
NO_COLOR=1. For one run, give --color never, which every command takes.
Typing numbers, and what a refusal says
A number is read the way you would write it by hand. Spaces around it are dropped. A comma between
groups of three digits is a thousands separator: --elevation 1,280 is 1,280 m (4,199 ft). A note:
line says so (note: --elevation 1,280 read as 1280 m) before anything else, in case the comma
meant something else.
That holds for every option that takes a number, negative ones included. --elevation -1,280 is
−1,280 m (−4,199 ft). --longitude -106,970 is read as −106,970° (not −106.970°) and refused, as a longitude is at
most 180° east or west.
Any other comma is refused with a question. 3,9 is 3.9 in much of the world, but it could be a
typing slip. 0,500 is refused too, as no number grouped in thousands starts with 0. The decimal
point is always a period.
The <M> in the first line is the option’s value, in meters. A usage error like this one exits with
status 2:
$ hpr sim validation/fixtures/ork/pod-flights/pods-none.ork --motor H54 --elevation 3,9
error: invalid value '3,9' for '--elevation <M>'
help: a comma is read only between groups of three digits, as in 1,280: is 3,9 meant as 3.9? Write the decimal point as a period
help: for more information, try '--help'.
$ echo $?
2
A refusal has two parts, as a compiler’s does. First comes an error: line that says what went
wrong, named the way you typed it. That’s the option with its value and unit, or the file’s path.
Then come help: lines that say what to do, the most useful last.
Every refusal has at least one help: line. A command that isn’t available yet (exit status 3)
names the milestone that brings it and where to follow it on the roadmap. A refusal that only a
fault in the simulator can cause asks you to report it at the issue tracker’s address.
A latitude past the pole is refused in the degrees you gave, with the range --latitude takes:
$ hpr sim validation/fixtures/ork/pod-flights/pods-none.ork --motor H54 --latitude 95
error: --latitude 95: the site's latitude is in degrees, from -90 to 90, north positive and south negative
help: for example `--latitude -33.9`
$ echo $?
1
A refusal raised by the simulator, rather than by an option, says so. It rounds its number to four significant digits and names the options that shaped the flight, as they were read. Here an elevation of a billion meters, chosen only to force the refusal, puts the launch site where there’s next to no air. Nothing slows the rocket, and it passes Mach 5, where the aerodynamics stop:
$ hpr sim validation/fixtures/ork/pod-flights/pods-none.ork --motor H54 --elevation 1e9
error: the flight stopped: it reached Mach 5.835; the aerodynamics stop at Mach 5 (the normal force's range)
help: the flight came from pods-none.ork with `--motor H54 --elevation 1000000000`: check those values, or fly it without them
$ echo $?
1
When no launch option was given, the help: line points at the design: its motor, masses and
parts.
A file that isn’t there is named with the closest name in its folder, one or two letters away in any
case. An example is help: is it rockets/vega.ork? It is the closest name in that folder. When the
folder isn’t there either, the folder is named instead.
A motor the bundled catalog lacks is named with the catalog’s motors whose designation or common
name begins with what you typed. H5 begins H54, the common name of 168H54-10A. The refusal
also gives ThrustCurve.org’s answer: the command that fetches the
motor, or, once the cache holds the answer, the motors that match the name:
$ hpr motors show H5
error: no motor in the bundled catalog is called H5
help: `hpr motors list` lists the catalog's motors, and a .eng or .rse file can be shown by its path
help: with a network connection, `hpr motors fetch H5` fetches it from ThrustCurve.org, and `hpr sim --motor` flies it
help: the catalog has H55W, 168H54-10A, 234H53-12A, H50 and HP-H550ST
$ echo $?
1
The commands
This table is written from the tool’s own list of commands. So it names only what hpr has, and
only the files each command really reads. “Not yet” commands exit with status 3.
| command | what it does | reads | prints | status |
|---|---|---|---|---|
hpr sim | Fly a design (.ork, .hpr, .hprz or a rocket’s .json) off a rail and print its flight; save its recording with --export | .ork, .hpr or .hprz, a rocket’s .json, a motor from the bundled catalog, .eng or .rse, or fetched from ThrustCurve.org | text, JSON, a recording as .csv, .json, .parquet, .geojson or .kml | available (how to use it) |
hpr convert | Convert a motor file between .eng and .rse, write a catalog motor as either, or convert a design between .ork, .hpr and .hprz | .eng, .rse, the bundled catalog, a design as .ork, .hpr or .hprz | .eng or .rse, .ork, .hpr or .hprz, text, JSON | available (how to use it) |
hpr motors | Look up motors in the bundled catalog, read a .eng or .rse motor file, fetch a curve from ThrustCurve.org, or search vendors’ stock and prices | .eng, .rse, the bundled catalog, motor.fusionspace.co’s stock and prices, fetched or saved, ThrustCurve.org’s curves, fetched and cached | text, JSON | available (how to use it) |
hpr weather | Fetch a launch day’s weather, or read a weather file, as a profile of air and wind | Open-Meteo, a University of Wyoming sounding, GFS or RAP, fetched or saved, a whole GFS file, an ERA5 .nc | text, JSON, a profile as .json | available (how to use it) |
hpr mc | Fly a design many times with its inputs scattered at random, and print how its apogee and landing spread; save every flight with --export | what hpr sim reads: a design and its motor | text, JSON, every flight’s draw and outcome as .csv | available (how to use it) |
hpr optimize | Search a design’s parameters for a goal | - | - | not yet: M6.3 |
hpr compare | Set a flight log against a simulation of it: how far the logged height and speed lie from the simulated, and each reading beside the simulation’s | a flight log, as hpr analyze reads it, a design, its motor and the launch, as hpr sim reads them | text, JSON | available (how to use it) |
hpr analyze | Read a flight log and print its readings, with no design file | a flight log in any layout HPR Sim reads, by its own reader, more logs of one flight, side by side on one timeline, a workbook’s sheet or a raw dump’s recording, as chosen, another logger’s table by a column mapping, binary records or a console capture by a record layout, a Raven FIP export below no header, by the header stated | text, JSON, a ghost file as .json, .czml or .gltf | available (how to use it) |
hpr diagnose | Diagnose what went wrong in a flight from its log | - | - | not yet: M7.4 |
hpr completions | Print a shell completion script for hpr | - | a bash, elvish, fish, powershell or zsh script, JSON | available (how to use it) |
Flying and scattering
hpr sim flies a design once, and hpr mc flies it many times with its inputs scattered.
hpr sim
hpr sim flies a design from a launch rail to the ground and prints what happened:
- its stability margin as it leaves the rail;
- its apogee;
- its speed off the rail;
- how its ejection delay suits the climb;
- how fast it comes down;
- its events;
- its top speed;
- where it came down.
It reads an OpenRocket .ork file, or a design in
the HPR design format: .hpr, or .hprz with its attachments. It also reads a
rocket’s JSON (.json, the tree Your own rocket describes).
A .hpr or .hprz flies exactly as the .ork it was converted from
(converting a design). It doesn’t print the .ork reader’s warnings,
though: hpr convert printed those.
Units
The text gives SI first. The US units a flyer in the United States reads follow in brackets
(parentheses): 1065.1 m (3494 ft). Every command that prints a height, speed, temperature, wind,
acceleration or size does this. So do the --plot figure and their note: and warning: lines.
A table’s heading names both units, m MSL (ft). Each cell gives the US figure in brackets after
the SI one, 1476.4 (4844):
| quantity | SI | US, in brackets |
|---|---|---|
| a height or a distance | meters to a tenth | whole feet |
| the rail’s length | meters to a tenth | feet to a tenth |
| a speed | m/s to a tenth | whole ft/s |
| the wind | m/s | whole mph |
| a station along the rocket (the CG and CP) | meters to the millimeter | inches to a tenth |
| a motor’s diameter and length | millimeters | inches to a hundredth and a tenth |
an acceleration (hpr analyze) | m/s² to a tenth | g to a tenth |
the air’s temperature (hpr weather) | °C to a tenth | whole °F |
the air’s pressure (hpr weather) | hPa | none: weather pressure is given in hPa |
| a motor’s masses | grams to a tenth | ounces to a tenth, pounds to a hundredth from one pound |
| thrust and impulse | N and N·s | none: motors are rated in them |
The plot’s right-hand scales are feet, feet per second and g (standard gravity, 9.80665 m/s²). The SI figure is the one to copy. The US one is rounded from it, to a whole foot for a height. That can differ by a foot from converting a rounded SI figure.
The site’s own prose still gives most heights and speeds in SI alone, until issue #400. The command output it quotes follows the rule above.
There is no --units switch. Both units appear at once, so nothing needs choosing. A switch that
claimed to change units everywhere would also have to reach the exports.
Those stay SI: --json and the exported CSV and JSON files name each field with its unit
(height_above_ground_m). That’s a published format that scripts read and a spreadsheet converts in
one column. The app will bring one units control for all of it
(US units in brackets,
which carries out §6 of
the product system).
Flying a design
This flies one of the repository’s own test rockets, a small single-stage OpenRocket design. Its
file names an AeroTech H128W. --motor H54 puts the catalog’s Cesaroni H54 in its motor mount
instead:
$ hpr sim validation/fixtures/ork/pod-flights/pods-none.ork --motor H54
pods-none (pods-none.ork)
configuration 1 of 1: [H128W-0] with --motor H54
a simulated flight, not a measurement
static margin 2.69 calibers off the rail; least 2.69 calibers, at 0.15 s, before apogee
CG and CP 0.480 m (18.9 in) and 0.641 m (25.2 in) aft of the nose tip, off the rail
apogee 846.1 m (2776 ft) above the site at 11.21 s
rail exit speed 21.3 m/s (70 ft/s)
delay apogee 7.71 s after burnout, with the charges held
descent no recovery device opened, so the fall is not a prediction
motor: 1 × 168H54-10A (from the bundled catalog, as of 2026-10-28) in `Motor mount`, lit at launch
launched at 0.00000° N, 0.00000° E, 0 m (0 ft) above sea level, from 1.5 m (4.9 ft) of vertical rail above its aft end, in calm air
note: the file has no recovery device, so the rocket falls from apogee on its airframe alone. The aerodynamics hold only at small angles of attack. Its landing time, speed and place, and any peak it sets in the fall, are not a prediction
warning: drag: issue #18: skin friction is taken as fully turbulent; on a smooth surface a laminar run near the nose lowers it, by 3.6% on RocketPy's Calisto at Mach 0.3. If this surface is that smooth, the apogee, top speed and drift read low, and the flutter margin and largest dynamic pressure look better than they are
warning: stability: issue #172: the static margin read up to 0.1108 calibers above OpenRocket's on four private designs, cause unknown; this flight's may read high by as much
help: issues: https://github.com/nrdptel/fusionspace-eridanus/issues/<number>
event time height speed
liftoff 0.00 s 0.3 m (1 ft) 0.0 m/s (0 ft/s)
rail exit 0.15 s 1.8 m (6 ft) 21.3 m/s (70 ft/s)
burnout 3.50 s 466.0 m (1529 ft) 136.3 m/s (447 ft/s)
apogee 11.21 s 846.1 m (2776 ft) 0.1 m/s (0 ft/s)
ground hit 29.71 s 0.0 m (0 ft) 65.9 m/s (216 ft/s)
(heights are the center of gravity's above the site; speeds are over the ground, and a deployment's
airspeed through the air)
top speed 178.3 m/s (585 ft/s) at 2.31 s
top Mach number 0.525
landing 17.4 m (57 ft) from the pad at 29.71 s, at 65.9 m/s (216 ft/s): with no recovery device opened soon after apogee, not a prediction
How far to trust it. Simulated from the design file, not measured. Against 60 logged flights of
fliers' own designs, the simulated apogee averaged 8.0% above the logged one. HPR Sim flew each in
its day's air from ERA5, a weather reanalysis, and each logged apogee is the height climbed in it.
The simulated apogee was within 10% on 31 and read low on 15, by at most 20%. This flight was flown
in the standard atmosphere. On a day warmer than it at the site, the rocket can climb higher than
this apogee; --weather flies the day's air. Plan a waiver or a field's ceiling with room above this
apogee; the altimeter's reading is the one to log, and the RSO decides.
More: https://hpr.fusionspace.co/accuracy.html
What each part says:
| lines | what they say |
|---|---|
| the first two | the rocket’s name and its file; the configuration flown, by its number in the file and its name (below). [H128W-0] is the file’s unnamed configuration, called by the motor it holds, and with --motor H54 says the H54 flew in its place. The file’s other configurations follow, each with why it doesn’t fly as read, if it doesn’t |
a simulated flight, not a measurement | that every figure below comes from a model of the flight, not from a measurement |
static margin | the static margin as the rocket leaves the rail, in calibers, at Mach 0, and its least value from there to apogee. Each is the weakest direction’s: a rocket with a fin set of one or two fins has a different margin for each direction the air crosses it, and the simulator prints the least; the JSON’s roll_rad gives that direction (Flight metrics) |
CG and CP | the stations the margin off the rail comes from: the center of gravity and the center of pressure, each in meters and inches aft of the nose tip, as the rocket leaves the rail. The margin is their distance apart over the reference diameter. The JSON gives them as cg_station_m and cp_station_m |
apogee | the apogee: the height of the center of gravity above the site, and when |
rail exit speed | the speed at rail exit |
delay | the coast, from burnout to apogee, in the flight flown with no charge firing, so an early charge doesn’t cut it short. Then the delay the design sets, if any, and, for one motor lit at launch, how far before or after that apogee its charge fires, and how far the delay may fire short or long by NFPA 1125, with the vertical speed at either end where the simulator predicts it (Choose the delay). --motor sets no delay without --delay, so the example shows the coast alone; one with a delay follows the table |
descent | the vertical speed under each set of open parachutes or streamers, when the next one opens and at landing, without the wind’s drift. It rests on the drag area the file gives each device (the landing, where an example shows it). With none open, it says so and gives no speed |
motor: ... | the motor, how many of it fly (a cluster’s tubes and a pod set’s pods each carry one), and the motor mount it sits in, by name |
recovery: ... | each parachute or streamer the file flies: its name, its event and delay, its drag area, and when it opened, such as recovery: `Drogue parachute` at apogee, 0.133 m² of drag area, opened at 9.12 s (recovery in the JSON, below); the example’s file has none |
launched at ... | the site, the rail and the wind, below |
note: | what the flight leaves out of the design, and which numbers that spoils |
warning: | what the simulator’s .ork or motor-file reader accepted with a caveat, such as a part it left out, and what the design’s checks found unusual but buildable, each in a sentence naming the parts; the same words about several parts of one name are printed once, with a count such as (×2) |
warning: unstable: | the rocket is unstable while a motor burns, before apogee or the first deployment, and the apogee figure says it is not a prediction (Flight metrics: unstable under power). Either the static margin falls below zero, or, where the simulator can give no margin, the pitching moment’s slope is above zero; a flight prints one of the two. A help: line links that page. In the JSON, flags lists the first as unstable_under_power, its peak the least margin under power in calibers, which the summary also has as min_powered_static_margin_cal; and the second as unstable_without_margin, its peak the largest per radian where the margin is undefined under power, which the summary also has as max_powered_moment_slope_per_rad |
warning: envelope: | a flag of the operating envelope: the flight went faster than any public flight the simulator has been compared with a reference on (currently Mach 1.15; it rises as references are added), past the core band (Mach 2.5) or the envelope (Mach 3.5), or flew above 15° angle of attack while the air was strong enough to matter. Each says when, and a help: line links the page. A flag changes no number. In the JSON, flags lists them, each with its flag, the peak that raised it (its value, a Mach number or an angle in radians, with its time_s and height, as every peak has) and its message |
warning: drag:, warning: stability:, warning: flight: | a known error in the drag (#18, #67, #68, #70, #72, #73 or #222), in a separated part’s drag (#179 or #354, when they warn), in the stability margin (#64, #87, #120, #121, #172, #325, #326, #1198 or #1290) or in the flight’s path (#8, #106, #213 or #219, when they warn) that the flight meets, by its issue number (the list, with each one’s condition). Each says which way its numbers lean; a help: line gives the address; <number> is the issue’s. A flight on a drag table of your own prints no drag warning except #179 and #354 (a separated part’s), and keeps the stability and flight warnings; a normal-force table of its own prints no stability warning. |
| the events | each event’s time, the height of the center of gravity above the launch site, and the speed over the ground; the height at liftoff isn’t zero, as the rocket stands on the rail. A deployment’s row adds its airspeed, the speed through the air that sets the device’s opening load: in a wind it differs from the speed over the ground. The JSON gives every event’s airspeed_m_s, and the summary’s max_deployment_airspeed_m_s the top one |
| the last figures | the top speed and Mach number, and the landing |
OpenRocket’s example A simple model rocket, with its C6-5, prints this delay line:
apogee 5.91 s after burnout, with the charges held; the motor's set delay: 5 s; its charge fires 0.91 s before apogee; the delay may fire 1.5 s short or long (NFPA 1125): climbing at 25.1 m/s (82 ft/s) to falling at 5.7 m/s (19 ft/s).
In the JSON, issues lists the drag, stability and flight warnings, each with its issue number, its kind (drag, stability or flight), url, the flight’s max_mach peak, the parts that meet it (their ids; none for #8, #18, #68, #121, #172, #179, #219, #354, #1198 or #1290) and its message.
The text names configurations and parts by their names, in backticks, not by the long ids an
OpenRocket file gives them. A part with no name is called by its id. --json prints the same flight
as data, with the ids beside the names. The fields are each configuration’s id, name and label
(what the text calls it), and each motor’s mount and mount_name.
A missing motor is fetched, then kept: it flies offline from the cache. A .ork file names its
motor but rarely carries its thrust curve. The simulator’s catalog
holds ThrustCurve.org’s 1,004 solid motors, but a newer motor, or one ThrustCurve.org lists without
a curve file, isn’t in it. When the file embeds no curve and the catalog lacks the motor, hpr sim
fetches it. It finds the motor on ThrustCurve.org by the file’s manufacturer
and designation, keeps it in the simulator’s cache, and flies it. A note names the curve file, who
measured it and its license (Motors from ThrustCurve.org).
For the motors of OpenRocket’s own example designs, HPR Sim takes the ThrustCurve file that holds
OpenRocket’s curve. For any other motor the curve may not be the one OpenRocket flies. No such
flight has been compared with OpenRocket’s own curve yet. With --offline, or no network, and no
copy in the cache, hpr sim refuses and names the command that fetches it. Here the test rocket’s
motor is an invented one, which no catalog holds (abridged):
$ hpr sim validation/fixtures/ork/guides/no-curve.ork --offline
error: configuration [Z9-INVENTED] can't be flown as the file has it. No thrust curve for Z9-INVENTED: no embedded curve […]. Invented Z9-INVENTED is not in HPR Sim's cache of ThrustCurve.org, and the run is offline
help: with a network connection, `hpr motors fetch --manufacturer Invented Z9-INVENTED` fetches it into the cache
help: give a motor with --motor
Run that command once with a network connection, or fly the design once while online, and it
flies offline after. Or give a motor file you have: hpr sim my-rocket.ork --motor my-motor.eng.
The landing
A .ork file’s parachutes and streamers fly, as OpenRocket flies them. So do those of a .hpr
or .hprz converted from a .ork. hpr sim flies them through
hpr::ork::recovery, so its numbers are the library’s. Each opens
fully at once, the file’s delay after its event. The rocket then comes down under the open devices’
drag alone.
The landing speed is within 0.021% of OpenRocket’s on 50 of its 53 example flights, and within 0.12% on all 53 (Recovery). Those flights are in calm air. They check how fast and how long the rocket comes down, not where wind drifts it.
When the first device opens within 1 s of apogee, the landing is no longer marked “not a prediction”. Nor is a peak set once a device is open.
A later first opening, such as a main alone at 150 m (492 ft), keeps the mark. It stays on the landing and on any peak in the fall before the opening. A note says how long the rocket fell first. Where and how fast the device opens come from that fall, on the airframe alone, as below.
The JSON’s recovery list gives each device’s name and body, the part that carries it
(below). It also gives opens_at (apogee, altitude, ejection, launch or
separation), height_above_ground_m, delay_s, drag_area_m2 and opened_s.
A device the file sets to never, or to an ejection charge a plugged motor doesn’t fire, opens
nothing. A note says so. One set to its stage’s ejection charge, in a stage where no motor lights,
opens nothing too, as in OpenRocket. The note says “Main never opens: it opens at its stage’s
ejection charge, and no motor of its stage lights”. The other devices fly.
A device the simulator can’t fly as written, such as one inside a part it doesn’t read, is refused. The rocket then flies with none, and a note says why.
This flies the repository’s dual-deploy test rocket, a drogue at apogee and a main at 150 m
(492 ft). It flies the catalog’s H54 in place of its own motor. The H54 is a 29 mm (1.14 in)
motor in a 52.4 mm (2.06 in) bore, so a note says it flies with no adapter. The descent line
gives the speed under the drogue as the main opens, then at landing:
$ hpr sim validation/fixtures/ork/loft-demo/demo-dual-deploy.ork --motor H54
Loft Demo 54mm — dual deploy (demo-dual-deploy.ork)
configuration 1 of 1: [K550W-P] with --motor H54
a simulated flight, not a measurement
static margin 6.25 calibers off the rail; least 6.25 calibers, at 0.27 s, before apogee
CG and CP 1.005 m (39.6 in) and 1.354 m (53.3 in) aft of the nose tip, off the rail
apogee 324.0 m (1063 ft) above the site at 9.12 s
rail exit speed 11.2 m/s (37 ft/s)
delay apogee 5.62 s after burnout, with the charges held
descent 14.1 m/s (46 ft/s) at 150.0 m (492 ft) under `Drogue parachute`; 4.7 m/s (15 ft/s) at landing with `Main parachute` open too
motor: 1 × 168H54-10A (from the bundled catalog, as of 2026-10-28) in `Booster / motor bay`, lit at launch
recovery: `Main parachute` at 150 m (492 ft) on the way down, 1.052 m² of drag area, opened at 22.41 s
recovery: `Drogue parachute` at apogee, 0.133 m² of drag area, opened at 9.12 s
launched at 0.00000° N, 0.00000° E, 0 m (0 ft) above sea level, from 1.5 m (4.9 ft) of vertical rail above its aft end, in calm air
note: the 168H54-10A is 29.0 mm across, 23.4 mm narrower than the 52.4 mm bore of `Booster / motor bay`, and flies centered there with no adapter. An adapter's mass isn't included: it would move the apogee, up or down, and for an adapter aft of the center of gravity the margin reads high without it
note: the file's 2 recovery devices fly as OpenRocket flies them. Each opens fully at its event, with the file's drag coefficient or OpenRocket's own. Once one opens, the rocket descends as a point under the open devices' drag alone
warning: drag: issue #18: skin friction is taken as fully turbulent; on a smooth surface a laminar run near the nose lowers it, by 3.6% on RocketPy's Calisto at Mach 0.3. If this surface is that smooth, the apogee, top speed and drift read low, and the flutter margin and largest dynamic pressure look better than they are
warning: stability: issue #172: the static margin read up to 0.1108 calibers above OpenRocket's on four private designs, cause unknown; this flight's may read high by as much
help: issues: https://github.com/nrdptel/fusionspace-eridanus/issues/<number>
event time height speed
liftoff 0.00 s 0.6 m (2 ft) 0.0 m/s (0 ft/s)
rail exit 0.27 s 2.1 m (7 ft) 11.2 m/s (37 ft/s)
burnout 3.50 s 163.1 m (535 ft) 59.6 m/s (196 ft/s)
apogee 9.12 s 324.0 m (1063 ft) 0.0 m/s (0 ft/s)
charge 9.12 s 324.0 m (1063 ft) 0.0 m/s (0 ft/s)
deployment 9.12 s 324.0 m (1063 ft) 0.0 m/s (0 ft/s), airspeed 0.0 m/s (0 ft/s)
charge 22.41 s 150.0 m (492 ft) 14.1 m/s (46 ft/s)
deployment 22.41 s 150.0 m (492 ft) 14.1 m/s (46 ft/s), airspeed 14.1 m/s (46 ft/s)
ground hit 53.94 s 0.0 m (0 ft) 4.7 m/s (15 ft/s)
(heights are the center of gravity's above the site; speeds are over the ground, and a deployment's
airspeed through the air)
top speed 65.9 m/s (216 ft/s) at 2.73 s
top Mach number 0.194
landing 0.4 m (1 ft) from the pad at 53.94 s, at 4.7 m/s (15 ft/s)
How far to trust it. Simulated from the design file, not measured. Against 60 logged flights of
fliers' own designs, the simulated apogee averaged 8.0% above the logged one. HPR Sim flew each in
its day's air from ERA5, a weather reanalysis, and each logged apogee is the height climbed in it.
The simulated apogee was within 10% on 31 and read low on 15, by at most 20%. This flight was flown
in the standard atmosphere. On a day warmer than it at the site, the rocket can climb higher than
this apogee; --weather flies the day's air. Plan a waiver or a field's ceiling with room above this
apogee; the altimeter's reading is the one to log, and the RSO decides.
More: https://hpr.fusionspace.co/accuracy.html
With no device open soon after apogee, the landing is not a prediction. The rocket then falls from apogee on its airframe alone, as the example’s does. The simulator’s aerodynamics hold only at small angles of attack, and a falling airframe turns far past them. So where it lands, and how fast, are artifacts of the model. One test design glides tail-first far from the pad in calm air (issue #241).
A top speed or Mach number set in the fall is an artifact too. A rocket that falls faster than it
climbed shows its top speed after apogee. hpr sim marks it “in the fall: not a prediction”
(after_apogee in the JSON). The ascent, up to apogee, is what to read.
Separation
A .ork configuration whose booster drops away under power flies. So does
one that drops several stages in turn, but a dropped stage’s own flight is rough. hpr sim reads
the staging from the file, as hpr::ork::separations does, and
flies it with no --motor. A motor of your own can’t be told when the stages separate, so with
--motor it is refused. Each parachute and streamer rides the part its stage is in
(hpr::ork::separated_recovery).
On both configurations of OpenRocket’s Two stage high power rocket, the sustainer’s landing speed is +0.00% off OpenRocket’s. Its flight time is +0.32% and +0.73% off. On the first, its main opens 1.09 s before OpenRocket’s. That’s mostly because its apogee is 1.79% lower and OpenRocket opens 8.9 m (29 ft) below the set height (Staging).
After the split, each part flies as a point, with only its devices’ drag. So the booster tumbles from the split until its first own device opens. A sustainer with no device tumbles from its apogee.
A real booster flies nose-first for a while. So its peak and landing are likely too low and too close to the pad (issue #179). A note says so, and a map export draws no pin for it.
The sustainer, which keeps the nose, is part 0. The booster is part 1. Each device line names its
part (on part 1), and the booster’s landing is printed as landing, part 1, marked rough. A
tumble the simulator adds counts as no recovery device for the landing’s caveat. So a sustainer that
only tumbles lands with “not a prediction”.
In the JSON, a device’s body is null for the sustainer and the part’s index otherwise. added
is true for a tumble the simulator added, and a tumble opened at the split has opens_at
separation. The powered separation milestone shipped this. The
decision record
says why each part needs a device.
The JSON’s summary also gives each part’s own opening shock once it
flies apart from the rocket, in body_max_descent_acceleration_m_s2. Each entry has the part’s
body number, the value in m/s², and its time_s and height_above_ground_m. A part with no
device of its own open has no entry. The value is the largest drag of that part’s own open
devices over its own mass, so a booster’s opening shock appears only in its own entry.
The flight’s figure, max_descent_acceleration_m_s2, is the stack’s while it is whole and then
the sustainer’s. It never includes a dropped part. After a separation with no motor left to
burn, the sustainer flies on as part 0 and has an entry of its own as well, for its flight after
the split. The flight’s figure counts that flight too, until an
ejection parts the sustainer; part 0’s entry goes on past it.
A tumble counts as a device. So a booster that tumbles from a fast split reads the tumble’s drag there, which can be above its parachute’s opening later. That drag is far outside the speeds the tumble was fitted at, so it is no bound either way. A parachute that opens after such a tumble likely reads low, because the tumble slows the part more than a real booster slows. Like the flight’s figure, a part’s is not for sizing hardware (how to read each part’s figure).
Several separations fly too, one after another, from the tail forward. At each split the stages behind it drop away. The rest flies on as a new sustainer, which must still have a motor to burn. The parts are numbered in the order they drop.
OpenRocket’s Three stage low power rocket is one of the example designs OpenRocket ships. Its
booster is part 1 and its middle stage part 2, and the file names both Booster stage. On its first
configuration, an A8-5 above two B6-0s, the note says the stack comes apart under power 2 times.
Part 1, Booster stage, drops away at 0.857 s, and part 2, Booster stage, at 1.714 s. The
sustainer, part 0, flies on. The output then prints landing, part 1 and landing, part 2, each marked rough like a booster’s.
- Against OpenRocket, on its own thrust curves. All three configurations separate at OpenRocket’s times. Their apogees are within 1.48% and their largest speeds within 1.64% of OpenRocket’s (Staging).
- With the curves
hpr simfetches. The file holds no curves, sohpr simfetches them from ThrustCurve.org (Motors from ThrustCurve.org), taking the files that hold OpenRocket’s own curves. Its largest speeds are within 1.67% of OpenRocket’s. The first configuration reads 78.61 m/s (257.9 ft/s) against OpenRocket’s 78.37 m/s (257.1 ft/s). With the file’s parachutes, its apogees are within 1.37% of OpenRocket’s own record, which opens them too. They’re within 2.48% of OpenRocket’s flight with nothing deployed. - Not validated: the dropped middle stage’s own flight, like the booster’s (issue #179) (evidence row G13).
The several separations milestone shipped this. Its decision record (several powered separations) has the numbers.
Boosters strapped beside the core fly too, on a rocket of one stage on the axis. They form a
parallel stage, which burns with the core and drops at its own
separation. On OpenRocket’s Parallel booster staging, the boosters’ E12s light with the core’s
I115W at launch. The note begins “the stack comes apart under power at 2.440 s: part 1,
Booster Set, drops away”. Boosters with no motor that lights stay on to the landing, as OpenRocket
flies them.
Both configurations’ apogees are within 1.23% of OpenRocket’s (Staging: Boosters beside the core). The dropped boosters’ own flight is not validated, like a booster’s (evidence row G13). The parallel staging milestone shipped this. Its decision record says how a parallel stage is read and flown.
A booster may drop with motors still burning, when the file separates it at its first burnout. A stage with motors in more than one mount burns out when its first motor does, as OpenRocket flies it. It drops the rest still burning. The dropped part flies with no thrust, so a note names the motors and the impulse its flight leaves out.
The first configuration of OpenRocket’s Pods--powered with recovery deployment is
[C6-7; 2× A3-4, B6-0]. That lists its motors by stage, sustainer first, the stages separated by
;. Its note begins “part 1 drops at 0.860 s with A3, A3 still burning”. The impulse it gives,
0.509 N·s, is the one the report’s
Parts dropped still burning
section holds.
This sustainer is unstable, with a least margin of −4.21 calibers. OpenRocket’s record flies it from
a 0.15 m (5.9 in) rod at 28.61° N with no wind. In those conditions, HPR Sim’s sustainer turns over
at 2.04 s. From hpr sim’s defaults, a 1.5 m (4.9 ft) rail with no wind, it does not. So the apogee
printed assumes it stays upright, and why the two differ is not traced
(evidence row G17).
hpr sim warns that the rocket is unstable under power and marks that apogee as not a prediction
(Flight metrics: unstable under power;
#335). The
pods milestone shipped this
(Staging: A booster dropped still burning).
A payload dropped with nothing left to burn flies when its own parachute opens at the split.
Some rockets drop a payload section at the booster’s ejection charge, after the motor has burned
out, sometimes before apogee. From the split, each part flies as a point with only its own devices’
drag, as OpenRocket flies a descent. A payload with nothing open would coast as if in a vacuum. So
hpr sim flies the split only if the part that keeps the nose has its own device open by then.
A device set to lowerstageseparation opens at the split, its delay after. Otherwise the
configuration is refused with “the part that keeps the nose, would coast with no drag from the
separation at …”. To fly it, set one of the payload’s devices to open at the split. In OpenRocket,
that’s its deployment event “Lower stage separation” with no delay.
The payload is part 0, and its apogee is the flight’s. Its own events, such as its apogee and its
landing, follow the stack’s in the events table. The note begins “the stack comes apart at 4.860 s
with nothing left to burn: part 1, Booster, drops away”. A dropped part that climbs higher gets a
note, “part 1 peaks at … above the flight’s apogee”. It matters because a waiver’s height is the
highest any part reaches.
On OpenRocket’s Deployable payload and ARC payload rocket, all six configurations fly. Two of the six separate before apogee. The payload’s apogee is within 1.1% of OpenRocket’s, and every descent meets the targets. Each deployment is within 0.1 s of OpenRocket’s or 2% of its time, whichever is larger. The landing speed and flight time are within 5% (Recovery).
Each of the Deployable payload’s five configurations flies with two warnings. The payload and the parachute are 25 mm (0.98 in) across in a 21 mm (0.83 in) bore, so they can’t fit as drawn. Their width sets only their own inertia (a packed part wider than its bore).
- What the refusal avoids. Coasting from the split with no drag, the Deployable payload’s C6-3 payload would reach 268.8 m (882 ft). That’s 4.00% above OpenRocket’s 258.5 m (848 ft) for the same payload flying on its own airframe.
- Not validated: the booster’s flight after the split, as above (issue #179) (evidence row G13). Nor is a real payload whose parachute opens late, which would land later and farther away. OpenRocket’s record holds no such flight.
- The figure and the exports stop at the split.
--plotand--exportfollow the stack, which ends where it comes apart. After that, each part’s flight is in the events and landings only, and a note says so.
The unpowered separation milestone shipped this. Its decision record (a separation with nothing left to burn) has the numbers.
The launch
Every flight starts from a rail, at a site, in the
standard atmosphere unless --weather gives a profile. Without
options, the site is at sea level at 0° N, 0° E, and the air is calm. The rail is vertical, 1.5 m (4.9 ft) long, and has no friction.
hpr sim doesn’t read the launch conditions an OpenRocket file stores with its simulations. Give
them with these options.
Set --elevation for any real field. The air thins with height, so the same rocket flies higher
from a high site. From 1,400 m (4,593 ft), the rocket above climbs about 8% higher than from sea
level. Latitude changes gravity only a little: at 45° N its apogee moves by less than 0.2%. Set
--latitude and --longitude too before exporting a map, which is drawn where you say the pad is.
| option | what it sets | default |
|---|---|---|
--latitude DEG | the site’s latitude, degrees north (south is negative) | 0 |
--longitude DEG | the site’s longitude, degrees east (west is negative) | 0 |
--elevation M | the site’s height above sea level, m | 0 |
--rail-length M | the rail’s length, from the rocket’s aft end to the rail’s top, m | 1.5 m (4.9 ft) |
--inclination DEG | the rail’s angle above the horizon, degrees: 90 is vertical | 90 |
--heading DEG | the direction the rail leans toward, clockwise from true north, degrees (add the declination to a compass reading) | 0 |
--wind M_S | a wind of this speed at every height, m/s | calm |
--wind-from DEG | where the wind blows from, clockwise from true north, degrees: 270 is a west wind | 0 |
--weather FILE | the air and winds of an hpr weather profile, not with --wind or --wind-from; --elevation must lie within its levels | standard |
OpenRocket measures its launch rod’s angle from the vertical instead, so its 5° is 85 here. This flies the same rocket from Spaceport America’s field, on a rail leaning 5° into a west wind:
$ hpr sim validation/fixtures/ork/pod-flights/pods-none.ork --motor H54 --latitude 32.99 --longitude -106.97 --elevation 1400 --rail-length 3 --inclination 85 --heading 270 --wind 5 --wind-from 270
pods-none (pods-none.ork)
configuration 1 of 1: [H128W-0] with --motor H54
a simulated flight, not a measurement
static margin 2.71 calibers off the rail; least 2.71 calibers, at 0.21 s, before apogee
CG and CP 0.478 m (18.8 in) and 0.641 m (25.2 in) aft of the nose tip, off the rail
apogee 877.4 m (2879 ft) above the site at 11.48 s
rail exit speed 30.2 m/s (99 ft/s)
delay apogee 7.98 s after burnout, with the charges held
descent no recovery device opened, so the fall is not a prediction
motor: 1 × 168H54-10A (from the bundled catalog, as of 2026-10-28) in `Motor mount`, lit at launch
launched at 32.99000° N, 106.97000° W, 1400 m (4593 ft) above sea level, from 3 m (9.8 ft) of rail above its aft end, 85° above the horizon, leaning toward 270° T, in a 5 m/s (11 mph) wind from 270° T
note: the file has no recovery device, so the rocket falls from apogee on its airframe alone. The aerodynamics hold only at small angles of attack. Its landing time, speed and place, and any peak it sets in the fall, are not a prediction
warning: drag: issue #18: skin friction is taken as fully turbulent; on a smooth surface a laminar run near the nose lowers it, by 3.6% on RocketPy's Calisto at Mach 0.3. If this surface is that smooth, the apogee, top speed and drift read low, and the flutter margin and largest dynamic pressure look better than they are
warning: stability: issue #172: the static margin read up to 0.1108 calibers above OpenRocket's on four private designs, cause unknown; this flight's may read high by as much
help: issues: https://github.com/nrdptel/fusionspace-eridanus/issues/<number>
event time height speed
liftoff 0.00 s 0.3 m (1 ft) 0.0 m/s (0 ft/s)
rail exit 0.21 s 3.3 m (11 ft) 30.2 m/s (99 ft/s)
burnout 3.50 s 468.6 m (1537 ft) 144.4 m/s (474 ft/s)
apogee 11.48 s 877.4 m (2879 ft) 11.3 m/s (37 ft/s)
ground hit 28.71 s 0.0 m (0 ft) 70.3 m/s (230 ft/s)
(heights are the center of gravity's above the site; speeds are over the ground, and a deployment's
airspeed through the air)
top speed 184.3 m/s (605 ft/s) at 2.35 s
top Mach number 0.556
landing 310.4 m (1018 ft) from the pad at 28.71 s, at 70.3 m/s (230 ft/s): with no recovery device opened soon after apogee, not a prediction
How far to trust it. Simulated from the design file, not measured. Against 60 logged flights of
fliers' own designs, the simulated apogee averaged 8.0% above the logged one. HPR Sim flew each in
its day's air from ERA5, a weather reanalysis, and each logged apogee is the height climbed in it.
The simulated apogee was within 10% on 31 and read low on 15, by at most 20%. This flight was flown
in the standard atmosphere. On a day warmer than it at the site, the rocket can climb higher than
this apogee; --weather flies the day's air. Plan a waiver or a field's ceiling with room above this
apogee; the altimeter's reading is the one to log, and the RSO decides.
More: https://hpr.fusionspace.co/accuracy.html
In this flight the rocket climbs about 4% higher than in the first example, at sea level, not the 8% the altitude alone gives. The rocket turns into the wind as it climbs, and the rail already leans that way. So its climb tips away from the vertical. The wind does most of it.
The motor and the configuration
--config NAMEflies the configuration of that number, name or id. The output’s first lines list the file’s configurations by number and name.- A configuration the file leaves unnamed is called by its motors and their
delays in brackets:
[C6-5], or[C6-P]for a plugged motor. Two motors make[C6-5; B6-0]. OpenRocket files usually leave them unnamed (50 of the 56 in OpenRocket’s own examples). --configignores case and brackets, so--config c6-5takes[C6-5], as does its number, such as--config 4.- A name two configurations share is refused, with their numbers. So is a word that is one configuration’s number and another’s id or name, with their names and ids.
- Without
--config,hpr simflies the file’s default configuration, or its only one. If it can’t tell which, it refuses and lists them.
- A configuration the file leaves unnamed is called by its motors and their
delays in brackets:
--motor NAMEflies a motor of the built-in catalog, by its designation or common name (H54,168H54-10A).hpr motors listshows the catalog. A name several motors share, asG80is, is refused with a name for each that finds it alone, such asRoadrunner G80(A name several makers share); so is a motor the catalog lists with no curve file. A name is also refused when another motor of that name fits the mount better (A name that fits another motor’s mount). A name the catalog lacks is fetched from ThrustCurve.org and cached (Motors from ThrustCurve.org), ashpr motors fetch NAMEdoes.--motor FILEflies the motor in a.engor.rsefile (RASP and RockSim files). Either way, the motor goes in the configuration’s motor mount, in place of the file’s motor. It lights at launch.--delay Sgives--motor’s motor an ejection delay ofSseconds after burnout.--delay Pmakes it a plugged motor. Without it, the motor fires no ejection charge, so a parachute set to open on the charge stays shut. With it, the first line sayswith --motor H125-CT --delay 10. Thedelayline says how far from apogee the charge fires (Pick a motor).--offlinetakes a fetched motor from the cache alone, never the network. Setting the environment variableHPR_OFFLINE=1does the same for every command.--mount NAMEsays which mount--motorgoes in, by its name or id. Use it when the design has several and no configuration says, or to move the motor to another. A name two mounts share is refused, with their ids.--jsonlists each motor’smountid too.--accept-design-errorsflies a design whose checks find errors, such as a motor wider than its mount. The flight’s notes then list the errors: such a rocket can’t be built as drawn.
hpr sim refuses, with the reason, rather than fly something other than the design:
- with
--motor, a configuration with motors in more than one mount, as--motorflies one; - a rocket whose stages separate in a way
hpr simdoesn’t fly. Powered splits fly, one or several (Separation). These don’t:- a split with nothing left to burn, beside another separation;
- a lone split with nothing left to burn before apogee, with no device open on the part that keeps the nose;
- a split at or after apogee, beside another separation;
- a split that comes before the one behind it;
- a motor lit by a stage’s separation, in a design that states no separation, such as a rocket’s
.json; - with
--motor, a.orkrocket of more than one stage, or a configuration that switches a stage off; - a
.orkrocket the simulator couldn’t read exactly as written, such as one with a parallel stage on a rocket of several stages; - a design whose checks find errors, unless
--accept-design-errorsis given; - a hybrid motor in a
.rsefile, which says so: the simulator flies solid motors only. A.engfile doesn’t say what kind of motor it holds, so a hybrid’s is flown as a solid. Check the motor.
Exporting the recording
--export FILE writes the flight’s recording: every quantity the simulator tracks, every 0.01 s and
at every event. --interval sets the recording interval, down to 0.001 s. The file’s extension
picks the format. Repeat --export for several files. hpr sim won’t write over a file it reads.
| extension | what it holds |
|---|---|
.csv | one row per sample, with a header giving each column in words and its unit in brackets, such as time [s] |
.json | the same columns and rows, each column’s unit in its name (time_s), with the design, configuration, the catalog’s date and how far to trust it |
.parquet | the same, as Apache Parquet, for data tools such as pandas |
.geojson | the rocket’s path over the Earth, for web maps |
.kml | the same path, for Google Earth |
The maps draw the whole path. They mark the landing point only when a recovery device opened. With none open, the path after apogee and where it ends aren’t predictions.
Each file names the program that wrote it, its version and its designation. A CSV file can’t
without breaking a spreadsheet’s reading of it. So hpr sim writes a small file beside it that
does, flight.meta.json for flight.csv. That file also gives the design and configuration
flown, the number of rows and the bundled motor catalog’s as-of date. It holds the trust note
hpr sim ends with too (kind and trust, as --json has them).
Exporting a flight says where each format
keeps it, and what each column and field means.
Plotting the flight
--plot FILE.svg draws the flight as one picture, to look at rather than to analyze. It shows the
altitude, the speed and the acceleration against time, in three panels over one time axis. Each
event is marked. The figure is always the same set, so any two flights read
alike. An SVG opens in any web browser.
The numbers behind it come from the same flight as the text. Beside the figure, --plot writes
the numbers it draws as a CSV file: sim-plot.plot.csv for sim-plot.svg
(The figure’s data). For every quantity the simulator tracks, use
--export. The name must end in .svg and its folder must exist.
-
Altitude: the height of the center of gravity above the launch site, as the events table gives it.
-
Speed: the center of gravity’s speed over the ground, whose peak is the
top speedline. The thin line is its vertical speed, up positive. Under the parachutes, that’s thedescentline’s rate. -
Acceleration: the size of the nose tip’s acceleration, and its vertical part (the thin line, up positive). The nose tip is the point the simulator’s equations of motion track. The
--jsonsummary’s peak acceleration is taken there too. For a rocket that isn’t turning, every point of it accelerates alike. A recovery device opens fully at once (the landing), so its opening shows as a sharp spike. The spike is the motion’s acceleration, which includes gravity, so it differs by up to g from the opening shock the--jsonsummary gives (max_descent_acceleration_m_s2), which leaves gravity out: above or below it by up to g. -
Not what an accelerometer reads. The panel shows how the motion changes: zero on the pad, and in a coast about −10 m/s² vertically, gravity plus drag. An accelerometer reads about zero in that coast, and 9.8 m/s² on the pad.
-
Two scales: each panel’s left scale is SI, its title the quantity and its unit (
ALTITUDE · m AGL). Its right scale is the US unit, at round values of its own. Those are feet above the ground, feet per second, and g, one standard gravity (9.80665 m/s²). Both scales measure the one quantity the panel draws, so the gridlines are the SI scale’s alone. -
Events: each instant with events is a numbered balloon (a circle) above the panels, with a dotted line through them. The balloons sit in one row, in time order. Where two would overlap, as liftoff and rail exit do, the later one steps right. It points at its line with a short leader, a thin solid line, as a drawing’s balloons do. Near the right edge they step back left instead, so each stays whole.
-
Panel heights: each panel’s height is chosen so its own lines’ slopes can be compared. The eye compares slopes best near 45°. So the height is the one at which the panel’s lines run at 45° on average, each piece of line counted by its length. This is Cleveland’s “banking to 45°”, from “The Shape Parameter of a Two-Variable Graph” by W. S. Cleveland, M. E. McGill and R. McGill. It’s in the Journal of the American Statistical Association 83, 1988.
Heights stay between 120 and 360 px. A climb and a slow descent can’t both run at 45°, so the climb draws steeper and the descent flatter. Measured on the drawn figure below, the altitude and speed panels reach the 360 px cap, where their lines average 39° and 38°. The acceleration panel is 252 px, at 45°. When every panel was 180 px, the altitude and the speed lines each averaged 22°.
-
Not a prediction: the fall from apogee is hatched and labeled when no recovery device opens within 1 s of apogee. The hatching runs to the first opening, or to the ground. The summary’s “not a prediction” marks follow the same rule, for the reason the landing gives. The example below has no hatching, as its drogue opens at apogee.
The figure is drawn in the chart style of the FusionSpace product system. In that style, magenta marks a prediction, and every line here is one. There’s no legend box. A caption under the title says once what the lines mean:
| Line | Means |
|---|---|
| Dashed magenta, thick | A quantity’s size, simulated by HPR Sim |
| Dashed magenta, thin | Its vertical part, up positive, so below zero on the way down |
| Chain (long dash, dot) | The ground, in the altitude panel; the other panels’ zero lines are solid |
| Dotted | An event, under its numbered balloon |
| Hatched area | A fall that is not a prediction |
The caption’s first line is the figure’s summary: the apogee, its time and the top speed. They’re
the summary’s own numbers, with feet and feet per second in parentheses. The SVG carries the same
sentence as its description, which a screen reader reads out. Numbers on the figure are written
for reading, 1,000 and a real minus sign −20. Copy numbers from --export or --json, which
are plain.
In the caption, the notes and the balloons’ tooltips, a number and its unit are joined by a
no-break space. So a wrapped line never ends between 100.0 and m.
The table under the figure gives each event a row: its balloon’s number and time, the altitude then in meters and feet, and its name. Each parachute or streamer is named. Under the event table comes the accuracy note.
The figure then ends in a title block, as a drawing does. So a plot on paper says what it is and where it came from. It’s a box with a 2 px border, and each field is a label in capitals over its value:
| Field | Holds |
|---|---|
| OWNER | FusionSpace |
| TITLE | The design’s name, cut at 80 characters |
| TYPE | Simulated flight |
| DESIGNATION | The program’s designation, FS-ACHERNAR · SW · TOOL 001 |
| PROGRAM | The program and its version, FusionSpace HPR 0.1.0 |
| UNITS | The figure’s units, SI with the US scales in brackets |
| DATA | The figure’s CSV file (below) |
| MOTOR CATALOG | The day the bundled motor catalog was downloaded, as the exports carry it, whether or not the flight’s motor came from the catalog |
The block has no date of issue: the same flight draws the same figure, byte for byte, on any day.
The text is set in Cascadia Mono where it’s installed, else another fixed-width font, so the lines keep their widths. The title is 20 px. All other text, the balloons’ numbers included, is 12 px, the smallest size the FusionSpace product system allows on a screen. The caption, balloon row, event table and title block are spaced in that system’s 4 px steps. That’s 16 px from line to line and 24 px from row to row. The time axis is titled at its right end, under the last tick, as a drawing labels an axis.
The panels sample the flight every --interval (0.01 s unless set), at every event, and at the
start and end of each integration step. So a jump such as a parachute’s opening is drawn at its
instant and full height. Where a pixel column of the figure covers many samples, it keeps the
column’s first, least, greatest and last. A long descent stays a small file, and no sampled peak
is lost.
A peak the summary prints is found between samples, so the plotted one can sit just below it. In the example, a test holds the plotted top speed and the main’s opening peak within 1% of the summary’s (the plot’s design; its style).
This draws the dual-deploy rocket of the landing:
$ hpr sim validation/fixtures/ork/loft-demo/demo-dual-deploy.ork --motor H54 --plot sim-plot.svg
cargo xtask cli draws this figure with the command above, so it shows what the current hpr
draws. This site shows it at its full 960 px, wider than the text, wherever the window has room.
In a narrower window it shrinks to fit, and a click shows it at full size.
The figure’s data
Every chart in the FusionSpace product system gives its data as well as its picture. That’s for
a reader who can’t see the figure or wants the numbers. So --plot sim-plot.svg also writes
sim-plot.plot.csv, with one row for each point the figure draws. Its header names each column
with its unit in brackets:
time [s],altitude [m AGL],speed [m/s],vertical speed [m/s],acceleration [m/s^2],vertical acceleration [m/s^2]
The values are SI only, with no feet, and plain, as --export’s CSV writes them. The vertical
speed and acceleration, the panels’ thin lines, have columns of their own. The rows aren’t evenly
spaced: an event or a step’s edge adds a row between the --interval ones.
Beside the CSV, sim-plot.plot.meta.json names the program that wrote it, the design and
configuration, and the row count. It also gives the catalog’s date and the accuracy note, as an
exported CSV’s sidecar does. The .plot in
the names keeps them apart from an --export sim-plot.csv beside them. If a file the run reads
or writes has either name, the run stops before it flies. The text result ends with a wrote
line for each of the three files. --json names the two beside the figure under plot_data
(path, rows, meta).
What hpr sim doesn’t fly yet
- A rocket’s
.jsonhas no recovery devices. It holds no parachute, so the rocket falls from apogee on its airframe alone. That fall isn’t a prediction, and the output’s notes say so. A Rust program can fly one (Getting started). The devices of a.ork, or of a.hpror.hprzconverted from one, fly (the landing). One set to open at the lower stage’s separation (lowerstageseparation) flies only on a split with nothing left to burn (separation). Otherwise it’s refused. - Separation, beyond powered splits. A
.orkconfiguration whose booster drops away under power flies. So does one that drops several stages under power in turn (separation). A design whose only separation can come only after apogee flies as one stack, with a note. So does a design with no separation stated. A payload dropped with nothing left to burn flies when its own device opens at the split. The rest, and a staged configuration with your own--motor, are refused by name (the refusals).
hpr mc
hpr mc flies a design many times, each flight’s uncertain inputs drawn afresh about their
planned values. It prints how far the apogee and the landing spread, with
the ellipses the landings fall in. It reads whatever hpr sim reads, with the same
options for the design, the motor and the launch. It flies each flight as hpr sim does, a
staged .ork’s separations included. Monte Carlo dispersion explains the
method, what each dispersion does and how to choose the numbers.
A run that takes more than a tenth of a second draws its progress on standard error, when that’s
a terminal. Each line is drawn over the one before and is gone when the run ends:
flying 412 of 1000 flights [======== ] 41%, about 6 s left. The estimate assumes
the flights left take as long as those flown.
> runs.txt sends only the result to the file, so the progress still shows on the terminal.
With standard error into a file or a pipe, or with --json, it draws nothing. The flights are
the same either way.
Scattering a flight
This flies the repository’s small test rocket on the catalog’s Cesaroni H54 200 times. It flies in a 4 m/s (8.9 mph) wind from the west, off a rail leaned 5° into it. Each flight’s mass, drag, motor, wind and rail are drawn afresh:
$ hpr mc validation/fixtures/ork/pod-flights/pods-none.ork --motor H54 --runs 200 --seed 2026 --wind 4 --wind-from 270 --inclination 85 --heading 270 --mass-sd 0.02 --drag-sd 0.05 --impulse-sd 0.03 --burn-time-sd 0.02 --wind-sd 0.25 --wind-from-sd 15 --inclination-sd 1 --heading-sd 2
pods-none (pods-none.ork)
configuration 1 of 1: [H128W-0] with --motor H54
200 simulated flights, seed 2026: 0 failed
nominal mean std dev 5% median 95%
apogee (m AGL) 813.9 819.4 34.4 765.0 818.8 870.8
apogee (ft AGL) 2670 2688 113 2510 2686 2857
landing distance (m) 286.9 283.2 44.8 208.8 281.8 354.5
landing distance (ft) 941 929 147 685 925 1163
200 of 200 flights landed, centered 281.8 m (925 ft) west and 2.0 m (7 ft) north of the pad
landing ellipse semi-major semi-minor heading flights inside
50% 52.8 m (173 ft) 32.8 m (107 ft) 089° T 48.5%
95% 109.7 m (360 ft) 68.1 m (223 ft) 089° T 93.5%
95%, the next flight 111.1 m (365 ft) 69.0 m (226 ft) 089° T 93.5%
motor: 1 × 168H54-10A (from the bundled catalog, as of 2026-10-28) in `Motor mount`, lit at launch
launched at 0.00000° N, 0.00000° E, 0 m (0 ft) above sea level, from 1.5 m (4.9 ft) of rail above its aft end, 85° above the horizon, leaning toward 270° T, in a 4 m/s (9 mph) wind from 270° T
scattered, one standard deviation each: --mass-sd 0.02, --drag-sd 0.05, --impulse-sd 0.03, --burn-time-sd 0.02, --wind-sd 0.25, --wind-from-sd 15, --inclination-sd 1, --heading-sd 2
note: the file has no recovery device, so the rocket falls from apogee on its airframe alone. The aerodynamics hold only at small angles of attack. Its landing time, speed and place, and any peak it sets in the fall, are not a prediction
warning: drag, the nominal flight: issue #18: skin friction is taken as fully turbulent; on a smooth surface a laminar run near the nose lowers it, by 3.6% on RocketPy's Calisto at Mach 0.3. If this surface is that smooth, the apogee, top speed and drift read low, and the flutter margin and largest dynamic pressure look better than they are
warning: stability, the nominal flight: issue #172: the static margin read up to 0.1108 calibers above OpenRocket's on four private designs, cause unknown; this flight's may read high by as much
help: issues: https://github.com/nrdptel/fusionspace-eridanus/issues/<number>
How far to trust it. Simulated from the design file, not measured; the spread above comes from the
inputs' scatter alone, not from the model's error. Against 60 logged flights of fliers' own designs,
the simulated apogee averaged 8.0% above the logged one. HPR Sim flew each in its day's air from
ERA5, a weather reanalysis, and each logged apogee is the height climbed in it. The simulated apogee
was within 10% on 31 and read low on 15, by at most 20%. These flights were flown in the standard
atmosphere. On a day warmer than it at the site, the rocket can climb higher than this apogee;
--weather flies the day's air. Plan a waiver or a field's ceiling with room above this apogee; the
altimeter's reading is the one to log, and the RSO decides.
More: https://hpr.fusionspace.co/accuracy.html
The table gives the nominal flight’s figure: the flight hpr sim flies with the same options.
Then come the run’s mean, standard deviation, 5th percentile,
median and 95th percentile. Each length is in meters, then in feet on the row under it. The
landing’s center and the ellipses’ axes give feet in parentheses. A failed flight counts as tried
with no value.
When a flight opened a recovery device, two more figures follow, each when any flight has a value for it. The opening shock is each flight’s largest drag over the mass of the part hanging from its devices, in m/s² and then in g: the opening load over the mass, without gravity. (A motor still burning when a device opens adds its thrust.) A canopy in steady fall carries 1 g, so the figure reads at least about 1 g unless the flight reaches the ground, or comes apart at an ejection, before its canopy reaches steady fall; a median near 1.0 g means the openings were no harder than the steady fall. The opening airspeed is the fastest a device on the stack, or on the part that keeps the nose, opened through the air, the speed that load follows.
After a separation with no motor left to burn, both figures count the part that keeps the nose, whether its devices opened before the split or after: its shock is its own devices’ drag over its own mass, as the simulator flies that part as a point, with no drag from its airframe. The part dropped aft counts in neither figure. An ejection that parts the stack, or the part that keeps the nose, ends the opening shock’s count: from the charge on, neither the piece ahead of the parted joint (a nose cone pushed off is that piece alone) nor the pieces behind it count. The opening airspeed still counts the openings of the piece ahead.
--delay-sd and --deployment-lag-sd spread both: a charge late after apogee opens the device
faster, because the rocket has had longer to fall. The simulator opens a canopy at once by
default, and leaves out a canopy’s drag overshoot, so the shock is no bound either way, and not a
number to size a shock cord from (The opening load). Use
it to compare designs and delays: its spread shows how the timing moves the load. A flight that
opened no device has no value, as a failed one has none.
The columns cover only the flights that have a value, so a failed flight is left out of them. If the failed flights are the ones that would have flown highest or landed farthest, the 95% column reads low: with 5% failed, it is about the 90th percentile of all the flights tried. If they’d have been the lowest, the 5% column reads high.
So when some flights have no value for a figure, hpr mc says how many have one, and adds rows
under the table that count the failed flights. For the 5% they’re placed below every flown
flight, and for the 95% above every one. That makes the 5% the lowest and the 95% the highest
they could be, whatever the failed flights would have done. This run scatters the mass by 45%, so
now and then a flight draws a negative mass and fails:
$ hpr mc validation/fixtures/ork/pod-flights/pods-none.ork --motor H54 --runs 100 --mass-sd 0.45
pods-none (pods-none.ork)
configuration 1 of 1: [H128W-0] with --motor H54
100 simulated flights, seed 0: 2 failed
nominal mean std dev 5% median 95%
apogee (m AGL) 846.1 822.8 34.4 769.9 834.6 851.1
apogee (ft AGL) 2776 2700 113 2526 2738 2792
landing distance (m) 17.4 23.2 46.1 13.3 16.5 33.3
landing distance (ft) 57 76 151 43 54 109
the columns count only the flights with a value, of 100: 98 with an apogee, 98 with a landing;
with each of the others placed past that end, the 5% and 95% are at worst
apogee (m AGL) 734.1 851.4
apogee (ft AGL) 2408 2793
landing distance (m) 12.4 36.7
landing distance (ft) 41 120
98 of 100 flights landed, centered 23.2 m (76 ft) east and 0.0 m (0 ft) south of the pad
landing ellipse semi-major semi-minor heading flights inside
50% 54.2 m (178 ft) 0.0 m (0 ft) 090° T 97.0%
95% 112.8 m (370 ft) 0.0 m (0 ft) 090° T 97.0%
95%, the next flight 115.7 m (380 ft) 0.0 m (0 ft) 090° T 97.0%
motor: 1 × 168H54-10A (from the bundled catalog, as of 2026-10-28) in `Motor mount`, lit at launch
launched at 0.00000° N, 0.00000° E, 0 m (0 ft) above sea level, from 1.5 m (4.9 ft) of vertical rail above its aft end, in calm air
scattered, one standard deviation each: --mass-sd 0.45
note: the file has no recovery device, so the rocket falls from apogee on its airframe alone. The aerodynamics hold only at small angles of attack. Its landing time, speed and place, and any peak it sets in the fall, are not a prediction
warning: flight 9 failed: 00000000-0000-4000-8000-000000000099: mass override (kg) is outside its domain: -0.03909
warning: flight 31 failed: 00000000-0000-4000-8000-000000000099: mass override (kg) is outside its domain: -0.1449
warning: drag, the nominal flight: issue #18: skin friction is taken as fully turbulent; on a smooth surface a laminar run near the nose lowers it, by 3.6% on RocketPy's Calisto at Mach 0.3. If this surface is that smooth, the apogee, top speed and drift read low, and the flutter margin and largest dynamic pressure look better than they are
warning: stability, the nominal flight: issue #172: the static margin read up to 0.1108 calibers above OpenRocket's on four private designs, cause unknown; this flight's may read high by as much
help: issues: https://github.com/nrdptel/fusionspace-eridanus/issues/<number>
How far to trust it. Simulated from the design file, not measured; the spread above comes from the
inputs' scatter alone, not from the model's error. Against 60 logged flights of fliers' own designs,
the simulated apogee averaged 8.0% above the logged one. HPR Sim flew each in its day's air from
ERA5, a weather reanalysis, and each logged apogee is the height climbed in it. The simulated apogee
was within 10% on 31 and read low on 15, by at most 20%. These flights were flown in the standard
atmosphere. On a day warmer than it at the site, the rocket can climb higher than this apogee;
--weather flies the day's air. Plan a waiver or a field's ceiling with room above this apogee; the
altimeter's reading is the one to log, and the RSO decides.
More: https://hpr.fusionspace.co/accuracy.html
Two of the 100 flights failed. Counting them moves the apogee’s 5% from 769.9 m (2,526 ft) down to 734.1 m (2,408 ft), and its 95% from 851.1 m (2,792 ft) up to 851.4 m (2,793 ft). Plan with the rows that count them.
A row reads unbounded when so many flights failed that the percentile’s interpolation reaches a
failed flight: at 100 flights, from 5 failed. The run then can’t put a limit on that end. Read the
reasons the warning: lines give (the --export file’s reason column has each flight’s), fix
what makes the flights fail, and run it again. In the JSON these are each spread’s
p05_counting_missing and p95_counting_missing, {"value": ...} or "unbounded", and null
when every flight has a value. Failed flights are counted
shows the arithmetic.
Monte Carlo dispersion explains the landing ellipses. The
50% and 95% ellipses hold that share of a normal scatter with the run’s mean and spread. The last
allows for the run’s spread being only an estimate, so the next flight lands inside it 95% of the
time. flights inside counts the run’s own landings inside each, a failed flight counted
outside. This rocket has no parachute, so its landings aren’t a prediction, and the note says so.
An ellipse’s heading is the direction of its long axis, in degrees clockwise from true north.
It’s written as a map’s bearing is: three digits and a T for true, such as 089° T. True north
isn’t the north a compass shows. Magnetic north is more than 10° away from it in much of the
western United States. Every bearing hpr prints is from true north, the rail’s heading and the
wind’s direction too. So is every one it reads (--heading).
The options
Each dispersion is one standard deviation, zero by default, which leaves its input at its nominal value. With none given, every flight is the nominal one, and a note says so. Choosing the numbers gives values to start from, with their sources.
| option | one standard deviation of | the library’s field (in radians for an angle) |
|---|---|---|
--mass-sd FRACTION | each stage’s mass without motors, as a fraction of it (0.02 is 2%) | dry_mass_sd_fraction |
--cg-sd M | each stage’s center of mass along the axis, m | cg_sd_m |
--drag-sd FRACTION | the zero-lift drag coefficient | drag_sd_fraction |
--impulse-sd FRACTION | each motor’s total impulse, its propellant with it | impulse_sd_fraction |
--burn-time-sd FRACTION | each motor’s burn time, at the same impulse | burn_time_sd_fraction |
--delay-sd S | each motor’s ejection delay, s | ejection_delay_sd_s |
--wind-sd FRACTION | the wind’s speed at every height | wind_speed_sd_fraction |
--wind-from-sd DEG | the wind’s direction, about --wind-from or the profile’s | wind_heading_sd_rad |
--inclination-sd DEG | the rail’s angle above the horizon | rail_elevation_sd_rad |
--heading-sd DEG | the rail’s heading | rail_azimuth_sd_rad |
--deployment-lag-sd S | each recovery device’s lag after its trigger, s | deployment_lag_sd_s |
--runs N sets how many flights, 1 to 100,000 (100 by default). --seed N picks the random draws
(0 by default). The same seed, design and options give the same flights, bit for bit, on one
platform, whatever the machine’s number of cores. Before it flies, hpr mc refuses a negative
standard deviation, a run of no flights, and an export that isn’t a .csv.
Exporting every flight
--export runs.csv writes one row a flight, in index order: what it drew, then what its flight
came to. Each number is written in the shortest form that reads back to the same bits. So a
spreadsheet or a script reading the file gets the run’s own numbers. A number a flight doesn’t
have is an empty cell.
Beside the CSV, runs.meta.json names the program that wrote it, the design, the configuration
and the seed. It also gives the number of flights, the dispersion, the bundled motor catalog’s
as-of date, and the trust note hpr mc ends with (kind and trust). The CSV’s header gives
each column in words with its unit in brackets, apogee [m] for apogee_m, as Python’s
MonteCarlo.to_csv does. The table below gives the columns by the names Python’s run[...]
takes:
| columns | what they hold |
|---|---|
index, outcome, failed_at, reason | the flight’s number from 0; flown or failed; for a failed flight, whether its draw made an impossible input (inputs) or the flight refused it (flight), and the error |
drag_scale, wind_speed_scale, wind_turn_rad, rail_elevation_offset_rad, rail_azimuth_offset_rad | the factors and offsets drawn for the drag, the wind and the rail (1 or 0 for an input not scattered) |
stage_N_dry_mass_scale, stage_N_cg_shift_m | each stage’s, counted from 1 at the nose |
motor_N_impulse_scale, motor_N_burn_time_scale, motor_N_ejection_delay_offset_s | each motor’s in the configuration flown |
device_N_deployment_lag_offset_s | each recovery device’s, a tumble’s always 0 |
termination, apogee_m, apogee_time_s | why the flight ended, and its apogee above the site |
rail_exit_speed_m_s, max_speed_m_s, max_mach, max_dynamic_pressure_pa, max_acceleration_m_s2, max_descent_acceleration_m_s2, max_deployment_airspeed_m_s, min_static_margin_cal, min_flight_margin_cal, max_angle_of_attack_rad | the flight’s peaks, as hpr sim --json’s summary has them; max_descent_acceleration_m_s2 is the opening shock |
landing_time_s, landing_east_m, landing_north_m, landing_distance_m, landing_latitude_deg, landing_longitude_deg, ground_hit_speed_m_s | where and when it landed; after a split with nothing left to burn, where the part that keeps the nose landed |
part_N_landing_time_s, part_N_landing_east_m, part_N_landing_north_m, part_N_ground_hit_speed_m_s | for a staged flight, each dropped part’s landing |
flags | the operating envelope’s flags the flight raised, and unstable_under_power or unstable_without_margin, separated by ; |
The same table is hpr_analysis::table::RunTable in the Rust library.
What the output warns of
Failed flights are counted, never dropped. Each reason is printed once, with how many flights
failed so and the first one’s index, its row in the export. The
operating envelope’s flags, and the flag for a rocket
unstable under power, are counted over the flights.
The known issues in the simulator’s drag, stability and flight path are the nominal flight’s, as
hpr sim prints them. So are hpr sim’s notes on the flight’s own numbers, such as a fall from
apogee before a device opened, each beginning “the nominal flight:”.
A staged flight can fail where its nominal flight flies, and is counted with its reason:
- A separation timed in seconds isn’t scattered. So a flight whose drawn burn is longer still burns at it, which the simulator refuses unless the split may drop a burning motor. A separation at a burnout follows the drawn burn.
- A part dropped on the way up with nothing left to burn flies as a point, with only its open devices’ drag. A separation or an ejection charge can drop it. If its device fired by the split but waits out a drawn lag, the part would climb through the lag with no drag at all. So the flight is refused.
--json prints all of it as one document, its schema
schema/cli/mc.schema.json.
Motors and conversion
hpr motors looks up, reads, fetches and searches motors. hpr convert turns motor and design
files from one format into another.
hpr motors
The catalog the simulator looks motors up in is ThrustCurve.org’s whole solid catalog, captured
October 28, 2026: 1,004 motors, from class 1/8A to class O. The 80 with no curve file that reads are
listed, with a closing note naming them, but hpr motors show and hpr sim --motor refuse them
(the whole catalog). A maker’s name before the designation
picks one maker’s motor (Estes C6), and --json gives each motor’s selector, the name that
finds it alone. hpr motors fetch fetches a newer motor’s curve from ThrustCurve.org into the simulator’s cache, for hpr sim to
fly (fetching a motor), and hpr motors update fetches the ones
its records show the bundle lacks (newer motors). Or download its .eng or .rse file
(RASP and RockSim files) and show that.
hpr motors search lists the motors vendors have in stock, with their prices
(Motors you can buy).
Listing the catalog
hpr motors list lists the catalog. Three filters narrow it, and each one given must match:
--classtakes an impulse class, such asJ.--diametertakes a casing diameter in millimeters, such as54, and matches within 0.5 mm (0.020 in).--manufacturertakes a maker as themakercolumn spells it (AeroTech,Cesaroni,Loki,Estes,Quest,AMW) or its full name (Cesaroni Technology), in any case.
A class or diameter the catalog has no motor for lists none, and exits with 0. A class that doesn’t exist, a diameter that isn’t a positive number, or a maker the catalog doesn’t know is refused with status 1. A misspelt maker would otherwise look like a maker with no motors.
The figures are the catalog’s, each worked out from the motor’s default ThrustCurve.org curve
file (The bundled motors), or its record’s with no file. The size, masses and
delays come from its header, the rest from its curve. In the delays column, P (or
1000) means plugged: the motor has no ejection charge
(ejection delay). The delays are as the header writes them, which
can be fewer than the maker sells.
$ hpr motors list --class J --diameter 54 --manufacturer Loki
6 motors from ThrustCurve.org's solid motor catalog: every solid motor's record and every data file but a restricted one, captured 2026-10-28; size and delays from each motor's default file's header, the rest from its curve, or from ThrustCurve.org's record where no file of it is bundled.
designation maker class dia mm (in) len mm (in) impulse N·s avg N burn s delays
J350-SF Loki J 54 (2.13) 327 (12.9) 986.5 378.7 2.60 0
J820-LW Loki J 54 (2.13) 327 (12.9) 1144.5 791.1 1.45 0
J525-LW Loki J 54 (2.13) 327 (12.9) 1118.7 568.0 1.97 0
J175-LW Loki J 54 (2.13) 327 (12.9) 1157.1 195.5 5.92 0
J300LR Loki J 54 (2.13) 327 (12.9) 1212.8 297.0 4.08 P
J670LB Loki J 54 (2.13) 330 (13.0) 1267.1 674.5 1.88 P
A name several makers share
Several makers sell motors under one name. Roadrunner and Estes each make a G80, and G80 is
also the common name of AeroTech’s G80T and of others. hpr sim --motor never picks a maker for
you: it refuses the name and lists a name for each motor that finds it alone. That name is the
designation where only one motor has it, or the maker’s short name and the designation where
makers share it:
$ hpr sim rocket.ork --motor G80
error: G80: `G80` matches several motors: 93G80-14A, Roadrunner G80, PML G80T, G80-LW, AeroTech G80T, Estes G80
help: give --motor one of those names, each of which names one motor alone, such as `--motor 93G80-14A`
Give one of them, such as --motor "Roadrunner G80"; the quotes keep the space. A name is refused this
way even when only one of its motors has a curve file, so it never flies a maker you didn’t name.
Within one maker, a designation wins over another motor’s common name: D5 is Quest’s D5, not its
D5-P. hpr motors list --json gives each motor’s name that finds it alone as selector, and the
JSON of a flight names the motor and the curve file it flew by ThrustCurve.org’s ids (motor_id
and simfile_id). Python’s and Rust’s from_catalog follow the same rule.
A name that fits another motor’s mount
A designation outranks a common name, but not when the common name’s motor fits the mount
better. Cesaroni’s J360 is a 38 mm (1.5 in) motor, and J360 is also the common name of its
54 mm (2.1 in) 1016J360-15A. In a 54 mm (2.1 in) mount, J360 could mean either, so hpr sim --motor refuses it and
lists both, each with its diameter. For a design whose mount has a 54.0 mm (2.13 in) bore:
$ hpr sim rocket.ork --motor J360
error: J360: in a mount of 54.0 mm bore, `J360` matches several motors: J360 (38 mm), 1016J360-15A (54 mm)
help: give `--motor 1016J360-15A` for the closest fit; a narrower one of them, flown in an adapter, can be given only by its .eng or .rse file, by its path
The help offers only names that fly in that mount and aren’t refused in turn. No catalog name
picks the 38 mm (1.5 in) J360 alone in a 54 mm (2.1 in) mount, so for one flown in an adapter,
give its .eng or .rse file, as ThrustCurve.org offers it.
The rule follows the one a .ork file’s motor is read by, in
ADR-302
§1 on looking a motor up by name, but it measures the motor against the mount’s bore rather
than against the case the file draws. --motor looks at every motor sharing the name. It refuses
the name if one of them fits the bore closer than the motor the name gives, by more than 1 mm
(0.039 in) of room, or fits where the named motor doesn’t. Here a motor fits when it is at most
1 mm (0.039 in) wider than the bore. That other motor must fly in the bore
by the design checks’ rule, which allows a nominal 18, 24 or 29 mm case a fraction of a millimeter
over the bore and other sizes none. In a 38 mm (1.5 in) mount the same J360 names the 38 mm
(1.5 in) motor alone, as the 54 mm (2.1 in) one doesn’t fit.
A motor named with --motor more than 5% narrower than the bore, such as a 38 mm (1.5 in) motor
in a 54 mm (2.1 in) mount, flies centered with no adapter. A note says so. The adapter’s mass is
left out: it would move the apogee, up or down, and for an adapter aft of the center of gravity
the margin reads high without it. 5% is more than the 1.6% a 3.00 in (76.2 mm) bore leaves a
75 mm case. It is less than the 17% between 24 mm (0.94 in) and 29 mm (1.14 in), the smallest
step between these sizes, in millimeters: 13, 18, 24, 29, 38, 54, 75 and 98. A motor the design
file holds gets no such note.
A motor’s figures
hpr motors show takes a motor’s name or a file’s path. A name can be the full
designation (1266J760-19A) or the common name (J760), in any
case, with or without spaces and hyphens. When several motors share a name, it shows each of them
(hpr sim --motor refuses such a name instead).
An argument ending in .eng or .rse is read as a file. Anything else is looked up by name.
It works each figure out from the thrust curve, the list of time and thrust points in the motor’s file:
- The total impulse is the area under the curve, with its points joined by straight lines. It sets the impulse class.
- The burn time is measured the NFPA 1125 way. It runs from when the thrust first reaches 5% of its peak to when it last falls back to it.
- The average thrust is the total impulse divided by that burn time.
- The masses and the casing size are the catalog’s, or the file’s for a file, with ounces or pounds and inches in parentheses.
- The impulse class comes with its range of total impulse, written as NFPA 1125 and NFPA 1127 write it. Each class runs from just above the one below’s top to twice it, such as J (640.01–1,280 N·s), the lower end exclusive. Classes past O, beyond the standards’ table, carry on the doubling.
- The designation is read for what it names, as the maker writes it.
H170Mis class H, a nominal average thrust of 170 N, and propellant M. - Where the measured average thrust, rounded to a whole newton, differs from the nominal one, both are shown.
- The letters joined to the thrust are the maker’s code for the propellant. For a catalog motor,
the propellant’s name is the one ThrustCurve.org gives. A file names no propellant, so for a
file the code is shown alone. Estes’s and Quest’s joined letters aren’t a propellant, so none
is read for them. The
TofA10Tmarks the 13 mm case of a mini motor. - Letters after a hyphen aren’t read as the propellant. The same place holds a delay for one
maker (AeroTech’s
J350W-L) and a propellant for another (Loki’sH125-CT). The exception is the form Cesaroni’s own files write,131-G84-GR-10A. Even there, a single delay letter, as in131-G84-P(plugged), isn’t read.
For a catalog motor, the last lines give each curve file: its format, who measured it, its license,
and its 1% check with each figure’s gap. (flown) marks the
one the motor flies. hpr motors list gives its figures, as a
test
checks.
$ hpr motors show J760
1266J760-19A (Cesaroni Technology), from the bundled catalog
impulse class J (640.01–1280 N·s)
total impulse 1267.3 N·s
average thrust 758.2 N measured; 760 N nominal, as the designation names it
peak thrust 938.6 N
burn time 1.67 s, from 0.001 s to 1.672 s (NFPA 1125, 5% of peak)
propellant White Thunder, as ThrustCurve.org names it
propellant mass 576.0 g (1.27 lb) of 1076.8 g (2.37 lb) loaded
casing 54 mm (2.13 in) across, 329 mm (13.0 in) long
delays 8 s, 10 s, 12 s, 14 s, 16 s, 18 s, 19 s
curve file https://www.thrustcurve.org/simfiles/5f4294d20002e9000000074a/ (flown)
RASP (.eng), from a certification test, public domain
passes the 1% check: total impulse +0.13%, average thrust +0.07%, burn time +0.08%
curve file https://www.thrustcurve.org/simfiles/5f4294d20002e9000000074b/
RockSim (.rse), from a certification test, public domain
passes the 1% check: total impulse +0.13%, average thrust +0.07%, burn time +0.08%
How far to trust it. Copied from ThrustCurve.org's curve file, downloaded 2026-10-28, not measured
by HPR Sim: the size, masses and delays from the file's header, the impulse, thrusts and burn time
from its curve, which can differ from the maker's rated figures. Each file is checked against
ThrustCurve.org's figures and OpenRocket's reading of its impulse and peak thrust, not against the
maker's data: checks of the file, not of the motor. The motor's printed data and its maker's
instructions come first, and the RSO decides.
More: https://hpr.fusionspace.co/pick-a-motor.html
A motor file shows every motor in it, as one .eng or .rse file can hold several. The
repository holds the catalog’s curve files to try, such as:
hpr motors show crates/hpr-motor/data/thrustcurve/curves/5f4294d20002e90000000724.eng
Some motor data is ambiguous. A delay of 0 can mean an ejection charge at burnout, or a plugged
motor with no charge. The simulator shows it as “0 (at burnout, or plugged)” and ends the output
with a warning. The Estes F15 in the catalog is one example. The warning’s “RASP spec” is the
.eng format’s description (RASP and RockSim files).
A motor file’s delays aren’t flown, so you choose one:
- With no
--delay,hpr sim --motorfires no motor charge, as if the motor were plugged. - With
--delay 0, it fires the charge at burnout.
Motors you can buy
hpr motors search lists the motors that U.S. vendors carry, with who has each one in stock and
at what price. The list comes from motor.fusionspace.co, a free
site that reads a dozen vendors’ public listings every hour. It covers AeroTech, Cesaroni and Loki
motors of class D and up. Motor stock and prices says what it publishes and how
the simulator reads it. Five filters narrow the list, and each one given must match:
--in-stockkeeps the motors at least one vendor has in stock.--classtakes an impulse class, such asL.--diametertakes a diameter in millimeters, such as54, and matches within 0.5 mm (0.020 in).--manufacturertakesAeroTech,CesaroniorLoki, or the full name the site uses (Cesaroni Technology,Loki Research), in any case.--max-pricetakes U.S. dollars, such as150or149.99. It keeps the motors in stock whose price for one motor, at the cheapest vendor with it in stock, is at most that. A motor sold in a pack counts at the pack’s price divided by its size. The site works that out, to the cent (What the site publishes).--max-pricenever keeps a motor with no such price. A motor out of stock has none. Nor does one whose cheapest vendor shows no price, or prices it in another currency than U.S. dollars. Every vendor’s price was in dollars on the recording.
The motors come cheapest first, by that price. Those with no such price, including every motor out of stock, come last, by maker and designation.
A filter that can’t match anything real is refused with status 1, as hpr motors list refuses
one. That’s a class that doesn’t exist, a maker the site doesn’t cover, or a price that isn’t
dollars and cents. A list with nothing in it exits with 0. When --max-price leaves nothing, the
last line names the cheapest motor in stock that the other filters keep, and its price. So you
know what one costs.
The list is fetched and saved as hpr weather’s answers are
(Online, offline, and saved answers). The first search
fetches it over HTTPS and keeps a copy in the simulator’s cache folder. A search within the hour
reads the copy, and --offline reads the copy however old it is. --from FILE reads a list
saved earlier, the site’s motors.json or in-stock.json. It touches neither the network nor
the cache.
--in-stock and --max-price keep only motors in stock, so with either the simulator fetches
the site’s list of motors in stock (about 1 MB). Otherwise it fetches the whole list (about
1.6 MB). The two are saved separately. Offline, a search of motors in stock reads the whole
list’s copy when it has no copy of the in-stock one. A search of every motor needs the whole
list’s copy.
Every list, even an empty one, carries two credit lines under its first two lines. The first is the site’s, “Motor stock data from motor.fusionspace.co”, which its data license (CC BY 4.0) asks for. It comes with the site’s caution to check stock and price on the vendor’s own page before relying on them.
The second is ThrustCurve.org’s, since the motors’ figures (impulse, average thrust, burn time)
are its published values. The site repeats them (Credit and terms).
The JSON output carries both in attribution. Keep them wherever you show the list.
This reads the list of motors in stock that the tests use, recorded at 07:07 UTC on 1 October 2026. It keeps the L motors in stock at up to $300 each:
$ hpr motors search --in-stock --class L --max-price 300 --from crates/hpr-net/tests/fixtures/replay/motor-finder-in-stock.json
4 motors (in stock, class L, at most $300.00 each) in motor.fusionspace.co's list built 2026-10-01T07:07:29Z.
Read from motor-finder-in-stock.json
Motor stock data from motor.fusionspace.co, licensed CC BY 4.0 (https://creativecommons.org/licenses/by/4.0/). It is aggregated from public vendor listings and ThrustCurve.org, provided as is, with no warranty. Check stock and price on the vendor's own page before relying on them
Motor data and thrust curves courtesy of ThrustCurve.org, https://www.thrustcurve.org/
designation maker class dia mm (in) impulse N·s avg N burn s each $ pack vendor
L1520T AeroTech L 75 (2.95) 3715.9 1567.8 2.36 260.99 1 Balsa Machining Service
L850W AeroTech L 75 (2.95) 3646.2 850.0 4.42 282.74 1 Sirius Rocketry
3419L645-P Cesaroni L 75 (2.95) 3419.8 644.8 5.30 286.36 1 Performance Hobbies
3683L851-P Cesaroni L 75 (2.95) 3683.2 849.1 4.34 290.39 1 Animal Motor Works
each $ is the price of one motor and pack how many come in the pack, both at the vendor named
last. A motor out of stock shows - for both and out of stock for the vendor. A vendor that
shows no price gives - under each $. A price in another currency names it, such as
282.74 CAD. The full product page is in the JSON output (cheapest_in_stock.url). At $150,
the same recording lists nothing:
$ hpr motors search --in-stock --class L --max-price 150 --from crates/hpr-net/tests/fixtures/replay/motor-finder-in-stock.json
0 motors (in stock, class L, at most $150.00 each) in motor.fusionspace.co's list built 2026-10-01T07:07:29Z.
Read from motor-finder-in-stock.json
Motor stock data from motor.fusionspace.co, licensed CC BY 4.0 (https://creativecommons.org/licenses/by/4.0/). It is aggregated from public vendor listings and ThrustCurve.org, provided as is, with no warranty. Check stock and price on the vendor's own page before relying on them
Motor data and thrust curves courtesy of ThrustCurve.org, https://www.thrustcurve.org/
None costs $150.00 or less: of the 20 motors in stock the other filters pass, the cheapest is AeroTech L1520T at $260.99.
The tests in
crates/hpr-cli/tests/motors_search.rs
run hpr motors search offline on the recorded lists, from the file and from the cache. They check every motor
it lists, and their order, against the recording’s own JSON, filtered by the test itself, not by
the simulator’s code. With one L motor’s price edited to $149.99 in a copy, the
--max-price 150 search lists exactly that motor.
Motors from ThrustCurve.org
hpr motors fetch NAME finds a motor on ThrustCurve.org and keeps
its curve in the simulator’s cache (Where the cache lives).
hpr sim then flies it with no network. It’s for a motor the bundled catalog lacks; hpr sim
fetches on its own too, so it matters most before a trip with no signal. This
is ThrustCurve’s data, as its contributors uploaded it. The simulator checks that a file makes a
motor it can fly, not that its curve is right.
-
Before a trip. For a
.orkmotor the catalog lacks, run the commandhpr sim --offlineprints for it, which names the file’s manufacturer (hpr motors fetch --manufacturer MAKER NAME), or fly the design once online; either fills its cache. Without--manufacturer,hpr motors fetch NAMEfills the cache forhpr sim --motor NAMEinstead. -
Which motor.
NAMEis a designation (F27R/L) or common name (F27), as ThrustCurve.org spells it.--manufactureradds the maker, by name or abbreviation. ThrustCurve matches a designation exactly, any case. If no motor has it, the simulator asks for the common name. Exactly one motor must answer:J450names four makers’ motors, and the refusal lists them, so give the designation or--manufacturer. A hybrid is refused, as the simulator flies solid motors only. -
Which curve. A motor can have several curve files. The simulator takes the first RASP (
.eng) file that makes a motor it flies, ranked by who measured it. A certification test comes first, then the manufacturer, then a user, then a file that names no source. With none, it takes a RockSim (.rse) file the same way. A file over 5% short of the record’s propellant mass draws awarning:(why).--file IDtakes the file with that id, fromhpr motors fetch’scurve fileline, first, when the motor has it and it reads. An offline refusal’s command names it when the flight asks for a file. The output names the file, who measured it and its license, as ThrustCurve states them, and ThrustCurve’s credit. -
OpenRocket’s curve for a
.orkmotor. ThrustCurve can hold several files of one motor with different curves. OpenRocket may fly another than the first by that order. The Estes A8’s first certification file burns 0.536 s, and the one OpenRocket’s examples fly burns 0.73 s.A
.orkrecords which curve OpenRocket flies by a digest, a fingerprint of the curve. For the motors of OpenRocket’s example designs,hpr simkeeps a table from digest to the ThrustCurve file with that curve, matched by comparing curves (cargo xtask ork-curves, as of October 4, 2026, rerun when ThrustCurve’s files change). It takes that file first, and the motor’s note says so. The table also holds the two motors of the public flights predicted from a design file, matched against the bundled files on November 10, 2026. Other digests aren’t in it yet (issue #1412).Another motor flies the file by the order above, and its note says it may not be OpenRocket’s curve. An offline refusal’s command then carries
--file. Offline, a file the cache lacks is given up for the usual order’s, with the same note. -
Offline.
--offline, orHPR_OFFLINE=1, reads the cache alone, a copy of any age; with none, it fails with exit status 1. Online, a copy a day old is fetched again, and kept if the network fails.
Printed online on October 4, 2026, pasted by hand (not run in CI) and edited to today’s format:
$ hpr motors fetch F27R/L
F27R/L (AeroTech), from ThrustCurve.org: fetched now
curve file 5f4294d20002e90000000372, RASP (.eng), from a user, no license stated
case 29 × 83 mm (1.14 × 3.3 in)
help: the bundled catalog has F27R/L too, and `hpr sim --motor` flies the catalog's curve
Motor data and thrust curves courtesy of ThrustCurve.org, https://www.thrustcurve.org/
Offline with nothing cached, it says what to run:
$ hpr motors fetch H128W --offline
error: H128W is not in HPR Sim's cache of ThrustCurve.org, and the run is offline
help: with a network connection, `hpr motors fetch H128W` fetches it into the cache
$ echo $?
1
The curves hpr motors fetch downloads aren’t bundled. The simulator ships ThrustCurve.org’s
solid catalog as of October 28, 2026
(the decision record on bundling it).
The decision record on fetching motors
has the reasoning for the fetch. Each file carries its contributor’s own license.
ThrustCurve.org grants no license for its motor records; the project uses them as published facts,
with credit (the decision record on ThrustCurve.org’s records).
Newer motors and the bundle’s date
hpr motors update says what the bundled catalog holds: the date of its ThrustCurve.org
snapshot, its motors and files, how many files pass the 1% check
against their motor’s record (and how many motors have at least one such file), and the bytes
compiled in.
ThrustCurve.org listed no motor newer than the bundle on October 29, 2026
(the decision record on the update),
so the online path below is tested only on its recorded answers of that day, with one motor and one file
taken out of the bundle; it hasn’t yet found a real new one.
Online, it asks ThrustCurve.org for its whole solid catalog, or reads an answer under a day old from the cache. It downloads a motor’s files only if the bundle lacks the motor, ThrustCurve.org lists a different number of files for it, or its record was updated on or after the snapshot’s date. Each motor or RASP or RockSim file the bundle lacks is fetched into the cache, and the commands that find it there are printed:
- A new motor is read offline by name,
hpr motors fetch NAME, andhpr sim DESIGN --motor NAMEflies it, DESIGN being your design file. If the bundle has a motor by that name,hpr sim --motorlooks there first and never reads the cache, so nohpr simline is printed; that case, and a name several makers share, give the maker:hpr motors fetch --manufacturer MAKER NAME. - A newer file of a bundled motor is only cached:
hpr sim --motorkeeps flying the bundled file, andhpr motors fetch --file IDshows the new one. - A fetched curve is a contributor’s upload, as in fetching a motor. The simulator checks that it makes a motor it can fly, but neither the 1% check nor the comparison with ThrustCurve.org’s statistics code covers it.
A file swapped for another under the same motor, with the file count and date unchanged, isn’t
found. --json prints the same as one document. Online with the network down, it reads the
answers an earlier update cached, or fails with help naming the bundle’s date if one is missing.
With --offline it never asks the network: it reads what an earlier update cached, or with any
answer missing names the bundle’s date and succeeds:
$ hpr motors update --offline
The bundled catalog: ThrustCurve.org's solid motors as of 2026-10-28
motors 1004, 924 with a file that reads
files 1701, and 5 left out
passing 412 files within 1% of their records, of 239 motors
size 4.2 MB (4196056 bytes)
note: offline, with no whole update cached; online, `hpr motors update` looks for motors and files newer than 2026-10-28
Motor data and thrust curves courtesy of ThrustCurve.org, https://www.thrustcurve.org/
hpr convert
hpr convert writes a motor as a RASP .eng file or a RockSim .rse file, the two formats
ThrustCurve.org offers (RASP and RockSim files). It writes a
design as a .ork, .hpr or .hprz file (converting a design). Give it the
file to read and the file to write. The extensions pick the formats. It reads a motor file, or a
motor of the bundled catalog by its name:
hpr convert H170M H170M.eng
A catalog motor is written with the size and masses the catalog gives, the ones the simulator
flies. Where its curve file’s header says otherwise, a warning says so. Written as .rse, the
figures worked out from them are rescaled to match, and a warning says that too. Those are the mass
fraction, the specific impulse, and the mass and center of gravity at each point. The delays are
the curve file’s, which can differ from the ones hpr motors show lists.
After the line naming the program, the file says where the curve came from. The line is “Copied
from the bundled motor catalog as of” the catalog’s date, written YYYY-MM-DD, “the day its curve
files were downloaded”. It’s a ; comment in .eng and an XML comment in .rse. A motor read
from a file gets no such line.
Converted again, a .eng file keeps the line as one of its comments. A .rse file’s reader skips
XML comments, so it isn’t carried on. An existing file of the output’s name is replaced, but never
the file being read. To rewrite a .eng file in the simulator’s layout, convert it to a new .eng
file name. Here the Estes F15’s .rse file, from the catalog’s curves, becomes a .eng file:
$ hpr convert crates/hpr-motor/data/thrustcurve/curves/5f923edb1bca5800041716ab.rse F15.eng
read 5f923edb1bca5800041716ab.rse
wrote F15.eng: F15
warning: line 3: engine "F15": delay 0 in "0,4,6,8" is ambiguous: the RASP spec means an ejection charge at burnout, but files mostly mean plugged. A motor file's delays aren't flown: with none chosen, no motor charge fires, as if plugged. For a charge at burnout, choose a delay of 0 (`hpr sim --delay 0`, or `delay_s=0` in Python)
warning: F15: a .eng maker is one word, so "Estes Industries, Inc." is written "Estes_Industries,_Inc."
warning: F15: the comments' blank lines and the spaces that end their lines were left out: a .eng comment is one line of text
warning: F15: Type, auto-calc-mass, auto-calc-cg, avgThrust, peakThrust, throatDia, exitDia, Itot, burn-time, massFrac, Isp, m, cg were left out: a .eng file has no place for them, and no number HPR Sim works out depends on them. HPR Sim works a motor's mass and center of gravity out from its curve and masses itself
What a conversion keeps
Both formats give a motor’s name, maker, diameter and length, its loaded and propellant masses, its
delays, and its thrust curve. The curve, the size and the masses are
kept. Converting a file and converting the result back gives each of them again, bit for bit, as
the simulator reads the file. A mass of 16 or 17 digits is the exception (below). The formats write
some things differently, and hpr convert translates:
.eng | .rse | |
|---|---|---|
| masses | kilograms | grams |
| delays | 6-10-14 | 6,10,14 |
| a plugged motor’s delay | P | 1000 |
| the curve’s first point, zero thrust at ignition | left out | written |
| a name or maker of several words | joined by _ | as it is |
Masses move between kilograms and grams by moving the decimal point, not by multiplying, which
would round. In a computer’s arithmetic, 0.0041 kg times 1,000 is 4.1000000000000005, while
moving the point gives 4.1. A mass written with 16 or 17 digits may still change in its last
digit. A warning says so. Of the 32 first bundled files, two masses written with 17 digits are the only
ones that don’t come back bit for bit; each carries the warning
(test).
A flight turns a .rse file’s grams into kilograms by dividing by 1,000, and the catalog’s by
multiplying by 0.001. So the same motor flown from a .eng file and from its converted .rse can
differ in a mass’s last digit, a part in .
Some things come back written differently, though they mean the same:
- Delays spelled
p,1000or with spaces come back in the table’s spelling. The simulator reads them as the same delays. - A name or maker of several words comes back with
_between the words, in any.engfilehpr convertwrites. A.engheader is seven fields split by spaces, and OpenRocket 24.12 refuses one of eight (the script checks it). A warning says so. - A
.engmotor whose delays are-, which names none, is written to.rsewithout delays, so converting it back to.engneeds--delays. - Comments lose their blank lines and the spaces ending their lines, and comments after a
.engfile’s last motor are dropped. A warning says so.
A .rse file also gives figures a .eng file has no place for. They’re the motor’s type, its
total impulse, average and peak thrust, burn time, mass fraction,
specific impulse, and nozzle throat and exit diameters. Two flags
say whether RockSim works the mass and center of gravity out itself. The file gives both figures
at each point of the curve. The simulator doesn’t use them for a solid motor. It works the mass and
center of gravity out from the curve and the masses, whichever format it reads.
Going to .eng, they’re dropped, and a warning names them. Going to .rse, they’re filled in the
way ThrustCurve.org’s .rse files are. The total impulse comes from adding up the curve, and the
remaining propellant falls in step with the impulse delivered. The center of gravity is at half the
length, both flags are set, and the type is unspecified. The rules, and the counts of real files
behind them, are in the .rse format notes.
hpr convert refuses to write a hybrid motor as .eng, which couldn’t mark it as a hybrid (the
simulator models solid motors only). A .eng header must give delays. So a .rse motor without
them is refused until --delays gives them, such as --delays P for a plugged motor. --delays
fills only the motors that give none.
Other programs. OpenRocket 24.12 opens all 32 files hpr convert writes from the curves
first bundled; the rest of the catalog’s files aren’t tried yet
(issue #1002). A script compares what OpenRocket reads from each converted file with what it
reads from the original. It compares the name, the maker as OpenRocket names it, the type, and
the diameter and length. It also compares the launch and burnout masses, the curve’s points and
the delays. 29 of the 32 read the same.
- Two are
.rsefiles that say the motor is reloadable or single-use. A.engfile can’t say it, so OpenRocket reads the converted files’ type as unknown. HPR Sim flies both types alike. - The third is the Aerotech G69N’s
.engfile, which writes its plugged delay as1000. OpenRocket reads no delay from that original, but a plugged motor from the converted.rse. HPR Sim reads both as plugged, so the difference is in OpenRocket’s reading of the original, not in whathpr convertwrote.
The project’s automated tests don’t run the script, as they have no OpenRocket.
Converting a design
Given design files, hpr convert takes a design between OpenRocket’s .ork and
the HPR design format. That format is .hpr, one JSON document, or .hprz, a zip
archive of the document with other files beside it. The extensions pick the formats, any of the
three to any.
Here one of the repository’s public designs becomes a .hpr:
$ hpr convert validation/fixtures/ork/loft-demo/demo-multi-config.ork demo.hpr
read demo-multi-config.ork
wrote demo.hpr: "Loft Demo 38mm — motor comparison", 2 motor configurations, HPR design format 0.2
warning: openrocket/rocket/stage[0]/bodytube[1]/innertube[2]: H128W's curve file 5f4294d20002e9000000000d is more than 1% from ThrustCurve.org's figures for it: total impulse +2.82%, average thrust +19.49%, burn time -8.48%
warning: openrocket/rocket/stage[0]/bodytube[1]/innertube[2]: G40W's curve file 5f4294d20002e90000000463 is more than 1% from ThrustCurve.org's figures for it: total impulse +1.94%, average thrust +13.72%, burn time -10.50%
The document holds everything the simulator read from the .ork, including what it doesn’t model.
So hpr convert demo.hpr demo.ork writes the .ork the simulator would write from the original,
byte for byte. hpr sim demo.hpr flies it to the same flight as the .ork. A document of
an older version of the format is migrated as it’s read, and the output says from which version.
hpr sim may refuse --motor for a version 0.1 document, which didn’t record whether the rocket
was read exactly as written. Converting the .ork again fixes that
(versions).
--attach adds a file to a .hprz, once for each file: a flight log, a photograph, anything, up
to 256 MiB for the whole container. Each goes at the top of the container, under its file name. A
name the container can’t hold, such as CON.txt, is refused
(the container’s name rules). Converting a .hprz to a .hprz
keeps its attachments, and adds any --attach names. Converting one to a .hpr or a .ork leaves
its attachments out, and a warning names each.
With --json, the output
(convert.schema.json)
gives:
- the files read and written, with their formats;
- the rocket’s name, and how many motor configurations the design holds;
- the version of the format the input was migrated from, if it was;
- the attachments written into a
.hprz; - the warnings: the
.orkreader’s, the.orkwriter’s, and each attachment left out.
Logs and weather
hpr analyze reads an altimeter’s flight log, hpr compare sets one against a simulation of it, and hpr weather writes the air and wind over a launch site.
hpr compare
hpr compare sets a flight log against a simulation of that flight. It takes the log, then the design, its
motor and the launch as hpr sim takes them. It prints how far the logged height and speed lie from
the simulated, phase by phase, and each reading beside the simulation’s. --json adds every sample’s residual.
A log from another logger is read by --mapping or --layout, as hpr analyze reads it.
Comparing a flight with its simulation says how to read the result.
hpr compare flight.pf2 rocket.ork --motor CTI-J350 --wind 4
hpr analyze
hpr analyze reads the log an altimeter recorded during a flight. It prints what the log says:
when the rocket lifted off, how high it went, how fast it climbed, and when it landed. It needs
only the log. It takes no design file and runs no simulation. So it answers “what did my rocket
do?” for anyone who flew one, whatever they designed it in. Each reading comes with a bound and,
where it can, a 90% interval, and the last rows are the smoother’s apogee and health card
(what they mean).
It reads each layout HPR Sim knows by that layout’s own reader. Another logger’s file is read by a
JSON file you write for it (Reading your own logger works one through). A
table is read by a column mapping, --mapping. Binary records, or a serial console’s capture of
them, are read by a record layout, --layout. The readers cover these
(the layouts read):
- PerfectFlite’s
.pf2logs, the Pnut’s, the StratoLogger’s and the StratoLoggerCF’s (the format) - AltOS’s CSV
- the Featherweight Raven’s FIP CSV
- the Blue Raven’s, the RRC3’s and Eggtimer’s CSV
- an Eggtimer TRS’s terminal text
- PerfectFlite’s exports and older
.pfa - AltimeterCloud’s and Entacore AIM’s CSV
- AerospaceNU’s SillyGoose logs and its flight computer board’s CSV and ground station text
- Silicdyne Fluctus’s CSV
- the ARTS2’s interpreted data
- a phone app’s
launchCSV - an Eggtimer’s download saved as RTF
- the Raven’s
.FIPaand the RRC3’s.rffraw downloads - the Featherweight app’s flight summaries
- the R-DAS’s raw text
- AltOS’s radio telemetry and its
.eepromraw downloads - the ARTS2’s
.odfand raw CSV - Missile Works’ RTx tracker’s
.rtxfile and exports - tables whose headers state their units
- the sheets of an Excel workbook
- binary records by a layout the caller states
- a Blue Raven’s USB download
- a course’s Teensy data logger
- one team’s radio telemetry packets
- a Raven FIP export pasted below no header
- an AltiMAX’s
.xlsexport - an AltiMAX’s
.ALSfile - Entacore AIM’s
.xtrafiles and raw dumps - a MARSA altimeter’s download
- AltOS’s radio telemetry decoded to a table
- AltOS’s CSV re-saved by a spreadsheet or cut to its columns
- tables whose headers state too little, by a column mapping
- GPS tracks
A workbook’s sheets and a raw dump’s recordings are read one at a time (A file of several records). A zip archive is refused. Unpack it and give the log inside. Formats no sample holds are listed as needing samples (evidence row G9).
hpr analyze takes its readings from any log’s barometric altitude or pressure, whichever logger
wrote it (readings on every logger). It states a bound on each.
A GPS track gives none: a receiver’s height lags and drops out too much to bound
(the height track).
Near the speed of sound a barometer reads the air wrongly. So the top speed is withheld as
transonic once the climb reaches 227.7 m/s (747 ft/s). That’s Mach 0.8 in the coldest air the
bounds allow below 20 km (12 mi).
hpr analyze flight.pf2
Each reading is a value that says where it came from and how far it may be off. One the log can’t
support is withheld, with the reason. The text output gives the reason as a sentence. The JSON
output adds its code, listed on
Flight-log readings. A log read with
readings withheld still exits with 0; a file the simulator can’t read exits with 1
(Exit codes).
The rest of the readings are the flight time, the descent under
each canopy with the main’s opening, and the top acceleration and burnout. The top
acceleration comes only from an accelerometer along the rocket’s axis, printed in m/s² and g.
Working it out from the altitude would turn the altitude’s one-foot steps into spikes of many g.
It’s what the part reads, the specific force, with gravity’s 1 g in,
where hpr sim’s max_acceleration_m_s2 is the rocket’s own acceleration. A PerfectFlite has
none, so it’s withheld as no_accelerometer.
Burnout is then printed as no sooner than the top speed’s time less its bound. That’s a floor: the true burnout comes no earlier and may come later by any amount (Flight-log readings).
A top acceleration can be a floor too. Where the part clipped and the top reached the range the logger’s family states, its line says “clipped at the part’s range of …”. Where it held flat below that range, or none is stated, the line says “held flat at its top, so it may have been clipped”. Where the accelerometer holds the thrust only in part, with no start or no end to it, the line says that.
The JSON marks each is_floor, and gives the clip’s cause in clip, range or flat. clip is
null for a top that didn’t clip and for a thrust with no end.
A log that ends on the climb says so on its top speed and smoothed apogee as well as its apogee: “so
the rocket may have gone faster”, “gone higher”. None of the three states an interval or a lower end. The JSON has
max_speed.is_floor and smoother.apogee_is_floor.
What the file states about itself, such as the altimeter’s own apogee, is printed beside the simulator’s readings, never in their place. Heights are meters above the altimeter’s reading on the pad, with feet in brackets. Times are seconds on the log’s clock.
This example log is invented, so every reading can be checked against the flight it was made from (Reading a flight log works through it). Its true apogee is 390.3 m (1,280.5 ft), at 10.26 s:
$ hpr analyze validation/fixtures/logs/synthetic-pnut.pf2
synthetic-pnut.pf2: PerfectFlite Pnut, serial 0, flight 1
984 samples, from 0.00 s to 49.15 s
readings from the logger's barometric altitude, sampled every 0.050 s in steps of 0.305 m, after a 0.30 s running median
4 channels: Altitude (altitude above ground), Velocity (speed), Temperature (F) (temperature), Voltage (voltage)
the logger states: apogee 390.4 m (1281 ft); ground elevation 182.9 m (600 ft) above sea level
liftoff 0.80 s, within 0.81 s, 90% interval 0.41 to 0.64 s
apogee 390.1 m (1280 ft) above the pad, within 31.9 m (105 ft), 90% interval 369.8 to 410.3 m (1213 to 1346 ft); at 10.28 s, within 0.88 s, 90% interval 10.07 to 10.57 s, 9.47 s after liftoff
highest sample 400.5 m (1314 ft) above the pad at 11.35 s, set aside by the median
top speed 78.3 m/s (257 ft/s), within 20.6 m/s (68 ft/s), 90% interval 72.8 to 82.8 m/s (239 to 272 ft/s), at 2.20 s, 71.9 m (236 ft) up: derived from the heights
landing 45.80 s, within 2.11 s, 90% interval 45.47 to 46.51 s; 35.52 s from apogee, at 10.9 m/s (36 ft/s) on average, within 2.1 m/s (7 ft/s), 90% interval 9.8 to 12.0 m/s (32 to 40 ft/s)
flight time 45.00 s, within 2.91 s, 90% interval 45.38 to 46.11 s
drogue descent 21.7 m/s (71 ft/s), within 2.2 m/s (8 ft/s), 90% interval 20.3 to 23.1 m/s (66 to 76 ft/s), from apogee at 10.28 s to the main's opening at 21.40 s, 390.1 m (1280 ft) to 148.4 m (487 ft) up; the mean rate from apogee: height lost over time taken, so the fall from rest there is included
main descent 6.0 m/s (20 ft/s), within 0.8 m/s (3 ft/s), 90% interval 5.5 to 6.5 m/s (18 to 22 ft/s), from the main's opening at 21.40 s, within 1.06 s, 90% interval 20.79 to 21.26 s, to landing at 45.80 s, 148.4 m (487 ft) to 2.1 m (7 ft) up
top acceleration withheld: the log has no accelerometer; HPR Sim doesn't difference a height twice to make one, as its steps would read as spikes of many g
burnout no sooner than 0.88 s: the top speed's time, 2.20 s (1.40 s after liftoff), less its bound, 1.32 s. Derived from the heights, burnout may have come later by any amount; 95% lower end 2.24 s
smoothed apogee 390.3 m (1280 ft), 90% interval 369.9 to 410.7 m (1213 to 1348 ft), at 10.25 s
health card pad assumed: too little of it in the log; heights on the readings' zero, noise from the flight's scatter
barometer: 984 samples, 981 fused, 1 rejected, 2 not weighed, 0 resets; 99.8% inside the gate; mean NIS 0.0252; largest test ratio 4.95 at 11.2 s, Mach 0.03
barometer de-weighted: charge 11.3–11.9 s
pass back: every step smoothed
How far to trust it. Measured by the logger, read by HPR Sim from its log, not simulated. Each
reading states the bound its error stayed within on HPR Sim's synthetic flights. They cover rates
from 500 to 0.5 samples a second, steps up to 10 m or 100 Pa, and air within 15 K of standard. A
reading the log can't support is withheld, with the reason. The top speed is derived from the
heights, and withheld from Mach 0.8, where a barometer's port may read the flow over the nose. For a
record or a certification, the altimeter's own reading is the one to log, and the RSO decides.
More: https://hpr.fusionspace.co/reading-a-flight-log.html
The highest sample in the file is 10.4 m (34 ft) above the apogee. It’s the pressure pulse of the ejection charge that fired a second after it. The readings are taken from the altitude after a running median, which sets that pulse aside. Reading a flight log explains each reading, and how far to trust it.
A log with an accelerometer
A log with an accelerometer along the rocket’s axis gives the top acceleration and burnout from
it. This invented log, written by the make.py beside it, is of a 2 kg rocket. Its motor pushes
120 N, a tenth more at its crest, from 2 s into the log, and stops at 3.45 s. Its accelerometer
writes, in g, what the part reads, gravity in.
A table of columns doesn’t name its logger, so the first line says unknown. With no primary
track, the heights come from its altitude column and the accelerometer is read on its own clock:
$ hpr analyze validation/fixtures/logs/accelerometer/axial.csv
axial.csv: unknown
no primary track: each channel on its own clock
readings from the barometric altitude channel, sampled every 0.010 s in steps of 0.010 m, after a 0.30 s running median
2 channels: Baro Alt AGL (m) (altitude above ground), Axial accel (g) (acceleration)
liftoff 2.30 s, within 0.67 s, 90% interval 1.98 to 2.17 s
apogee 272.3 m (893 ft) above the pad, within 22.8 m (75 ft), 90% interval 257.7 to 286.7 m (845 to 941 ft); at 9.91 s, within 0.80 s, 90% interval 9.72 to 10.17 s, 7.61 s after liftoff
top speed 68.9 m/s (226 ft/s), within 20.7 m/s (68 ft/s), 90% interval 63.4 to 73.5 m/s (208 to 241 ft/s), at 3.48 s, 55.9 m (183 ft) up: derived from the heights
landing 40.77 s, within 1.82 s, 90% interval 40.48 to 41.38 s; 30.87 s from apogee, at 8.8 m/s (29 ft/s) on average, within 1.8 m/s (6 ft/s), 90% interval 7.8 to 9.6 m/s (25 to 32 ft/s)
flight time 38.47 s, within 2.48 s, 90% interval 38.79 to 39.41 s
drogue descent 19.4 m/s (64 ft/s), within 2.4 m/s (8 ft/s), 90% interval 17.9 to 20.9 m/s (58 to 69 ft/s), from apogee at 9.91 s to the main's opening at 16.26 s, 272.3 m (893 ft) to 149.0 m (489 ft) up; the mean rate from apogee: height lost over time taken, so the fall from rest there is included
main descent 6.0 m/s (20 ft/s), within 0.7 m/s (3 ft/s), 90% interval 5.5 to 6.4 m/s (18 to 21 ft/s), from the main's opening at 16.26 s, within 0.98 s, 90% interval 15.70 to 16.13 s, to landing at 40.77 s, 149.0 m (489 ft) to 2.0 m (6 ft) up
top acceleration 65.4 m/s² (6.7 g), within 7.1 m/s², 90% interval 61.3 to 68.9 m/s², at 2.59 s
burnout 3.45 s, within 0.07 s, 90% interval 3.44 to 3.46 s, 1.15 s after liftoff: from the accelerometer
smoothed apogee 269.5 m (884 ft), 90% interval 255.4 to 283.6 m (838 to 931 ft), at 9.64 s
health card barometer: 4611 samples, 4611 fused, 0 rejected, 0 not weighed, 0 resets; 100.0% inside the gate; mean NIS 0.291; largest test ratio 0.483 at 11.4 s, Mach 0.01
accelerometer: 4611 samples, 1197 fused, 0 rejected, 3414 not weighed, 0 resets; 100.0% inside the gate; mean NIS 0.000752; largest test ratio 0.00576 at 2.02 s, Mach 0.00
barometer de-weighted: charge 8.97–10.7 s
barometer less accelerometer at apogee: -0.0431 m
pass back: every step smoothed
How far to trust it. Measured by the logger, read by HPR Sim from its log, not simulated. Each
reading states the bound its error stayed within on HPR Sim's synthetic flights. They cover rates
from 500 to 0.5 samples a second, steps up to 10 m or 100 Pa, and air within 15 K of standard. A
reading the log can't support is withheld, with the reason. The top speed is derived from the
heights, and withheld from Mach 0.8, where a barometer's port may read the flow over the nose. For a
record or a certification, the altimeter's own reading is the one to log, and the RSO decides.
More: https://hpr.fusionspace.co/reading-a-flight-log.html
The top acceleration, 6.7 g, is the specific force, gravity’s 1 g in. The rocket itself sped up at about 5.7 g. Burnout, 3.45 s within 0.07 s, is where the thrust’s fall ends, the end of the motor’s burn (Flight-log readings).
Liftoff is read at 2.30 s, within 0.67 s, later than the motor’s start. So burnout’s 1.15 s after liftoff is less than the motor’s 1.45 s burn. Its time on the log’s clock is the one to compare.
A file of several records
Some files hold more than one record. hpr analyze reads one of them at a time, by its own
reader. A spreadsheet’s workbook holds sheets: an .xlsx, or an .xls written as one bare
worksheet, as an AltiMAX altimeter’s Excel export is. Excel’s own .xls, a compound file of
several streams, isn’t read. An Entacore AIM raw dump can hold several recordings.
With no choice given, hpr analyze reads the workbook’s one sheet that reads as a log, or the dump’s one
recording. Where several sheets read, or none, or the dump holds several recordings, it refuses,
exit code 1, and names the choices:
--sheet Nreads the workbook’s sheetN, counted from 0, as its layout’s own reader reads it. The JSON output’slogobject gives it assheet.--recording Nreads the dump’s recordingN, counted from 0, given asrecording. It takes none of--mapping,--layout,--fip-headerand--sheet.
A sheet chosen for a dump, a recording chosen for a workbook, or either for a file of one record
is refused, saying why. A table on a sheet no reader takes is read by a column mapping and
--sheet (below).
The invented workbook two-flights.xlsx has three sheets, “First”, “Notes” and “Second”, and the
first and last read as logs. With no --sheet, hpr analyze refuses it: “2 of the
workbook’s 3 sheets read as logs, sheets 0 (First), 2 (Second): choose one”. --sheet 2 reads the
second flight, made to peak at 548.0 m (1,798 ft) above the pad, and a note names the sheet:
$ hpr analyze validation/fixtures/logs/several/two-flights.xlsx --sheet 2
two-flights.xlsx: unknown
no primary track: each channel on its own clock
readings from the barometric altitude channel, sampled every 0.200 s in steps of 0.020 m, after a 0.40 s running median
1 channel: Baro Alt AGL (m) (altitude above ground)
liftoff 1.20 s, within 1.05 s, 90% interval 0.69 to 0.99 s
apogee 547.8 m (1797 ft) above the pad, within 43.0 m (141 ft), 90% interval 520.3 to 574.9 m (1707 to 1887 ft); at 13.10 s, within 0.99 s, 90% interval 12.87 to 13.43 s, 11.90 s after liftoff
top speed withheld: the track's samples come every 0.200 s, too far apart for a 0.5 s fit of 5 samples. That fit needs them at most 0.125 s apart
landing withheld: the log ends at 40.00 s, 280.8 m above the pad. It ends before the altitude comes within 2.0 m of the pad and stays under 5.0 m for 1 s
flight time withheld: the flight time needs landing, which is withheld above
drogue descent withheld, as landing is
main descent withheld, as landing is
top acceleration withheld: the log has no accelerometer; HPR Sim doesn't difference a height twice to make one, as its steps would read as spikes of many g
burnout withheld: burnout from the speed's peak needs the top speed, which is withheld above
smoothed apogee 546.6 m (1793 ft), 90% interval 512.3 to 580.8 m (1680 to 1906 ft), at 13.00 s
health card pad assumed: too little of it in the log; heights on the readings' zero, noise from the flight's scatter
barometer: 201 samples, 199 fused, 0 rejected, 2 not weighed, 0 resets; 100.0% inside the gate; mean NIS 0.00810; largest test ratio 0.0120 at 15.6 s, Mach 0.06
barometer de-weighted: charge 12.2–14.0 s
pass back: every step smoothed
How far to trust it. Measured by the logger, read by HPR Sim from its log, not simulated. Each
reading states the bound its error stayed within on HPR Sim's synthetic flights. They cover rates
from 500 to 0.5 samples a second, steps up to 10 m or 100 Pa, and air within 15 K of standard. A
reading the log can't support is withheld, with the reason. The top speed is derived from the
heights, and withheld from Mach 0.8, where a barometer's port may read the flow over the nose. For a
record or a certification, the altimeter's own reading is the one to log, and the RSO decides.
More: https://hpr.fusionspace.co/reading-a-flight-log.html
note: read from the sheet "Second" of an Excel workbook, its cells as stored
Two logs of one flight
Give hpr analyze more than one log of a flight, each in a format it reads by itself, and it puts
them on one timeline and reads them side by side. Each altimeter counts from a zero of its own. The clocks are lined up by each log’s liftoff, the logs’ readings are never
averaged, and each reading’s spread says how far apart they lie, not which is right. A log with no
liftoff, such as a GPS track, says so and sits on no timeline
(#1086). A log read by --mapping or
another of the options that name one file can’t be one of them yet
(#1085). --stages says that the
logs are one logger to a stage, of a stack that left the pad together; it gives no spread, a
booster’s readings and a sustainer’s being of different bodies.
These two logs are invented, their clocks 53.5 s apart (Reading a flight
log has a real pair). “Within” is a bound: no
reading’s error passed it on the synthetic flights, and the clock offset’s came to 0.13 of it at
most. The 90% interval is where the truth lay nine times in ten, and it needn’t hold the reading:
liftoff is read late, so its interval lies earlier, and the flight time reads short, so its interval
lies later
(the 90% intervals). unknown is the
logger’s name, which these two tables don’t state. A staged flight’s logs take the same arguments
and --stages: hpr analyze sustainer.csv booster.csv --stages.
$ hpr analyze validation/fixtures/logs/two-logs/first-board.csv validation/fixtures/logs/two-logs/second-board.csv
2 logs of one flight on one timeline, by a shared liftoff: read side by side, never averaged
log 1 first-board.csv: unknown
readings from the barometric altitude channel
liftoff 41.20 s on its clock, within 0.76 s, 90% interval 40.83 to 41.05 s
log 2 second-board.csv: unknown
readings from the barometric altitude channel
liftoff -12.30 s on its clock, within 0.86 s, 90% interval -12.72 to -12.47 s
log 2's clock less log 1's: -53.50 s, within 1.61 s, 90% interval -53.59 to -53.41 s
apogee, above each log's own pad
log 1 989.8 m (3247 ft), within 74.6 m (245 ft), 90% interval 942.3 to 1036.9 m (3091 to 3402 ft)
log 2 1001.3 m (3285 ft), within 75.4 m (248 ft), 90% interval 953.2 to 1048.9 m (3127 to 3442 ft)
spread 11.5 m (38 ft)
apogee's time, after each log's liftoff
log 1 10.72 s, within 1.60 s
log 2 10.65 s, within 1.75 s
spread 0.07 s
smoothed apogee
log 1 988.8 m (3244 ft), 90% interval 936.9 to 1040.7 m (3074 to 3415 ft)
log 2 1000.8 m (3283 ft), 90% interval 948.3 to 1053.3 m (3111 to 3456 ft)
spread 12.0 m (39 ft)
top speed
log 1 176.4 m/s (579 ft/s), within 51.2 m/s (168 ft/s), 90% interval 162.8 to 187.6 m/s (534 to 616 ft/s)
log 2 177.6 m/s (583 ft/s), within 41.2 m/s (135 ft/s), 90% interval 166.7 to 186.6 m/s (546 to 613 ft/s)
spread 1.2 m/s (4 ft/s)
top acceleration
log 1 withheld: the log has no accelerometer; HPR Sim doesn't difference a height twice to make one, as its steps would read as spikes of many g
log 2 withheld: the log has no accelerometer; HPR Sim doesn't difference a height twice to make one, as its steps would read as spikes of many g
burnout, after each log's liftoff
log 1 1.90 s, within 2.08 s, a floor: the true value may lie any amount above it
log 2 2.00 s, within 2.23 s, a floor: the true value may lie any amount above it
flight time
log 1 61.70 s, within 1.37 s, 90% interval 61.87 to 62.22 s
log 2 61.70 s, within 1.56 s, 90% interval 61.90 to 62.29 s
spread 0.00 s
drogue descent
log 1 withheld: the descent shows no drogue's leg, which at the ground's density falls faster than 30.8 m/s up to the main's opening. That mark is 1.6 times the rate near the ground, 19.3 m/s, or 3 m/s more if that is more. A drogue's leg would also fall on median faster than 1.4 times the rate near the ground. So the rocket came down under one canopy, or under a drogue no faster than the mark, which reads as one. The main's descent is then the whole descent's, from apogee
log 2 withheld: the descent shows no drogue's leg, which at the ground's density falls faster than 31.1 m/s up to the main's opening. That mark is 1.6 times the rate near the ground, 19.5 m/s, or 3 m/s more if that is more. A drogue's leg would also fall on median faster than 1.4 times the rate near the ground. So the rocket came down under one canopy, or under a drogue no faster than the mark, which reads as one. The main's descent is then the whole descent's, from apogee
main's opening, above each log's own pad
log 1 withheld: the descent shows one canopy
log 2 withheld: the descent shows one canopy
main descent
log 1 19.4 m/s (64 ft/s), within 1.6 m/s (6 ft/s), 90% interval 18.4 to 20.3 m/s (60 to 67 ft/s)
log 2 19.6 m/s (64 ft/s), within 1.6 m/s (6 ft/s), 90% interval 18.6 to 20.5 m/s (61 to 68 ft/s)
spread 0.2 m/s (1 ft/s)
How far to trust it. Measured by the loggers, read by HPR Sim from their logs, not simulated, and
never averaged. A spread says how far apart the logs lie, not which is right: two boards can agree
and both be off by the day's air. The clocks are lined up by each log's liftoff; that the logs are
of one flight is your word, not checked. Each reading states the bound its error stayed within on
HPR Sim's synthetic flights. They cover rates from 500 to 0.5 samples a second, steps up to 10 m or
100 Pa, and air within 15 K of standard. A reading the log can't support is withheld, with the
reason. The top speed is derived from the heights, and withheld from Mach 0.8, where a barometer's
port may read the flow over the nose. For a record or a certification, the altimeter's own reading
is the one to log, and the RSO decides.
More: https://hpr.fusionspace.co/reading-a-flight-log.html
A ghost file
--ghost FILE also writes the logs’ paths for a viewer, on one clock in a frame at the pad: .json,
.czml (Cesium) or .gltf (a 3D scene), by the file’s extension. Give it again for another format.
--pad LAT,LON[,HEIGHT] states the pad, in degrees and meters; without it, the place comes from the
log’s GNSS fixes. Ghost files says what each file holds and what it assumes
where a log can’t say.
hpr analyze flight.csv \
--ghost flight.czml \
--ghost flight.gltf
A logger of your own
A logger of your own is read by a file you write for it, each JSON with a schema (JSON output):
--print-mappingprints what a table’s header states, as a column mapping to edit, and reads nothing more. It’s the same with--json, and not stamped withtool, so it reads back.--mapping FILEreads a table by its column mapping. The mapping can mark the column that is the barometric altitude above the pad as the primary track.--sheet Nnames the workbook’s sheet the table is on,.xlsxor a bare.xls, from 0. A workbook of one sheet needs none.--layout FILEreads binary records, or the block of a serial console’s capture the layout names, by a record layout. It takes no--sheet.--fip-header FILEreads a Featherweight Raven’s FIP export that lost its header line when it was pasted into a workbook. It reads the export under the header line the file states (below).--sheet Npicks the workbook’s sheet,.xlsxor a bare.xls. With none, the workbook must have only one. The rows saved as text read too.--recordprints the record the log reads into, every channel in SI units (degrees for angles), as one JSON document, in place of the readings.
A log is read by one of --mapping, --layout and --fip-header, never two. The JSON output’s
log object names the file given, as mapping, layout or fip_header. A mapping or layout
that doesn’t follow its schema is refused, exit code 1, naming the field by its JSON path, such as
columns[1].unit. One the log contradicts, such as a primary track on the clock’s column,
is refused naming the column. Reading your own logger works one invented
logger through each.
A FIP header file has two keys. header is the header
line the Featherweight Interface Program writes for an export of the same channels. It gives each
channel’s Time@ clock, its value and its bILBA status cell.
pasted lists the columns, counted from 1, that another table pasted over the export covers.
Leave it out when none are. A key the schema doesn’t name is refused, naming it. For an invented
export of three channels, the first’s clock and value covered by a pasted table, which leaves that
channel out:
{
"header": "Time@Axial Accel (Gs),Axial Accel (Gs),bILBA,Time@Baro (Atm),Baro (Atm),bILBA,Time@[Altitude (Baro-Ft-AGL)],[Altitude (Baro-Ft-AGL)],bILBA",
"pasted": [1, 2]
}
A log read under a stated header is marked as one read by your own description, as a mapping’s is. Its readings are only as right as that header (A FIP export pasted below no header).
hpr weather
hpr weather writes down the air and the wind over a launch site, level by level from the ground
up. At each height it gives the pressure, temperature, humidity, and the wind’s speed and the
direction it blows from. That list of levels is a profile (a
sounding, when a weather balloon measured it). It comes from one of five
sources:
| source | what it is | command |
|---|---|---|
| Open-Meteo | a free weather service’s forecast, or its archive of past forecasts (Launch-day weather) | hpr weather open-meteo --latitude 32.99 --longitude -106.97 --time 2026-10-02T18:00Z |
| University of Wyoming | a weather balloon’s measurements, from the station’s latest launch before yours (Weather-balloon soundings) | hpr weather wyoming --station 72364 --time 2025-06-21T15:30Z |
| GFS | NOAA’s global forecast model, on a 0.25° grid, fetched or read from a whole file you download (NOAA forecasts: GFS and RAP) | hpr weather gfs --latitude 32.99 --longitude -106.97 --cycle 2026-09-30T00Z --hour 18 |
| RAP | NOAA’s 13 km (8.1 mi) forecast model over the contiguous U.S. and nearby Canada and Mexico (NOAA forecasts: GFS and RAP) | hpr weather rap --latitude 32.99 --longitude -106.97 --cycle 2026-09-30T12Z --hour 6 |
| ERA5 | a netCDF file you download from Europe’s climate data service: the past weather, reconstructed (ERA5 weather files) | hpr weather era5 era5.nc --latitude 47.21 --longitude 9.00 --time 2020-02-22T13:00Z |
hpr sim --weather flies a profile (the profile file). Each source’s page
flies Calisto, RocketPy’s example rocket, through the weather it fetched.
The tests in
crates/hpr-cli/tests/weather.rs
run the four online sources through hpr weather offline, from a saved answer and from the
cache. They run ERA5 from its file.
Asking for the weather
- Times are UTC, written
2025-06-21T15:30Z: the date, aT, the hour and minutes, and aZfor UTC. Seconds are optional, and so are the minutes:2026-09-30T00Zis midnight. A time without itsZis refused, so local time can’t be mistaken for UTC. - Open-Meteo reads the forecast at
--time, between the two hours around it. Add--historicalfor a launch already gone: that asks Open-Meteo’s archive of past forecasts.--modelnames one of Open-Meteo’s weather models, by the name its documentation gives. By default it picks one (What the simulator asks for). - Wyoming takes the station’s number, such as station 72364 for Santa Teresa,
New Mexico (finding a station), and your launch
--time. It fetches that station’s latest sounding before the launch. Soundings are named for 00 and 12 UTC, and the balloon goes up about an hour before. The example’s 12 UTC sounding left at 11:02.--bufrasks for the detailed version, a row every second or two of the climb. - GFS and RAP take the forecast run and the hour.
--cycleis when the run started, and--houris how many hours after it the forecast is for. GFS runs every 6 hours and RAP every hour. What the simulator asks for lists the hours each run covers, and how long NOAA keeps them. - ERA5 reads a file you downloaded, at your site and time (Getting a file).
Online, offline, and saved answers
The first time you ask, hpr weather fetches the answer over HTTPS. It keeps a copy in the
simulator’s cache folder (Where the cache lives;
HPR_CACHE_DIR moves it). Ask again and it reads the copy while that is fresh
(How long a copy stays fresh). If the network fails,
it falls back to an older copy, and the output says so.
--offlinenever goes online. It answers from the cache, fresh or not. With no copy it fails, with exit status 1, and names what it would have fetched.--from FILEreads an answer saved earlier and touches neither the network nor the cache. It reads Open-Meteo’s JSON, the Wyoming archive’s CSV, or a GRIB2 file for GFS and RAP. For GFS and RAP, still give--latitudeand--longitude. The file covers an area, and the site picks the point in it. For Open-Meteo and Wyoming, the file says where and when it’s for. So the options that choose what to fetch are refused beside it: Open-Meteo’s--latitude,--longitude,--historicaland--model, and Wyoming’s--station,--timeand--bufr. Open-Meteo’s--timestays, and must fall within the file’s hours. A GRIB2 file is checked as a fetched one is. It must be on its model’s grid, and when you give--cycleand--hour, it must be that run and hour. Check the first line of the output, which says where and when the profile is for.--output FILE(or-o) writes the profile as JSON, described below.
A fetch that takes more than a tenth of a second says so on standard error when that’s a
terminal. It shows waiting for nomads.ncep.noaa.gov, 1 s, then, once the answer starts to
arrive, fetching from nomads.ncep.noaa.gov: 48.2 kB so far, 2 s. Each goes over the one before,
gone when the answer is in. hpr motors fetch, hpr motors search and hpr sim fetching a motor do the
same (Fetching over HTTP).
The simulator reads the small GRIB2 files that NOAA’s download server, NOMADS, cuts out around a
site. It reads whole GFS files you download yourself too, which are packed more tightly
(A whole GFS file). The decoder also reads fields compressed as JPEG
2000 images, which RAP’s whole files use. But no whole RAP file has been run through hpr weather
yet (Files in JPEG 2000).
An example
This reads a recorded answer from Open-Meteo’s archive, for Spaceport America in New Mexico at 15:30
UTC on 21 June 2025. It writes the profile to profile.json. (The page’s run writes into a scratch
folder, shown as <the scratch folder>; hpr prints the path you give it.)
$ hpr weather open-meteo --time 2025-06-21T15:30Z --from crates/hpr-net/tests/fixtures/replay/open-meteo-historical.json --output profile.json
Open-Meteo at 32.99655° N, 106.96947° W, for 2025-06-21T15:30:00Z
Read from open-meteo-historical.json
Weather data by Open-Meteo.com (CC BY 4.0)
height pressure temp humidity wind from
m MSL (ft) hPa °C (°F) % m/s (mph) ° T
1400.0 (4593) 859.5 29.6 (85) 18 3.3 (7) 162
1482.0 (4862) 850.0 28.2 (83) 16 2.9 (6) 189
2014.4 (6609) 800.0 23.4 (74) 16 2.8 (6) 225
3160.6 (10369) 700.0 14.5 (58) 28 6.8 (15) 236
4439.1 (14564) 600.0 3.3 (38) 60 9.8 (22) 219
5894.6 (19339) 500.0 -7.0 (19) 70 9.9 (22) 200
7604.0 (24948) 400.0 -17.1 (1) 34 8.3 (19) 218
9712.0 (31864) 300.0 -31.5 (-25) 8 4.4 (10) 261
10981.7 (36029) 250.0 -41.2 (-42) 9 10.6 (24) 261
12465.1 (40896) 200.0 -52.2 (-62) 13 9.8 (22) 253
14276.4 (46838) 150.0 -64.8 (-85) 18 9.9 (22) 263
16716.8 (54845) 100.0 -70.8 (-95) 12 6.3 (14) 253
18863.9 (61889) 70.0 -66.2 (-87) 4 7.8 (17) 164
20940.5 (68703) 50.0 -60.0 (-76) 0 5.4 (12) 108
24212.5 (79437) 30.0 -54.0 (-65) 0 8.6 (19) 083
Left out: 5 levels
below the ground, 5 levels: 1000 hPa, 975 hPa, 950 hPa, 925 hPa, 900 hPa
Profile written to <the scratch folder>/profile.json
How far to trust it. A weather model's forecast, not a measurement. HPR Sim's profile gives back
every level it keeps of Open-Meteo's answer to rounding error, checked on recorded answers; the
forecast itself is not yet checked here against measured winds or a flight's log. On launch day, go
by the latest forecast and the wind measured at the field; the RSO decides.
More: https://hpr.fusionspace.co/weather.html
The first line says where and when the profile is for:
- for Open-Meteo, its model’s grid point nearest the site
- for GFS and RAP, the site itself, blended from the four grid points around it
- for Wyoming, where the balloon was released
The ground comes first: its height above sea level (MSL) and its pressure in hectopascals (hPa; 1,013 hPa is sea level’s standard). Then come its temperature and humidity, and the wind 10 m (33 ft) above it. Each pressure level above the ground follows.
The levels the model gives below the ground are listed as left out. Here the ground is at about 1,400 m (4,593 ft), and 1,000 to 900 hPa lie beneath it. Where each value comes from, and why levels are left out, is on the source’s page.
The profile file
--output writes the profile in SI units, the way the library holds it. Its levels run from the
lowest up, each with:
| field | unit |
|---|---|
height_msl_m | meters above sea level |
temperature_k | kelvin |
pressure_pa | pascals (100 Pa = 1 hPa) |
relative_humidity | a fraction: 0.18 is 18%; null for ERA5, which the simulator reads as dry air |
wind_speed_m_s | meters per second |
wind_direction_from_rad | radians clockwise from true north, where the wind comes from |
The file opens with a tool object naming the program that wrote it. Then comes kind, which
says what the figures are: measured for a balloon sounding, forecast, or reanalysis for ERA5.
Then comes trust, the note the printed result ends with, so a saved profile keeps how far to
trust it. Nothing checks or uses these three keys. The library reads past them, and reads a profile
saved before they were written too.
After them come the levels above, then latitude_rad, the latitude the profile was measured or
forecast at, in radians. Last is wind_interpolation, how the wind is blended between levels
(speed_direction). The Rust library reads the file back as a
SoundingProfile, with the same checks.
hpr sim --weather FILE flies it, from an --elevation within its levels, and refuses a profile
with no winds. The text output and --json give the same levels with the direction in degrees.
What the profile leaves out
- Time between forecast hours, for GFS and RAP: pick the run and hour nearest your launch. Open-Meteo and ERA5 blend the two hours around it.
- The site’s real ground. A forecast’s ground is its model’s smoothed terrain, not your pad’s height. An ERA5 file has no ground at all: its levels start at 1,000 hPa, which can lie below a high site.
- Humidity in ERA5. The simulator doesn’t read it yet, so ERA5’s profile is dry air.
- Above the top level, the library carries the air on as the standard atmosphere and holds the top wind. Each source’s page gives its top.
Scripting and shells
What a script or a shell gets from hpr: its JSON documents, its exit codes and its completion scripts.
JSON output
With --json, a command prints exactly one JSON document on standard
output, and nothing on standard error. That holds when the command fails, too. What the text’s
warning: and note: lines say is in the document’s own fields instead, such as hpr sim’s
notes, warnings, flags and issues. Each document has a published JSON Schema, which
describes its fields and units:
| output | schema |
|---|---|
hpr sim | sim.schema.json |
hpr motors list | motors-list.schema.json |
hpr motors show | motors-show.schema.json |
hpr motors search | motors-search.schema.json |
hpr convert | convert.schema.json |
hpr analyze | analyze.schema.json |
hpr analyze with more than one log | analyze-together.schema.json |
hpr analyze --record | analyze-record.schema.json |
hpr weather | weather.schema.json |
hpr completions | completions.schema.json |
| any failure | error.schema.json |
Every document opens with the same tool object, the program that wrote it:
{"name": "FusionSpace HPR", "version": "0.1.0", "designation": "FS-ACHERNAR \u00b7 SW \u00b7 TOOL 001"}.
The text is ASCII, so the designation’s middle dot · is written as its escape \u00b7. Every
JSON reader reads that back as the dot
(Exporting a flight). An error document’s
help lists what to do about the failure, the lines the text output starts with help:. It’s
empty when there’s nothing to suggest.
The sidecar of a CSV recording (Exporting the recording) has its own
schema, sim-export-meta.schema.json.
Three files hpr analyze reads have schemas too, with no tool, as a person writes them:
- the column mapping,
analyze-mapping.schema.json, which--print-mappingprints - the record layout,
analyze-layout.schema.json - the FIP header,
analyze-fip-header.schema.json
Units are SI, and each field’s name says its unit: total_impulse_ns is in newton-seconds and
diameter_m in meters. The exceptions say so in their names too:
hpr simgives angles in degrees (latitude_deg) and margins in calibers (margin_cal)hpr weathergives the wind’s direction in degrees (wind_from_deg) and humidity as a fraction (relative_humidity, 0 to 1)hpr motors listkeeps the catalog’s millimeters (diameter_mm)hpr motors searchkeeps the site’s millimeters and cents (diameter_mm,unit_price_cents)
Numbers aren’t rounded, so a converted value can end in digits such as 0.0036000000000000003. A
motor’s figures carry no more precision than its curve file.
FusionSpace HPR is released but not yet at 1.0, so the fields may still change. The schemas are published beside the code, and a change to a document changes its schema in the same commit.
$ hpr motors show B4-4 --json
{
"tool": {
"name": "FusionSpace HPR",
"version": "0.1.0",
"designation": "FS-ACHERNAR \u00b7 SW \u00b7 TOOL 001"
},
"kind": "copied",
"trust": "How far to trust it. Copied from ThrustCurve.org's curve file, downloaded 2026-10-28, not measured by HPR Sim: the size, masses and delays from the file's header, the impulse, thrusts and burn time from its curve, which can differ from the maker's rated figures. Each file is checked against ThrustCurve.org's figures and OpenRocket's reading of its impulse and peak thrust, not against the maker's data: checks of the file, not of the motor. The motor's printed data and its maker's instructions come first, and the RSO decides. More: https://hpr.fusionspace.co/pick-a-motor.html",
"motors": [
{
"name": "B4-4",
"manufacturer": "Quest Aerospace",
"source": {
"kind": "catalog",
"format": "eng",
"files": [
{
"simfile_id": "5f4294d20002e900000006d6",
"page_url": "https://www.thrustcurve.org/simfiles/5f4294d20002e900000006d6/",
"format": "eng",
"measured_by": "certification_test",
"license": "not_stated",
"flown": true,
"check": {
"passes": false,
"total_impulse_ns": {
"file": 3.8392810000000006,
"stated": 3.84
},
"average_thrust_n": {
"file": 4.421340299414922,
"stated": 4.22
},
"burn_time_s": {
"file": 0.8683522959108246,
"stated": 0.91
}
}
}
]
},
"diameter_m": 0.019,
"length_m": 0.07,
"propellant_mass_kg": 0.010400000000000001,
"loaded_mass_kg": 0.0166,
"total_impulse_ns": 3.8392810000000006,
"impulse_class": "B",
"average_thrust_n": 4.421340299414922,
"peak_thrust_n": 12.81,
"burn_time_s": 0.8683522959108246,
"burn_start_s": 0.019373510540788272,
"burn_end_s": 0.8877258064516129,
"curve_end_s": 0.91,
"delays": [
{
"kind": "seconds",
"value": 4.0
}
]
}
],
"warnings": [
{
"motor": "B4-4",
"line": null,
"kind": "dropped",
"message": "an empty delay in \"4-\" was left out, and no number HPR Sim works out depends on it"
},
{
"motor": "B4-4",
"line": null,
"kind": "unusual",
"message": "B4-4's curve file 5f4294d20002e900000006d6 is more than 1% from ThrustCurve.org's figures for it: average thrust +4.77%, burn time -4.58%"
}
]
}
A failure prints an error document. Its kind matches the exit status, and milestone is set
only for a command not available yet. Here hpr sim --offline refuses a copy of the test rocket
above whose motor is an invented one, without --motor, as neither the file, the bundled catalog nor
the cache holds a curve for it:
$ hpr sim validation/fixtures/ork/guides/no-curve.ork --offline --json
{
"tool": {
"name": "FusionSpace HPR",
"version": "0.1.0",
"designation": "FS-ACHERNAR \u00b7 SW \u00b7 TOOL 001"
},
"error": {
"kind": "input",
"message": "configuration [Z9-INVENTED] can't be flown as the file has it. No thrust curve for Z9-INVENTED: no embedded curve, and no motor of that manufacturer and designation in the bundled catalog. Invented Z9-INVENTED is not in HPR Sim's cache of ThrustCurve.org, and the run is offline",
"command": "sim",
"milestone": null,
"help": [
"with a network connection, `hpr motors fetch --manufacturer Invented Z9-INVENTED` fetches it into the cache",
"give a motor with --motor"
]
}
}
$ echo $?
1
Exit codes
| Exit code | kind in JSON | meaning |
|---|---|---|
| 0 | - | The command did what was asked. |
| 1 | input | An input was missing, unreadable or refused, such as a motor the catalog doesn’t have. |
| 2 | usage | The command line was wrong: an unknown command or option, or a missing argument. |
| 3 | not_available | The command is registered, but the milestone that brings it hasn’t come yet. |
hpr --help and hpr --version print text and exit with 0, even with --json.
hpr completions
hpr completions writes a script that lets your shell complete hpr’s commands and options when
you press Tab. Save it where your shell looks for completions:
| shell | command |
|---|---|
| bash | hpr completions bash > ~/.local/share/bash-completion/completions/hpr |
| zsh | hpr completions zsh > ~/.zfunc/_hpr, with fpath+=~/.zfunc before compinit in ~/.zshrc |
| fish | hpr completions fish > ~/.config/fish/completions/hpr.fish |
| PowerShell | hpr completions powershell >> $PROFILE |
| elvish | hpr completions elvish >> ~/.config/elvish/rc.elv |
What it leaves out
- Some unpowered separations, a dropped stage’s accuracy, and a rocket
.json’s parachutes.hpr simflies powered separations, one or several in turn. It flies a lone unpowered one before apogee only if the part that keeps the nose has a device open by then. A dropped stage flies as a point under its devices’ drag, so its landing is rough. It flies a.orkfile’s parachutes and streamers, but a rocket’s.jsoncomes down with no recovery device (what it doesn’t fly yet). - Readings within bounds, with intervals.
hpr analyzegives each reading within a bound or withheld, on every layout it reads. Twelve readings give a 90% interval too, and a floor a lower end in its place (The 90% intervals), with the smoother’s apogee and health card. It gives no Mach number and takes no top acceleration from a board’s three axes. It finds no deployment but the main’s opening, from the descent’s rate. - Only OpenRocket’s design files and the HPR design format.
hpr convertandhpr simread OpenRocket’s.orkand the HPR design format’s.hprand.hprz, not RockSim’s.rktor RASAero’s.CDX1(how the formats compare). - No validation check. The validation cases and their reference results are files in the
repository, not part of the tool. To re-run them, clone the repository and run
cargo xtask validate --check(what it checks). - RockSim is unchecked. OpenRocket opens the files
hpr convertwrites (evidence row G25); whether RockSim does isn’t checked. - Stock from one site.
hpr motors searchcovers only what motor.fusionspace.co does (what it leaves out). It has no filter by total impulse or by reload case. - 80 catalog motors can’t fly by name. The catalog has no curve file for them that
reads (the whole catalog). A motor newer than the
catalog’s October 28, 2026 capture needs its
.engor.rsefile, or its curve fetched from ThrustCurve.org into the cache.hpr motors searchlists motors you can buy, not their curves. - Downloads for three systems (Running it). On other systems,
hpris built from source with Rust. - The text output is for people. Its layout may change between versions. Scripts should read
--json, whose schemas are published.
Online data and the cache
See how HPR Sim fetches weather, elevation and motor data over the network, and how its cache keeps those answers working offline.
This page covers hpr-net, the one crate that uses the network, and the cache that makes its
answers work offline. It’s for anyone who will pull weather, elevation or motor data into a
flight.
Today the crate holds the cache, the offline rule and an HTTP client (the online layer), and six data sources:
- Open-Meteo’s weather (Launch-day weather);
- weather-balloon soundings from the University of Wyoming (Weather-balloon soundings);
- NOAA’s GFS and RAP forecasts (NOAA forecasts: GFS and RAP);
- Open-Meteo’s ground elevation (A launch site’s elevation);
- motor.fusionspace.co’s motor stock and prices (Motor stock and prices);
- ThrustCurve.org’s motor records and thrust curves (also on
Motor stock and prices).
hpr simandhpr motors fetchfetch a curve the bundled catalog lacks (Motors from ThrustCurve.org).
What it promises
The simulation itself never touches the network (the architecture’s pure-core rule: no filesystem, network or clock). Anything fetched from the internet goes through a client. The client puts a cache (a folder of saved responses) in front of a transport (the thing that fetches). It runs in one of two modes:
- Online: if the cache holds a fresh copy, the client returns it without fetching. Otherwise it fetches, saves the response, and returns it. If the fetch fails and an old copy exists, it returns the old copy, marked stale, with the reason. With no old copy, it returns the fetch’s error.
- Offline: it never calls the transport. It returns whatever the cache holds, marked stale if it’s old, or an error saying the URL isn’t cached.
Each answer says how fresh it is (Fetched, Cached or Stale) and when it was fetched. It
gives the data source’s attribution, the credit line its terms ask you to show with the data.
A data source can also give the client a check, its own parser (Client::fetch_checked). Then an
answer the parser refuses is never saved, so it can’t take a good copy’s place. Examples are an
error page sent as a success and a forecast whose hours are still empty. Online, a good copy that
has gone stale comes back instead, with the reason; with no copy, the fetch fails. A saved copy
the check refuses counts as missing online, and is the error offline.
How long a copy stays fresh
Each source has a time to live (TTL): how many seconds a saved copy counts as fresh. A copy
exactly one TTL old is no longer fresh: online it’s fetched again, offline it comes back marked
Stale. A copy dated later than the time asked (saved while the clock ran fast) is never fresh.
The caller passes the time, in seconds since 1 January 1970 (Unix time). The crate reads no clock,
so the tests can use small numbers.
Here’s a worked example with a one-hour TTL (3,600 s), from the tests. Each scenario starts with an empty cache and fills it at 1,000 s:
| scenario | time asked (s) | cache holds | answer | fetches made |
|---|---|---|---|---|
| A, online | 1,000 | nothing | Fetched, from 1,000 | 1 |
| A, online | 4,599 | copy from 1,000 (3,599 s old) | Cached, from 1,000 | 1 |
| A, online | 4,600 | copy from 1,000 (3,600 s old) | Fetched, from 4,600 | 2 |
| B, offline | 1,000, before filling | nothing | error: not cached | none |
| B, offline | 1,010 | copy from 1,000 | Cached, from 1,000 | none |
| B, offline | 2,593,000 (30 days after 1,000) | copy from 1,000 | Stale, from 1,000 | none |
| C, online, network down | 8,200 | copy from 1,000 | Stale, from 1,000, with the reason | one failed |
| C, online, network down | 1,000 | nothing, for another URL | error: the fetch’s | one failed |
Fetching over HTTP
The HTTP client is Http. It’s behind hpr-net’s http cargo
feature. So a program that depends on hpr-net alone and needs only the cache and saved responses
builds no network code.
The hpr library’s net feature turns HTTP on: with
fusionspace-hpr = { version = "0.1", features = ["net"] } in Cargo.toml it’s
hpr::hpr_net::Http. Its API page has
an example, compiled in CI, that fetches into the platform’s cache folder. Building with HTTP needs
a C compiler, since the encryption library compiles some C and assembly.
| behavior | what it does | checked by |
|---|---|---|
| encryption (TLS) | rustls, a TLS library written in Rust, with Mozilla’s list of trusted certificate authorities built in: no OpenSSL, and the computer’s own certificate store is not read | one manual fetch; not in CI |
| time allowed | 60 s for the whole request: finding the host, connecting, redirects and reading; at most 30 days | a test, at 0.3 s |
| largest answer | 64 MiB, counted after any unpacking; one byte more is refused | a test, at and one byte past a limit set to the sample’s size |
| compression | asks for gzip and unpacks it | a test |
| error status | anything but a 2xx success, such as 404 or 304, is a failed fetch | a test each for 404 and 304 |
| redirects | followed, up to ten; the cache files the answer under the address you asked for | a test with one redirect; the cap of ten is ureq’s default, not tested |
| proxy | the first set of ALL_PROXY, HTTPS_PROXY and HTTP_PROXY (either case), for both http and https addresses; hosts listed in NO_PROXY connect directly; an unreadable value is ignored. A SOCKS proxy is refused with an error, not bypassed, and under one no redirect is followed | tests that a SOCKS proxy is refused, that NO_PROXY exempts a host, and that the error doesn’t show the proxy’s password; the rest is ureq’s, not tested |
| identification | sends User-Agent: fusionspace-hpr/<version> (+https://hpr.fusionspace.co), so a data provider can see who is asking | a test |
| bytes so far | counts the answer’s bytes as they arrive, after any unpacking, for a caller to show while it waits (Http::received); each fetch starts from 0 | tests of the count and of its start |
A failed fetch (an error status, a timeout, a refused or dropped connection, a too-long answer) is handled as above. Online, the client falls back to an old copy marked stale.
On the command line, a fetch that waits more than a tenth of a second says so on standard error,
when that’s a terminal. It shows waiting for nomads.ncep.noaa.gov, 1 s until the answer starts,
then fetching from nomads.ncep.noaa.gov: 48.2 kB so far, 2 s. Each line is drawn over the one
before and is gone once the answer is in. A copy read from the cache, standard error
into a file or a pipe, --json, and a terminal with TERM=dumb draw nothing.
A fetch that waits longer than the time allowed (the table above) fails. A failed or refused
fetch, including an --offline run with nothing cached, ends with help: lines. They say what to
do, such as running it again without --offline.
The time and size limits, and whether to use the environment’s proxy, are fields of
HttpConfig. Start from HttpConfig::default(), change a
field (for example config.timeout = Duration::from_secs(300)), and pass it to
Http::with_config(config).
The computer’s certificate store isn’t read. So a network that inspects encrypted traffic with its own certificate (common on company and school networks) makes every HTTPS fetch fail. There’s no setting yet to add a certificate.
Where the cache lives
The cache folder is whatever you pass. Cache::platform_dir
gives the usual place for caches on each system, and the folder is created on the first save:
| system | folder |
|---|---|
| macOS | $HOME/Library/Caches/co.fusionspace.hpr |
| Windows | %LOCALAPPDATA%\FusionSpace\hpr\cache |
| Linux and other Unix | $XDG_CACHE_HOME/fusionspace-hpr if that variable holds a full path, otherwise $HOME/.cache/fusionspace-hpr |
The folders carry FusionSpace HPR’s name
(the decision on the public name).
Builds from before release 0.1 used folders named hpr-sim; those are not read. So a cache from
one of them fills again from the network, and the old folder can be deleted.
Setting the environment variable HPR_CACHE_DIR puts the cache in that folder instead, on every
system. A relative path there is taken from the current folder. The folders come from environment
variables alone. On Windows, LOCALAPPDATA is read rather than asking the system, which gives the
same folder unless the variable was changed. If HPR_CACHE_DIR isn’t set and HOME (macOS,
Linux) or LOCALAPPDATA (Windows) is unset or empty, Cache::platform_dir returns nothing and you
must name a folder.
Setting HPR_OFFLINE to anything but empty or 0 makes every hpr command answer from the
cache alone, as each command’s --offline does. It’s for a script, or a field laptop, that must
not reach the network.
How it is checked
The tests in crates/hpr-net/tests/offline.rs
replay a hand-written sample from a folder:
- The offline test gives the client a transport that fails the test if it’s ever called. Then the test asks for a URL before and after it’s cached, fresh and thirty days stale.
- Offline, a corrupt entry is an error; online, it’s fetched again and overwritten.
- The checked fetch is tested through Open-Meteo’s source (Launch-day weather). An answer with an hour’s values missing isn’t saved, and an earlier good copy comes back and stays saved.
- The soundings’ source is tested the same way (Weather-balloon soundings).
- NOAA’s forecasts refuse, and don’t save, a file for another run or hour than the one asked for (NOAA forecasts: GFS and RAP).
- The elevation source refuses an answer with no heights, and a lookup made once works offline (A launch site’s elevation).
- The motor-stock source refuses, and doesn’t save, a motor’s page that holds another motor. The ThrustCurve.org source does the same with a download of another motor’s file (Motor stock and prices).
The cache’s own tests check that a saved body reads back, and that another URL’s entry in the same
file reads as a miss. They check the hash that names each file against its published test
values. It’s FNV-1a, a standard 64-bit hash, so names stay the same on every platform. The cache
folder rules are checked for each system with a made-up environment, HPR_CACHE_DIR included; the
XDG_CACHE_HOME case runs only on Unix test machines.
The API reference for hpr_net has a runnable example.
The HTTP tests in crates/hpr-net/tests/http.rs
start a small web server inside the test, serving the same sample on the computer’s own loopback
address (127.0.0.1). Nothing leaves the machine, and the tests turn off any proxy the
environment names. They check that:
- a fetch saves the sample in the cache, and a second fetch inside the time to live sends no request;
- offline mode answers from the cache without a request while the server is still running;
- a compressed answer arrives unpacked, and the request names
fusionspace-hprand asks for gzip; - a redirect is followed and saved under the address asked for;
- a 404 and a 304 are failed fetches and save nothing;
- an answer one byte over the limit is refused and one at the limit passes;
- a megabyte of zeros that compresses to under 64 KiB is refused at a 64 KiB limit;
- a server that never answers is cut off at a 0.3 s limit. The test requires under 5 s, and the server stalls for 10 s;
- a timeout of
Duration::MAX(the usual way to say “no limit”), which the transport treats as 30 days, doesn’t crash; - when the server hangs up without answering, an old copy comes back marked stale, with the reason.
What it leaves out
- No retries: a failed fetch is tried once.
- Plain, unencrypted
http://addresses are accepted; nothing forces HTTPS. - The 60 s time limit covers the whole transfer, so a large answer on a slow connection can time
out. Raise it in
HttpConfig. - No test makes an encrypted (HTTPS) connection. The test server speaks plain HTTP, since a local encrypted server would need certificates made for the test. One manual run on a Mac fetched a real Open-Meteo forecast over HTTPS. The same run refused a site with an expired certificate (the decision record on HTTP over the cache).
- Freshness comes only from the source’s TTL: a server’s cache headers are ignored, and the cache key is the URL alone.
- If saving a fetched body fails (a full disk, a read-only folder), the fetch fails too.
- Nothing prunes old entries, and nothing locks the cache. Each file is written whole under a temporary name and renamed, so no file is ever half written. But two programs saving the same URL at once, or a crash between the two renames, can leave a body beside another fetch’s time. Temporary files a crash leaves behind aren’t cleaned up.
Launch-day weather
Fetch the weather over a launch site at launch time from Open-Meteo, and fly a rocket through it instead of a standard atmosphere.
Open-Meteo is a free weather service. Its weather arrives as a sounding: temperature, pressure, humidity and wind at a column of heights. The column runs from the ground up to about 24 km (79,000 ft). This page is for anyone who wants a flight in a day’s forecast instead of the standard atmosphere with one wind.
Code: hpr_net::open_meteo (API reference), written for
the first weather increment. It needs the net feature of the
hpr crate. The choices are in
the decision record.
Weather from a file you download is on ERA5 weather files. The air a weather balloon measured is on Weather-balloon soundings. NOAA’s own GFS and RAP forecasts are on NOAA forecasts: GFS and RAP.
What the simulator asks for
Open-Meteo has two services with winds above the ground (its documentation). Both give numerical weather models’ output, hour by hour, on 19 pressure levels. A pressure level is a height named by the air pressure there, in hectopascals (hPa; sea-level pressure is about 1,013 hPa). The levels run from 1,000 hPa, about sea level, to 30 hPa, about 24 km (79,000 ft) up.
| service | covers | a saved answer stays fresh for |
|---|---|---|
| Forecast | about 16 days ahead and 3 months back | 1 hour |
| Historical forecast | the same forecasts, archived, for a past launch | 30 days |
The simulator asks for the two whole hours around the launch time, in UTC (universal time, the time at Greenwich). On each level it asks for the temperature, relative humidity, wind speed and direction, and the level’s geopotential height. At the ground it asks for the pressure, the temperature and humidity 2 m (6.6 ft) up, and the wind 10 m (33 ft) up. The request names the units, and the simulator refuses an answer in any other. Wind directions are where the wind blows from, clockwise from north, as weather services give them.
The answer goes through hpr-net’s cache (Online data and the cache). So a
second request within the “stays fresh” time above is answered from the disk. Offline mode answers
from the disk only. An answer the simulator can’t read is never saved, so it can’t replace a good
copy.
The simulator writes the site’s latitude and longitude to 5 decimal places. That’s about 1 m (3.3 ft) on the ground, far finer than any model’s grid. Your program keeps the site in radians and turns it back into degrees, which can change its last digits. The rounding absorbs that: a site given to 8 decimals or fewer still finds its saved answer.
Open-Meteo’s data is licensed CC BY 4.0: show the
credit “Weather data by Open-Meteo.com (CC BY 4.0)” wherever you show the weather. Every answer
carries it. The free service is for non-commercial use, under 10,000 calls a day
(Open-Meteo’s terms). A self-hosted Open-Meteo server can stand
in for Open-Meteo’s own: set the request’s endpoint.
How the answer becomes a sounding
The ground is at the answer’s elevation. It takes the ground pressure, the 2 m (6.6 ft) temperature and humidity, and the 10 m (33 ft) wind. Putting the 10 m (33 ft) wind at the ground makes it the wind on the launch rail. The profile doesn’t jump from there to the lowest level’s wind above it (a Loft lesson: a forecast profile that stepped at its lowest level).
Levels below the ground are left out. The weather models report all 19 levels everywhere, inventing values beneath high ground. A level is kept only when its pressure is below the ground’s and its height is above the ground.
A level with a missing value at either hour is left out too. So is one whose relative humidity is outside 0 to 100%. The profile lists every level it left out, and why.
Heights. The models give a level’s height in geopotential meters. The simulator converts them to heights above sea level at the site’s latitude. It uses the World Meteorological Organization’s formula (WMO-No. 8 eq. 12.16, as the atmosphere page explains).
Open-Meteo’s documentation calls the value an altitude above sea level. So HPR Sim checks which it is on the two recorded answers. Air pressure falls with height at a rate set by the air’s temperature and humidity (the hypsometric equation). That fixes how thick each layer between two levels must be, in geopotential meters.
From 500 to 30 hPa, the recorded layers match that to within 0.03% to 0.13% on average. Read as meters above sea level instead, they’d be 0.58% to 0.68% too thin. So they’re geopotential meters.
Between the two hours every value is linear in time. The wind is interpolated by its east and north parts. So a wind that turns through the hour takes the shorter way round.
Between levels the sounding works as for any other. The temperature and humidity are linear, and the pressure is hydrostatic. The wind is interpolated by its speed and direction, or, if you ask, by its east and north parts, as RocketPy does. Above the top level the standard atmosphere continues, and the air is marked extrapolated.
Humidity is taken as relative to liquid water. A model that reports it relative to ice at cold levels changes the density there very little. The two differ by at most 27 Pa of water vapor (near −12 °C). That moves the density by under 0.03% at 400 hPa. Higher up the air is colder and the gap smaller: about 6 Pa at −40 °C, 0.08% even at 30 hPa.
An example
crates/hpr/examples/open_meteo_weather.rs
asks for the weather over Spaceport America at 15:30 UTC (9:30 local) on 21 June 2025. It makes
these calls:
Client::new(transport, Cache::new(folder), Mode::Online)sets up the fetching. The transport is what fetches (Online data and the cache). A real program passeshpr_net::Http::new()and keeps its cache inCache::platform_dir(). This one never uses the network. A stand-in transport answers with the historical-forecast answer recorded for the tests, which holds 15:00 and 16:00.OpenMeteoRequest::new(latitude, longitude, time, OpenMeteoApi::HistoricalForecast)says what to ask for, andopen_meteo::fetch(&client, &request, now)fetches and reads it at the launch time.profile.sounding(WindInterpolation::SpeedDirection)makes the sounding, andsounding.wind()its wind.hpr_sim::Environment::new(earth, sounding, wind)puts both in a flight’s environment.
The program prints the ground and the levels below 6 km (19,685 ft). Then it prints the air at the
pad and above it, beside the standard atmosphere. Last, it flies RocketPy’s Calisto (one of the
example rockets) in both, without its parachutes. Run it from a
copy of the repository with cargo run --example open_meteo_weather -p fusionspace-hpr --features net. It
prints:
Open-Meteo over 32.99° N, 106.97° W at 2025-06-21 15:30 UTC
Weather data by Open-Meteo.com (CC BY 4.0)
freshness: Fetched
level (hPa) height (m) temperature (°C) humidity (%) wind (m/s) from (°)
859.5 1400 29.6 18 3.3 162 the ground
850 1482 28.2 16 2.9 189
800 2014 23.4 16 2.8 225
700 3161 14.5 28 6.8 236
600 4439 3.3 60 9.8 219
500 5895 -7.0 70 9.9 200
Below the ground, left out: 1000, 975, 950, 925, 900 hPa
height above the pad (m) pressure (hPa) temperature (°C) density (kg/m³)
0 Open-Meteo 859.5 29.6 0.9858
0 standard 856.0 5.9 1.0687
1000 Open-Meteo 765.2 20.4 0.9058
1000 standard 756.3 -0.6 0.9667
3000 Open-Meteo 602.9 3.6 0.7565
3000 standard 585.2 -13.6 0.7854
Calisto to apogee apogee (m above the pad) east of the pad (m) north (m)
Open-Meteo 2913.5 15.3 -158.4
standard, calm 2854.5 -5.2 0.0
freshness: Fetched means the answer came from the transport, not the cache. A second call within
the hour would say Cached. The ground is at 1,400 m (4,593 ft), so the five levels from 1,000 to
900 hPa are left out.
That June morning was 24 °C warmer at the pad than the standard atmosphere. The air was 8% less dense there, and 4% less dense 3 km (9,843 ft) up. Calisto climbs 2.1% higher in it.
At apogee it’s 158 m (518 ft) south of the pad and 15 m (49 ft) east, upwind. The wind blows from the south-southeast at the ground. It turns to the southwest by 600 m (1,969 ft) above the pad, 2,014 m (6,608 ft) above sea level. A rocket just off the rail, still slow, turns into the wind (weathercocking) and flies that way.
The calm flight’s 5.2 m (17 ft) west is Earth’s rotation: a climbing rocket is pushed west (the Coriolis effect). With the rotation turned off, the calm flight drifts 0.006 m (0.2 in).
How it is checked
The tests in crates/hpr-net/tests/open_meteo.rs
use two answers recorded from Open-Meteo for Spaceport America. One is from the
historical-forecast service (21 June 2025, 15:00 and 16:00 UTC). The other is from the forecast
service (2 October 2026, 18:00 and 19:00 UTC). No test uses the network.
- At each recorded hour, the sounding is sampled at every kept level’s height. It gives back the recorded pressure to a relative 1e-12, the temperature to 1e-9 K and the wind to 1e-9 m/s. It also holds the recorded humidity. The test reads the expected values from the recording itself, not through the code under test. The ground is checked the same way.
- Both answers leave out exactly the five levels below the 1,400 m (4,593 ft) ground, and keep 14. Each half of the rule (the pressure, the height) leaves a level out on its own, in an edited answer.
- At 10 and 30 minutes past the hour, every value is the weighted average of the two hours. So is each part of the wind. A wind from 350° then 10° is from due north at half past, and a direction never reads 360°.
- A humidity of 100% at both hours stays 100% at any time between. Above 100%, a level is left out and the ground refused.
- The request’s address is the one recorded, so a replayed answer fills the cache. A second
request is answered from the cache, and offline mode answers without the network.
tests/http.rsdoes the same over HTTP, from a test server on the machine’s own address. - An answer with an hour’s values missing isn’t saved. With no earlier copy the request fails. With one, the earlier copy comes back, marked stale, and stays saved. A saved answer that can’t be read at a later launch time in the same hour is fetched again online. Offline, the request fails with the reason that answer can’t be read.
- The simulator refuses text that isn’t JSON, Open-Meteo’s error answer, and a unit other than the
one asked for. It also refuses a missing field, hours outside the years
1970to9999, and a time outside the answer’s hours. - The heights are geopotential, by the hypsometric check above. The test holds each average to the ranges quoted there.
What it leaves out
- A damaged answer gets an error, or a value from what was left, on the damage the tests try: the parser is tried on cut, changed and arbitrary bytes. That doesn’t test whether a well-formed answer is true. Damaged files says what the tests cover and leave out.
- Nothing checks a forecast against the weather that came. Weather-balloon soundings, the measured air, can be fetched too (Weather-balloon soundings), but no forecast has been compared with one. NOAA’s Global Forecast System and Rapid Refresh (GFS and RAP) can be fetched by name. A whole GFS file you download can be read too (NOAA forecasts: GFS and RAP).
- The ground takes the 2 m (6.6 ft) temperature and humidity and the 10 m (33 ft) wind. So the whole launch rail sees the 10 m (33 ft) wind. A real wind is weaker close to the ground. How much that changes a rocket’s turn into the wind off the rail isn’t measured.
- A relative humidity above 100% at the ground refuses the answer rather than trimming it.
- When Open-Meteo refuses a request (a place or date it doesn’t cover), the error names the HTTP status but not Open-Meteo’s reason. That’s because the HTTP transport drops the body of a failed answer.
- Each request is for only one place and one launch time. It takes Open-Meteo’s own choice of weather model unless you name one.
- The Python package doesn’t fetch weather. The command line fetches it with
hpr weather open-meteo.
Weather-balloon soundings
Fetch a weather balloon’s measurements from the University of Wyoming’s archive and fly a rocket through the air they recorded.
The University of Wyoming’s archive serves weather balloons’ measurements. A balloon carries a radiosonde, which measures the air on the way up, from the ground to 30 km (98,000 ft) or more. It records a sounding: temperature, pressure, humidity and wind at a column of heights. Hundreds of stations release one at 00 and 12 UTC (universal time, the time at Greenwich) every day.
This page is for anyone who wants a flight in air measured near a launch. The alternatives are a forecast (Launch-day weather, NOAA forecasts: GFS and RAP) or the standard atmosphere.
What the checks catch and miss:
- Each row’s height is checked against the row before it. That catches a gross error in a pressure or height (57 hPa recorded for 557). More than 10 bad rows in a row refuse the answer, and so does a ground that the rows after it agree is wrong. That can refuse a good ground too, when the first few rows after it are a little off.
- A wrong wind, humidity or temperature isn’t caught. On layers under about 100 m (328 ft) thick, the check allows any temperature from −150 to 80 °C.
- The archive serves two versions of most soundings, and they can disagree near the ground. In the example below, Calisto is 402 m (1,319 ft) from the pad at apogee in one and 563 m (1,847 ft) in the other.
Code: hpr_net::wyoming (API reference), written for
the second weather increment. It needs the net feature of the
hpr crate. The choices are in
the decision record.
What the simulator asks for
A request names a station and the sounding’s hour. The station is its World Meteorological
Organization (WMO) number, such as station 72364 for Santa Teresa, New Mexico; the archive’s page has a
map of them. WyomingRequest::latest_before(station, launch_time) picks the last 00 or 12 UTC
sounding at or before a launch. Times are in seconds since 1 January 1970 UTC (Unix time). The
balloon goes up about an hour before that hour.
The simulator asks for the archive’s comma-separated text, one row per level, and reads these columns. Pressures are in hectopascals (hPa, 100 Pa; sea-level pressure is about 1,013 hPa).
| column | read as |
|---|---|
| time | when the balloon was released, from the first row |
| latitude, longitude | where it was released, from the first row |
| pressure, in hPa | the level’s pressure |
| geopotential height, in m | its geopotential height above sea level |
| temperature, in °C | its temperature |
| relative humidity, in % | its humidity, relative to liquid water (the file gives it relative to ice too) |
| wind direction, in degrees, and wind speed, in m/s | the wind, and where it blows from, clockwise from north |
The units are in the column names, and the simulator refuses a file with any other. The archive serves two versions of most soundings:
| version | what it is | rows |
|---|---|---|
| Coded message, the default | the message stations have sent for decades (WMO’s TEMP code, FM 35) | about 200 |
| BUFR file | the station’s newer digital file (WMO’s Binary Universal Form for the Representation of meteorological data), a row every second of the climb | about 6,000 |
The coded message holds the standard pressure levels (850, 700, 500 hPa and so on). It also holds the significant levels between them, where the temperature or wind changes its trend.
The answer goes through hpr-net’s cache (Online data and the cache).
wyoming::fetch(&client, &request, now) takes the time now, in Unix seconds, to judge how fresh a
saved copy is. For a day after its hour the archive’s copy of a sounding can still fill in, as a
station’s later messages arrive:
| the sounding’s age | a saved copy stays fresh for |
|---|---|
| under a day | an hour |
| over a day | 30 days, if it was saved after the sounding’s first day; an earlier copy is fetched again |
Offline mode answers from the disk only, however old the copy. An answer the simulator can’t read is never saved, so it can’t replace a good copy. A sounding the archive doesn’t have comes back as an HTTP error: 404, or 400 for a BUFR file the station doesn’t send. The request reports that error. No test covers a missing sounding.
The archive states no terms of use. Show the credit “Sounding from the University of Wyoming’s radiosonde archive” wherever you show the sounding. Every answer carries it.
How the answer becomes a sounding
Heights. The file gives geopotential meters. The simulator converts them to heights above sea level at the first row’s latitude. It uses the WMO’s formula (WMO-No. 8, its Guide to Instruments and Methods of Observation, eqs. 12.15 and 12.16, as the atmosphere page explains).
The balloon drifts as it climbs. Converting at the latitude it reached instead would move a height. At 10 km (33,000 ft) the move is about 0.8 m (2.6 ft) per degree of drift. At 30 km (98,000 ft) it’s about 2.5 m (8.2 ft) per degree. The example’s balloon drifted 0.06°.
Why geopotential. Air pressure falls with height at a rate set by the air’s temperature and humidity. The hypsometric equation turns that into how thick each layer between two pressures must be, in geopotential meters:
Here and are the pressures at the layer’s bottom and top. is dry air’s gas constant (287.05 J/(kg·K)), and is standard gravity (9.80665 m/s²). is the mean of the two rows’ virtual temperatures. A virtual temperature is the temperature, raised a little for the humidity (WMO-No. 8, eqs. 12.17 and 12.18).
In the three recorded soundings, take the 13 layers between the standard levels from 850 to 10 hPa. The recorded thicknesses match the equation to 0.01% to 0.03% on average. Single layers are off by 0.05% to 0.13% on average, either way. Read as meters above sea level instead, the layers would be 0.51% to 0.60% too thin on average.
So they’re geopotential meters, as the column says.
Each row is checked against the row before it. Take a row with a pressure, height and temperature. It fits the row before it when its height above that row is the layer’s thickness, give or take an allowance. The allowance is 5% of the thickness, plus what rounding the two pressures can move it, plus 30 m (98 ft). The pressures are rounded to 1 hPa in the coded message at 100 hPa or more, and to 0.1 hPa elsewhere. For example, from the coded message’s row at 557 hPa to the next at 549 hPa:
| value | |
|---|---|
| virtual temperatures | 272.24 K and 271.42 K (−1.7 °C and −2.5 °C, 79% and 81% humidity) |
| 7,956.8 m (26,105 ft) | |
| thickness | 7,956.8 m × ln(557/549) = 115.1 m |
| recorded | 5,151 m − 5,035 m = 116 m, a miss of 0.9 m (3.0 ft) |
| allowance | 5% of 115.1 m + 14.4 m (rounding each pressure by 0.5 hPa) + 30 m = 50.1 m |
Rows are kept from a chain. The simulator looks for the longest chain of rows from the ground in which each row fits the one before it in the chain. The chain may pass by up to 10 rows at a time, and the rows it passes by are left out. Of two chains equally long, the simulator takes the one whose layers fit more closely. Closer means a smaller total of each layer’s miss as a share of its allowance. A miss of 25 m (82 ft) with an allowance of 50 m (164 ft) is a share of 0.5.
Why a chain: every row kept must also lie above the last row kept, so one bad row kept can hide the good ones. On that rule alone, a 557 hPa row with a digit lost, 57 hPa at 5,035 m (16,519 ft), would be kept. Every good row up to 57 hPa, about 20 km (66,000 ft), would then lie below it and be dropped.
To fit, the bad row would have to be 18.6 km (61,000 ft) above the row before it, at 570 hPa. It’s 183 m (600 ft) above that row. So the chain passes it by, from 570 hPa to 549 hPa, and it’s left out. A chain through two or three bad rows that fit each other would have to pass by more good rows. So they’re passed by the same way.
A row with no wind or humidity is left out of the profile but can still be in the chain. So the next row is checked across a thin layer, not a thick one. A row with no temperature can’t be checked. The chain steps over it without counting it, and it’s left out as missing a value.
In the three recordings every row fits the one before it, missing by at most 1 m (3.3 ft) beyond rounding. So the 30 m (98 ft) and the 5% are margin, and the check is for gross errors, not small ones:
- The 30 m (98 ft) leaves room for the coded message’s heights from 500 hPa up, which are rounded to 10 m (33 ft). A height 30 m (98 ft) off misplaces its level by about as much as a 0.33% to 0.55% pressure error. The range comes from the air’s scale height, 5.5 km (18,000 ft) to 9 km (30,000 ft). That’s the climb over which pressure falls by a factor of e.
- The 5% is a judgment, not a measurement: no row in the recordings needs any of it. It leaves room for a layer whose inner rows have no temperature, where the mean of its two ends’ temperatures gives its thickness less well.
Then the simulator keeps:
- The ground, the first row: the pressure, temperature, humidity and wind at the station when the balloon was released. A first row with a value missing or impossible refuses the answer.
- One row of each run of rows in the chain with the same pressure, the middle one. The BUFR file gives pressures to 0.1 hPa. High up, the balloon climbs tens of meters while the pressure falls that much, so runs of rows share one pressure. The rounded value is the pressure at about the middle of its run. In the example, 1,931 of the BUFR file’s 5,851 rows are the other rows of such runs; the coded message has none.
- Each such row that lies above the last row kept, higher and at a lower pressure. Rows that fall or stay at one height, a balloon coming down, fit but don’t lie above, and are left out however many.
It leaves out:
- A row the chain passes by.
- A row with a value missing or impossible: the last row often has no wind. An impossible
value is any of these:
- a pressure below 0.1 hPa or above 1,200 hPa;
- a temperature outside −150 to 80 °C;
- a height outside −1 km (−3,281 ft) to 60 km (196,850 ft);
- a wind speed below zero or above 300 m/s (671 mph);
- a humidity below zero, or a direction beyond 360°.
The profile lists every row it left out, and why. Two things refuse the answer:
-
A ground the rows after it disagree with. No row before the ground checks it. So HPR Sim also looks for chains each starting at one of the next 11 rows with a pressure, height and temperature within the bounds. If one of them beats every chain from the ground, the ground is taken as wrong.
Bad rows right after a good ground can do the same. They miss the ground but fit the rows above them, within the allowance. They beat the ground when the chain through them is longer, or as long and closer. The chain through them is longer when it passes by fewer good rows than it holds bad ones, less one.
That happens in narrow bands of error, just past the ground’s allowance. In the BUFR file, whose first layers are about 8 m (26 ft) thick, two rows 31 m (102 ft) high refuse the answer. Two rows 20 m (66 ft) high don’t, since they fit the ground and are kept. Nor do two 35 m (115 ft) high, which fit nothing but each other and are passed by.
In the winter coded message, three rows 45 m (148 ft) high refuse the answer. So do 11 bad rows that fit each other, however far off. HPR Sim can’t tell these from a bad ground. Rows grossly off, 850 m (2,789 ft) say, fit nothing above them and are passed by, up to 10.
-
More than 10 rows after the chain’s end. The chain can pass by only 10 rows at a time, so 11 bad rows in a row end it. HPR Sim takes that to mean the chain’s end is wrong, or all 11 are. A block of heights 1 km (3,281 ft) off is one such case.
A long run of rows with no temperature can also refuse the answer. The layer across the run is then too thick for its two ends’ temperatures to give. In a BUFR file 10 rows are about 10 s of the climb, some 50 m (164 ft). In a coded message they can span kilometers.
A refused answer names the lines and isn’t cached. The other version, or the sounding 12 hours earlier, may be usable instead.
In the profile:
- Humidity above 100%, which radiosondes can report in cloud, is kept in the level as recorded and taken as 100%.
- Between levels the sounding works as for any other. The temperature and humidity are
linear, and the pressure is hydrostatic (as the atmosphere page
explains). The wind is interpolated by its speed and direction. Pass
WindInterpolation::Componentsto interpolate its east and north parts instead, as RocketPy does. Above the top level the standard atmosphere continues, and the air is marked extrapolated.
An example
crates/hpr/examples/wyoming_sounding.rs
fetches the Santa Teresa sounding a launch at 15:30 UTC on 21 June 2025 would have had, in both
versions. It flies Calisto (one of the example rockets) from the
station without its parachutes. It makes these calls:
Client::new(transport, Cache::new(folder), Mode::Online)sets up the fetching. A real program passeshpr_net::Http::new()as the transport (what fetches) and keeps its cache inCache::platform_dir(). This one never uses the network: a stand-in transport answers with the two versions recorded for the tests.WyomingRequest::latest_before("72364", launch_time)picks the 12 UTC sounding, andwyoming::fetch(&client, &request, now)fetches and reads it. Setting the request’sversiontoWyomingVersion::Bufrasks for the BUFR file instead.sounding.sounding(WindInterpolation::SpeedDirection)makes the profile, andprofile.wind()its wind.hpr_sim::Environment::new(earth, profile, wind)puts both in a flight’s environment.
It prints the ground and five standard levels, with heights in meters above sea level, and each version’s second row. Then it prints the air at the pad and above it, beside the standard atmosphere. It also prints where Calisto is at apogee: east and north of the pad, negative for west and south.
Each flight starts on its own sounding’s ground. The third flight drops the BUFR file’s rows
between its ground and 1,438 geopotential meters, the height of the coded message’s second row.
Run it from a copy of the repository with
cargo run --example wyoming_sounding -p fusionspace-hpr --features net. It prints:
Santa Teresa, New Mexico (72364), 2025-06-21 12 UTC
Sounding from the University of Wyoming's radiosonde archive
freshness: Fetched
released 58 minutes before 12 UTC
coded message: 227 levels kept, 1 left out
BUFR file: 3920 levels kept, 1931 left out
level (hPa) height (m) temperature (°C) humidity (%) wind (m/s) from (°)
872 1254 28.4 31 5.7 265 the ground
850 1482 26.6 32 11.8 270
700 3165 14.6 36 2.6 215
500 5903 -5.3 63 8.2 180
250 11002 -40.1 7 13.9 260
100 16724 -73.1 13 13.9 255
second row above the ground (m) wind (m/s) from (°)
coded message 186 10.7 269
BUFR file 8 11.1 264
height above the pad (m) pressure (hPa) temperature (°C) density (kg/m³)
0 sounding 872.0 28.4 1.0022
0 standard 871.4 6.9 1.0842
1000 sounding 778.5 22.3 0.9151
1000 standard 770.3 0.4 0.9811
3000 sounding 613.5 4.9 0.7664
3000 standard 596.5 -12.6 0.7977
Calisto to apogee apogee (m above the pad) east of the pad (m) north (m)
coded message 2880.4 -408.8 -23.4
BUFR file 2854.5 -571.1 -48.4
BUFR above 1,438 m 2878.2 -426.7 -19.1
standard, calm 2844.2 -5.2 0.0
freshness: Fetched means the answer came from the transport, not the cache. That early
morning (6 a.m. local) was 21.5 °C warmer at the station than the standard atmosphere. The air
was 7.6% less dense at the ground and 3.9% less dense 3 km (9,843 ft) up. Calisto climbs 1.3%
higher in it than in the standard atmosphere with no wind. The thinner air and the wind both play
a part.
At apogee Calisto is about 400 m (1,312 ft) west of the pad, upwind. The wind blows from the west. A rocket just off the rail, still slow, turns into the wind (weathercocking) and flies that way. The calm flight’s 5.2 m (17 ft) west is Earth’s rotation. A climbing rocket is pushed west (the Coriolis effect), as on the Launch-day weather page.
The two versions put Calisto’s apogee 26 m (85 ft) apart, and the BUFR flight 162 m (531 ft) further west. Most of that is the first 186 m (610 ft) of the climb. Both start from the station’s wind at the ground, 5.7 m/s (13 mph). The coded message’s second row, 186 m (610 ft) up, is 10.7 m/s (24 mph) from the west. So its wind grows steadily over that climb.
In the BUFR file the wind is already 11.1 m/s (25 mph) 8 m (26 ft) above the ground. That’s where the rocket is slowest and turns into the wind the most. Without its rows below 1,438 geopotential meters, the BUFR flight’s apogee is 427 m (1,401 ft) west. That’s within 18 m (59 ft) of the coded message’s. This flight peaks at 2,878 m (9,443 ft), within 2.2 m (7.2 ft) of the coded message’s.
Which version is nearer the truth isn’t known.
How it is checked
The tests in crates/hpr-net/tests/wyoming.rs
use three answers recorded from the archive. Two are Santa Teresa on 21 June 2025 at 12 UTC, in
both versions. The third is Salt Lake City on 15 January 2025 at 12 UTC, a winter sounding. No
test uses the network.
-
The sounding is sampled at every kept row’s height. It gives back the recorded pressure to a relative 1e-12, the temperature to 1e-9 K, the humidity to 1e-15 and the wind to 1e-9 m/s. The test reads the expected values from the recording itself, not through the code under test, and applies the rules above on its own.
-
The rows left out are exactly those the rules leave out. They’re the last row of each coded message (no wind), and 1,931 rows of the BUFR file (the other rows of a run). The coded messages keep 227 and 241 rows, the BUFR file 3,920.
-
Every BUFR row, kept or not, lies within 0.08 hPa of the profile’s pressure at its height. The worst is 0.071 hPa. Keeping the first row of each run instead would miss by 0.093 hPa.
-
The ground’s wind is 5.7 m/s (13 mph) from 265°. It’s checked against its east and north parts worked out by hand: 5.678 m/s (12.70 mph) east and 0.497 m/s (1.11 mph) north.
-
An edited file drops each of these rows:
- a row with a missing temperature;
- one with a humidity below zero, a temperature of −999 °C, a negative wind speed or pressure, or a direction of 361°;
- one that fits but lies below the last row kept (and not merely the row before);
- and a row at the ground’s pressure.
The rows left out are listed in line order. A humidity of 103% is kept and taken as 100%, and a wind from 360° reads as from north.
-
In the three recordings, every row with a pressure, height and temperature fits the one before it. Each misses by at most 1 m (3.3 ft) beyond rounding. The most is 0 m (0 ft) in the coded messages and 0.97 m (3.2 ft) in the BUFR file.
The test works out the thickness itself, with the file’s mixing ratio (grams of water vapor per kilogram of dry air) for the humidity. Unit tests pin the check, and the worked example above, to thicknesses and allowances worked out by hand. They test 0.01 m (0.03 ft) either side of the edge.
-
Rows the chain passes by, with the rest of the answer kept:
- A pressure missing a digit, 57 hPa at 5 km (16,000 ft); the profile is the recording’s without the row.
- A height raised 850 m (2,789 ft), and a height lowered to 4,000 m (13,123 ft).
- Two bad rows in a row, and two blocks of six raised rows with a good row between them.
- A bad row after which the balloon bursts and falls back.
- A row whose vapor pressure would exceed the air’s pressure (16 hPa at 30 °C, saturated).
- A row that barely fits the row before it, alone: 854 hPa 50 m (164 ft) low and 101 hPa 95 m (312 ft) high. Also a BUFR row at 112.8 hPa 35 m (115 ft) high. The next row misses it, and a chain through it isn’t longer and fits less closely. The rows before and after it are kept.
- A row that misses the good row before it but barely fits the one below that, alone: 808 hPa raised 50 m (164 ft). Also a BUFR row at 244.2 hPa raised 35 m (115 ft). A chain could skip the good row to reach it. But the chain through the good row is longer, or as long and closer.
- A BUFR row at 150.6 hPa raised 50 m (164 ft), whose pressure is rounded to 0.1 hPa. In the coded message, 549 hPa raised 45 m (148 ft) fits within its pressures’ 1 hPa rounding and is kept.
- Blocks of bad rows that fit each other but not the good rows beside them, which are kept. The blocks are 820 and 808 hPa raised 50 m (164 ft), and 101, 100 and 99 hPa raised 100 m (328 ft). In the BUFR file they’re rows at 112.8 and 112.7 hPa raised 50 m (164 ft). They’re also two BUFR rows at 13.9 hPa lowered 50 m (164 ft), and two at 10.1 hPa lowered 60 m (197 ft). Each of those two pairs is inside a run sharing one pressure.
- The two or three rows after the ground raised 850 m (2,789 ft); the ground and the rest are kept.
- A row inserted at 870 hPa, recorded 65 m (213 ft) above the ground. The air’s thickness puts it about 20 m (66 ft) up. It misses the ground, but the next row fits the ground. A chain starting at the inserted row fits less closely. So the row is left out and the answer isn’t refused.
-
Rows kept or left out as they fit:
- With no wind, or no humidity, from 250 to 55 hPa (73 rows), every row after the gap fits and is kept. Checked across the gap instead, the next row would not fit.
- Rows falling or staying at one height at the end are left out without refusing the answer. When a row that fits and lies above follows them, the rows are left out and the row is kept. Of rows crossing back and forth over the last row kept, the first above it is kept.
- A BUFR run of three rows at one pressure whose middle is raised 100 m (328 ft) keeps its first row.
- A row at 0.1 hPa and −150 °C, 55.6 km (182,400 ft) up, fits the row below it and is kept.
-
Answers refused:
- A block of 10 rows raised 1 km (3,281 ft) is left out; 11 refuse the answer.
- In the coded message, a ground at 87.2 hPa (872 with its decimal point misplaced). Also one at 125 m (410 ft), where 1,252 m (4,108 ft) lost a digit, and one 8 hPa off. Also one 52 m (171 ft) or 80 m (262 ft) high. And a BUFR ground 34 m (112 ft) high, whose first layer is 8 m (26 ft) thick.
- A ground at 1,200 hPa, at −1,000 m (−3,281 ft) or at −150 °C. These are within the bounds, but no row above fits them.
- In the coded message, the first layer is 186 m (610 ft) thick. A ground 40 m (131 ft) high there, or at 80 °C, fits it and is kept with every row.
- With only one row after a bad ground, the ground is kept and the row left out. A row with no temperature right after a bad ground isn’t counted: the refusal names the row after it.
- Rows after a good ground that beat it. In the BUFR file they’re two rows raised 31 m (102 ft), and four lowered 35 m (115 ft). In the winter coded message they’re three raised 45 m (148 ft), and in the other, four raised 50 m (164 ft). Eleven rows raised 1 km (3,281 ft) beat it too.
- Two BUFR rows raised 20 m (66 ft) fit the ground and are kept, leaving out the three good rows no higher than them. Two BUFR rows raised 35 m (115 ft), and 10 coded-message rows raised 1 km (3,281 ft), are passed by. A chain without the ground may start only at the 11 rows after it. After 11 rows that fit nothing, the answer is refused for the gap.
-
A row raised within its allowance is kept, and leaves out the good rows just above it, which now lie below it. The tests raise one row, or a block of two or three, by 20 m (66 ft) or 35 m (115 ft). They raise or lower it by 50 m (164 ft) or 100 m (328 ft). None of these refuses an answer, and a coded message loses at most 2 other levels.
The BUFR file is sampled at every 150th row, to keep the test under a minute. It’s also sampled where a sweep of every row, run once and not in the tests, found the worst. In the BUFR file a change loses at most 8 other rows for one row. A block loses at most 10, about 50 m (164 ft) of the climb. Lowering one row, or changing its pressure by 3%, loses no other.
-
Values just past the bounds above are left out. Unit tests keep values at each bound. At the top row, temperatures of −150 and 80 °C and a wind of 300 m/s (671 mph) are kept and make a profile.
-
The request’s address is the one recorded, so a replayed answer fills the cache. A second request is answered from the cache, and offline mode answers without the network. A copy saved while the sounding was young is fetched again once it has settled.
-
An answer that isn’t the archive’s text (such as an error page) isn’t saved. With no earlier copy the request fails. With one, the earlier copy comes back, marked stale.
-
Text with no header, a missing or doubled column, or a unit other than the one required is refused. So is a row with too few or too many fields, or a field that isn’t a number. So is a first row with no date, or with a value missing. A header or a row of a million commas, and more than 100,000 rows, are refused without being read further.
-
The heights are geopotential, by the hypsometric check above. The test holds each average under 0.1% as geopotential meters, and more than 0.4% too thin as meters above sea level.
What it leaves out
- A damaged answer gets an error, or a value from what was left, on the damage the tests try: the parser is tried on cut, changed and arbitrary bytes. Which rows of a damaged page still read is a separate matter. Damaged files says what the tests cover and leave out.
- How far a station’s sounding is from the air over a launch site isn’t measured, in distance or in time.
- Which version is nearer the truth near the ground, where they differ most, isn’t known. A balloon’s first seconds of drift aren’t a steady wind either.
- A level with any value missing is left out whole, even when its other values are good.
- The check catches a gross error in a row’s pressure or height. It keeps:
-
A wrong wind or humidity. The check doesn’t use the wind, and humidity moves the thickness by only a few percent. For saturated air at 30 °C and sea-level pressure, it’s 1.6%. Only a wind below zero or above 300 m/s (671 mph) is caught.
-
A wrong temperature that keeps the thickness within the allowance, and a height error within it. On the example’s layer that’s 50 m (164 ft), more on thicker ones.
-
A row whose pressure and height are both wrong yet fit each other.
-
A wrong ground that fits the row after it, or has only one row after it. In the coded message a ground 40 m (131 ft) high, or at 80 °C instead of 28.4 °C, fits.
-
Bad rows that fit their neighbors: a block of them can be kept, and good rows beside them passed by instead. No more good rows are passed by than the block holds, and fewer unless the block fits more closely. In the coded message, 683 and 673 hPa both raised 50 m (164 ft) are kept, and 664 hPa is left out.
High in a BUFR file, rounding the pressure to 0.1 hPa widens the allowance. There four rows at 13.9 hPa lowered 50 m (164 ft) are kept, and the two good rows at 14.0 hPa before them left out.
-
- A good ground followed by bad rows that fit the rows above them is refused, as if the ground were wrong. That happens when the chain through them wins.
- A row, or a short block, kept a little too high leaves out the good rows just above it. In the tests that’s at most 2 other levels of a coded message and 10 other rows of a BUFR file (8 for one row).
- Only the archive’s comma-separated text is read, not its other formats, and there’s no list of stations to search by place.
- Only soundings from U.S. stations, which are U.S. government works, are committed as test data (the decision record).
- The Python package doesn’t fetch soundings. The command line fetches them with
hpr weather wyoming.
NOAA forecasts: GFS and RAP
Fetch NOAA’s GFS and RAP forecasts over a launch site and fly a rocket through the weather they predict.
These are the United States weather service’s own forecasts. NOAA’s National Centers for Environmental Prediction (NCEP) run two weather models whose output HPR Sim reads:
- The Global Forecast System (GFS) covers the whole Earth on a grid a quarter of a degree apart, about 28 km (17 mi).
- The Rapid Refresh (RAP) covers the contiguous United States and nearby parts of Canada and Mexico, on a grid 13 km (8.1 mi) apart. It’s started again every hour.
The simulator asks NOAA’s download server, NOMADS (NOAA Operational Model Archive and Distribution System), for a small piece of one forecast around the site. The piece arrives as a GRIB2 file, the World Meteorological Organization’s binary format for weather on a grid. The simulator reads it with its own decoder.
The result is a sounding: temperature, pressure, humidity and wind at a column of heights. The column runs from the ground up to about 31 km (102,000 ft) in GFS or 16 km (52,000 ft) in RAP. You can also download a whole GFS file and read it offline (A whole GFS file). That file’s sounding goes up to about 79 km (259,000 ft).
This page is for anyone who wants a flight in a named NOAA model’s forecast. Open-Meteo’s choice of model is on Launch-day weather, and a weather balloon’s measurement on Weather-balloon soundings.
The 2.2e-16 is one rounding in the last binary digit. The profile gives back those values, interpolated to the site, at every level it keeps. CI checks eight messages of the whole GFS file, and 182,443 points of the four RAP fields, packed as JPEG 2000 images as in RAP’s whole files. The whole GFS file’s profile at Spaceport America is the recorded cut’s to 1.04e-7, by a test skipped in CI, since CI doesn’t have the file. The tests replay two recorded answers. The live connection to NOMADS isn’t tested in CI.
The pad sits on the model’s smoothed ground: at Spaceport America 1,476 m (4,843 ft) in GFS and 1,429 m (4,688 ft) in RAP. Open-Meteo gives 1,400 m (4,593 ft), as in Launch-day weather’s example.
Code: hpr_net::nomads (API reference), with the decoder in
hpr_io::grib2 (API reference). It was written for
the third weather increment. Later increments extended it
to whole GFS files and
to JPEG 2000. It needs the net feature of the hpr crate.
The choices are in three decision records:
What the simulator asks for
A forecast comes from a run: the model starts from the weather observed at one hour, its cycle, and steps forward. Each forecast hour is the forecast for that many hours after the cycle. Times are in UTC (universal time, the time at Greenwich) and given in seconds since 1 January 1970 UTC (Unix time). Pressures are in hectopascals (hPa, 100 Pa; sea-level pressure is about 1,013 hPa). A pressure level is a height named by the pressure there.
| model | grid | runs start | forecast hours | pressure levels asked for |
|---|---|---|---|---|
| GFS | 0.25° of latitude and longitude, the whole Earth | every 6 hours (00, 06, 12, 18 UTC) | every hour to 120, then every third hour to 384 | 28, from 1,000 to 10 hPa, about 31 km (102,000 ft) |
| RAP | 13 km (8.1 mi), on a Lambert conformal map of the contiguous United States and nearby parts of Canada and Mexico (not Alaska or Hawaii) | every hour | every hour to 21; to 51 only from the 03, 09, 15 and 21 UTC runs | 37, from 1,000 to 100 hPa every 25, about 16 km (52,000 ft) |
NomadsRequest::new(latitude, longitude, model, cycle, forecast_hour) says what to ask for, and
it can’t fail. The request’s url(), and so nomads::fetch, refuse a cycle the model doesn’t run
or a forecast hour its run doesn’t have. NomadsModel::has_forecast_hour(cycle_hour, hour) says
which hours a run has.
The simulator picks neither for you. To fly at 18 UTC, ask for GFS’s 00 UTC run at hour 18, say, or RAP’s 12 UTC run at hour 6. A site outside the model’s grid is refused once the answer arrives.
The request’s address is NOMADS’ grib filter. It’s a web form that cuts chosen variables, levels and a box of latitude and longitude out of a run’s file. The simulator asks for a box 0.3° each way around the site. The box holds 9 GFS or about 25 RAP grid points, among them the four around the site. That’s about 28 KB for GFS and 40 KB for RAP.
The box’s edges are written to hundredths of a degree, worked out from the site rounded to 5 decimals, about 1 m (3.3 ft). Your program keeps the site in radians and turns it back into degrees, which can change its last digits. The rounding absorbs that: a site given to 8 decimals or fewer asks for the same box and finds its saved answer. The simulator asks for:
| variable | where |
|---|---|
| geopotential height | the ground (the model’s terrain) and each pressure level |
| pressure | the ground |
| temperature and relative humidity | 2 m (6.6 ft) above the ground and each pressure level |
| wind, as two components | 10 m (33 ft) above the ground and each pressure level |
GRIB2 fixes each variable’s unit, so there are no units to check. The filter also sends the ground’s own (skin) temperature, since the request asks for temperature at the surface. The simulator decodes it but doesn’t use it. With the skin temperature, a cut holds 147 GFS or 192 RAP messages, one variable on one level each. A cut of more than 1,000 is refused unread.
The answer goes through hpr-net’s cache (Online data and the cache).
nomads::fetch(&client, &request, now) takes the time now, in Unix seconds, to judge how fresh a
saved copy is. A run’s files don’t change once NOAA writes them, so a saved copy stays fresh for
30 days.
NOMADS keeps only recent runs. On September 30, 2026 its grib filters listed 10 days of GFS runs and 2 of RAP. So a past launch needs a copy saved while NOMADS still had it. A run appears on NOMADS some hours after its start time. NOMADS limits how often you can ask, so keep to that.
Offline mode answers from the disk only. Only an answer that decodes, makes a sounding, and is for the run and hour asked for is saved. So a bad answer can’t replace a good copy.
NCEP’s forecasts are U.S. government works, free of copyright. Every answer carries the credit “Forecast data from NOAA/NCEP (GFS, RAP), via NOMADS”. Show it wherever you show the forecast.
How the answer becomes a sounding
Between grid points. A model gives each value only at its grid points. The simulator takes the four around the site and blends them bilinearly. Each point’s weight grows as the site nears it, in the grid’s own rows and columns. The four weights add up to 1.
A cut is refused and not saved when its grid steps and projection aren’t the model’s. GFS’s grid has 0.25° steps, and RAP’s has 13,545 m (44,439 ft) cells about 265° E.
The ground is at the model’s terrain height at the site. It takes the surface pressure, the 2 m (6.6 ft) temperature and humidity, and the 10 m (33 ft) wind. Putting the 10 m (33 ft) wind at the ground makes it the wind on the launch rail. The profile doesn’t jump from there to the lowest level’s wind above it (a Loft lesson: a forecast profile that stepped at its lowest level). Open-Meteo’s page does the same.
Levels below the ground are left out. The models give every level everywhere, inventing values beneath high ground. A level is kept only when its pressure is below the ground’s and its height is above the ground. A level with a value missing at any of the four grid points is left out too.
At Spaceport America, about 1,400 m (4,593 ft) up, six levels are underground in each model. They’re 1,000 to 850 hPa in GFS and 1,000 to 875 hPa in RAP. GFS keeps 22 of its 28 levels and RAP 31 of its 37. The profile lists every level it left out, and why.
Heights. GRIB2 gives heights in geopotential meters. The simulator converts them to heights above sea level at the site’s latitude. It uses the World Meteorological Organization’s formula (WMO-No. 8 eq. 12.16, as the atmosphere page explains).
The model’s terrain height is also given in geopotential meters and converted the same way. At this latitude that adds about 2 m (6.6 ft): GFS’s 1,474.4 gpm becomes 1,476.4 m (4,844 ft). Were the model’s terrain really a height above sea level, as for Open-Meteo’s elevation, the ground would sit about 2 m (6.6 ft) too high.
RAP’s winds are turned to east and north. RAP’s map is a cone unrolled flat (a Lambert conformal projection). RAP gives each wind as two components along its map’s rows and columns, not east and north.
“Up” on that map points true north only along 95° W, one line of longitude. Elsewhere the lines of longitude lean towards the map’s center. So the map’s “up” is turned from true north by an angle that grows with the distance from 95° W:
Here is the site’s longitude, and 25° N is where RAP’s cone touches the Earth. At Spaceport America, 106.97° W (253.03° E),
so the map’s “up” points 5.06° west of true north. The simulator turns the wind by that angle, with and the components along the map’s rows and columns:
Left unturned, a 20 m/s (45 mph) wind would be about 1.8 m/s (4.0 mph) off sideways (20 m/s × sin 5.06°). The components are blended between grid points first and turned once, at the site. Across one 13 km (8.1 mi) cell, changes by about 0.06°. GFS gives its winds east and north already.
Humidity is taken as relative to liquid water, as for Open-Meteo. If NCEP’s models give it relative to ice at cold levels, the density there moves by under 0.1% (Launch-day weather explains the bound). A humidity above 100% is kept in the level as given and taken as 100% in the sounding.
Between levels the sounding works as for any other: the temperature and humidity are linear,
and the pressure is hydrostatic. The wind is interpolated by its speed and direction. Pass
WindInterpolation::Components to interpolate its east and north parts instead, as
RocketPy does.
An example
crates/hpr/examples/nomads_forecast.rs
fetches both models’ forecasts for Spaceport America at 18 UTC (noon local) on 30 September 2026.
They’re GFS’s 00 UTC run at hour 18 and RAP’s 12 UTC run at hour 6. It flies Calisto (one of the
example rockets) through each, without its parachutes. It makes
these calls:
Client::new(transport, Cache::new(folder), Mode::Online)sets up the fetching. A real program passeshpr_net::Http::new()as the transport (what fetches) and keeps its cache inCache::platform_dir(). This one never uses the network: a stand-in transport answers with the two files recorded for the tests.NomadsRequest::new(latitude, longitude, NomadsModel::Gfs, cycle, 18)says what to ask for (andNomadsModel::Rapfor RAP), andnomads::fetch(&client, &request, now)fetches it and reads it at the site. Here it reads the two recorded forecasts, as a real program would fetch them.profile.sounding(WindInterpolation::SpeedDirection)makes the sounding, andsounding.wind()its wind.hpr_sim::Environment::new(earth, sounding, wind)puts both in a flight’s environment.
It prints each model’s ground and the standard levels 850, 700, 500, 250 and 100 hPa above it. Heights are in meters above sea level. The wind’s direction is where it blows from, clockwise from north. Then it prints where Calisto is at apogee: east and north of the pad, negative for west and south.
Each flight starts on its own model’s ground, and the standard-atmosphere flight on GFS’s.
Run it from a copy of the repository with
cargo run --example nomads_forecast -p fusionspace-hpr --features net. It prints:
Spaceport America, 2026-09-30 18 UTC
Forecast data from NOAA/NCEP (GFS, RAP), via NOMADS
freshness: Fetched
GFS: run of 00 UTC, hour 18: 22 levels kept, 6 left out
RAP: run of 12 UTC, hour 6: 31 levels kept, 6 left out
RAP's winds turned by -5.06° to east and north
GFS level (hPa) height (m) temperature (°C) humidity (%) wind (m/s) from (°)
848 1476 19.3 42 5.5 242 the ground
700 3077 2.8 90 7.3 262
500 5720 -12.9 55 17.0 246
250 10822 -32.7 1 45.8 230
100 16741 -70.6 17 17.7 209
RAP level (hPa) height (m) temperature (°C) humidity (%) wind (m/s) from (°)
854 1429 16.9 70 3.7 246 the ground
850 1463 16.1 67 4.4 249
700 3076 2.6 77 8.1 272
500 5722 -12.0 39 20.5 242
250 10822 -32.6 1 42.9 231
100 16739 -70.8 10 13.0 211
Calisto to apogee apogee (m above the pad) east of the pad (m) north (m)
GFS 2875.5 -258.0 -133.9
RAP 2874.1 -208.6 -85.2
standard, calm 2860.0 -5.2 0.0
freshness: Fetched means the answer came from the transport, not the cache. A second call within
30 days would say Cached. GFS has no 850 hPa row because its ground, at 848 hPa, is above that
level.
The two models agree closely aloft: at 500 hPa their heights are 2 m (6.6 ft) apart and their temperatures 0.9 °C. Near the ground they differ more. GFS’s ground is 47 m (154 ft) higher and 2.4 °C warmer. Its 10 m (33 ft) wind is 1.8 m/s (4.0 mph) stronger.
Calisto climbs 14–16 m (46–52 ft) higher in either forecast than in the standard atmosphere with no wind. At apogee it’s west-southwest of the pad, upwind. The wind at the ground blows from the west-southwest (242° and 246°). A rocket just off the rail, still slow, turns into the wind (weathercocking) and flies that way.
GFS’s stronger wind near the ground turns Calisto further into the wind. Calisto ends 49 m (161 ft) further west and 49 m (161 ft) further south than in RAP’s forecast. How much of that comes from the ground’s wind and how much from the winds aloft isn’t separated.
The calm flight’s 5.2 m (17 ft) west is Earth’s rotation, as on the Launch-day weather page. A climbing rocket is pushed west (the Coriolis effect). Which model is nearer the air Calisto would have met isn’t measured.
Whole files offline
A whole downloaded GFS file reads with no network. Fields packed as JPEG 2000 images, as RAP’s whole files are, read too, though no whole RAP file has been tried.
A whole GFS file
Instead of asking NOMADS for a cut, you can download a whole GFS file and read it offline. Do it, for example, before driving out to a launch with no signal. NOMADS keeps the most recent runs, and NOAA’s open data bucket on Amazon’s cloud older ones. A file holds one run’s forecast for one hour over the whole Earth, about 550 MB:
https://nomads.ncep.noaa.gov/pub/data/nccf/com/gfs/prod/gfs.20260930/00/atmos/gfs.t00z.pgrb2.0p25.f018
https://noaa-gfs-bdp-pds.s3.amazonaws.com/gfs.20260930/00/atmos/gfs.t00z.pgrb2.0p25.f018
Here 20260930/00 and t00z are the run (00 UTC on 30 September 2026) and f018 the forecast
hour. Only the 0.25° files (pgrb2.0p25) read. The smaller 0.5° and 1° files are refused. The
command line reads the file as it reads a saved cut, with the site you want:
hpr weather gfs --latitude 32.99 --longitude -106.97 --cycle 2026-09-30T00Z --hour 18 --from gfs.t00z.pgrb2.0p25.f018 --output profile.json. It took about a third of a second on a Mac.
NCEP packs whole files more tightly than the grib filter’s cuts, with GRIB2’s complex packing. The values are split into groups, each with its own smallest value and number of bits. Most fields store the differences between neighboring values rather than the values (spatial differencing).
GRIB2 numbers these packings as templates 5.2 and 5.3. The simulator’s decoder reads both. A whole file also holds 743 messages where a cut holds 147:
- Totals and averages over a time span, such as the rain that fell in the last six hours. The simulator reads these, but the profile doesn’t use them.
- Values for a layer between two heights, such as the humidity from the ground to mid-air. The simulator skips these, because they don’t belong to one level.
- Every pressure level up to 0.01 hPa, so the profile goes on above 10 hPa, where a cut stops. In the profile the simulator writes from this file, the 0.01 hPa level is 79.2 km (259,800 ft) above sea level. The highest levels are near the top of the model, and nothing here checks how good its forecast is there.
The grid runs all the way round the Earth, so the simulator joins its last column to its first. A
site between 359.75° and 0° of longitude still has four grid points around it. That’s checked by
a_grid_round_the_earth_wraps_its_columns in crates/hpr-net/tests/nomads.rs.
For that run and hour at Spaceport America, the whole file’s profile has the cut’s 22 levels. Each of their values is within 1.04e-7 of the cut’s, relatively, and 13 more levels sit above them. Why they differ at all: NOMADS packs its cuts again in fewer bits. Read with ecCodes, without HPR Sim, the two files already differ by up to 2.4e-6, relatively, at the cut’s grid points.
Files in JPEG 2000
Some of NCEP’s files compress each field as a picture. The packed whole numbers become a grayscale
image, stored in the JPEG 2000 image format (GRIB2’s template 5.40). RAP’s whole pressure-level
files are packed this way. The simulator decodes them with
hayro-jpeg2000, a JPEG 2000 decoder written in Rust.
Then it turns each whole number into a value, as it does for the other packings.
A lossless image gives back exactly the numbers packed into it. A lossy one gives back approximations. The simulator reads lossless images of up to 21 bits a value, coded the way NCEP codes them. The four RAP fields below have 6 to 16 bits. Anything else is refused, naming what it is: a lossy image, one with more bits, or one coded some other way.
The limit of 21 bits comes from the decoder’s arithmetic. It works in 32-bit floats, which keep whole numbers exact only up to 16,777,216. Its intermediate sums run about 8 times larger than the values. A field with a bitmap is stored as one row of its values. The decoder takes at most 60,000 in a row, so such a field of more values is refused too.
A picture has to be decoded whole, so reading one point decodes the whole field. Read all the
values you need in one go
(Field::values_at), as hpr weather does.
A whole RAP file through hpr weather rap --from hasn’t been tried. No whole RAP file was
downloaded, only four of its fields (How it is checked).
How it is checked
The tests in crates/hpr-net/tests/nomads.rs
use the two files the example reads. They were recorded unchanged from NOMADS’ grib filter on
30 September 2026 for Spaceport America (32.99° N, 106.97° W). One is GFS’s 00 UTC run at hour 18
(27,586 bytes). The other is RAP’s 12 UTC run at hour 6 (40,026 bytes), both for 18 UTC.
No test uses the network.
The expected values come from ecCodes 2.49.0, the European Centre
for Medium-Range Weather Forecasts’ decoder.
validation/oracles/grib2/eccodes_dump.py
ran it on the same files, and its output is committed as
crates/hpr-net/tests/fixtures/nomads-eccodes.json. The tests read that file directly, not
through the decoder under test.
Each line gives what was measured, then the bound the test holds it to. All the measurements below were made on macOS. CI runs the same tests with the same bounds on Linux and Windows.
-
The cuts hold 147 GFS messages (9 grid points each) and 192 RAP messages (25 grid points each). Each names the same variable, level and times as ecCodes. All 6,123 values are within 2.2e-16 of ecCodes’, relatively (bound 2.5e-16). That’s one rounding: ecCodes multiplies by an inexact where HPR Sim divides by an exact . Decoding a value uses only basic arithmetic, which is the same on every platform.
-
Every grid point’s position is within 5.7e-14° of ecCodes’ (bound 1e-12°, since other platforms’ maths libraries can differ in the last digits). The four points’ weights add up to 1, and the blend of their positions is the site, to 1e-5°.
-
RAP’s wind turn is , −5.06° at the site. The positions ecCodes gives two neighboring grid points show the map’s rows bearing from north, to 2.2e-6° (bound 3e-6°). That pins the sign. GFS’s winds aren’t turned.
-
The sounding is sampled at the ground and every kept level’s height. It gives back ecCodes’ values interpolated to the site. The pressure is within a relative 1e-13, the temperature within 1e-11 K and the wind within 1e-11 m/s. Each level holds the humidity within 1e-14. The six underground levels of each model are the ones left out.
-
The heights are geopotential meters. From 500 hPa up, each layer’s thickness matches what the hypsometric equation gives it, with the file’s heights read as geopotential meters. On average the match is to −0.002% (GFS, 15 layers to 10 hPa) and −0.08% (RAP, 16 layers to 100 hPa). Read as meters above sea level, the layers would be 0.63% and 0.51% too thin. The test holds each average to those figures as rounded.
-
The two models read alike for the same hour. Their 2 m (6.6 ft) temperatures are within 3 K of each other. Their 500 hPa heights are within 30 m (98 ft), and their 500 hPa winds within 5 m/s (11 mph). That’s a guard against a misread file, not a check of either forecast.
-
The request’s address is the one recorded, so a replayed answer fills the cache. A second request is answered from the cache. Offline mode answers without the network 40 days later, marked stale.
-
Wrong answers aren’t saved. A RAP request answered with a GFS cut is refused. So is a cut of another run or hour than the one asked for. A GFS cut whose steps are changed to 0.5° still reads, but isn’t GFS’s grid, so it would be refused too.
-
A humidity over 100% is kept in the level and taken as 100% in the sounding (a unit test).
-
A level whose field has no value at one of the four points around the site is left out as missing data. A hostile cut of more than 1,000 fields is refused before it’s read (a real one has 147 or 192).
-
A whole GFS file was checked too (the 00 UTC run of 30 September 2026 at hour 18, 550 MB, not committed):
check where it runs measured bound every one of its 746,770,303 values against ecCodes’, relatively a script, run once outside CI 4.4e-16 none its 24,642,017 grid points without a value are ecCodes’ the same script all the same all eight whole messages cut from it, one of each kind: which field each is, its points without a value, and every 997th value CI 4.4e-16 or less 4.5e-16 the same eight messages: two sums over all their values CI within the bound 1.35e-15 of the terms’ sizes hpr weatherwrites the cut’s profile from it, relativelya test skipped in CI, which doesn’t have the file 1.04e-7 1.1e-7 The script is
validation/oracles/grib2/whole_file.py. Its record, with ecCodes’ survey of the file, isgfs-whole-file.json. The sums catch a value decoded wrong anywhere in a message. A value off by a single packing step would move a sum at least 23,000 times more than the bound allows. -
Complex packing is checked in CI on the recorded GFS cut, packed again by ecCodes with complex packing and both orders of differencing (
repack.py). The repacked cut goes through every check above. Its 1,323 values match ecCodes’ to one rounding (bound 2.5e-16), and its profile matches at every level. From it,hpr weatherwrites a profile within 6.9e-8 of the cut’s, relatively (bound 7e-8). -
JPEG 2000 is checked in CI on four fields cut unchanged from RAP’s run of 00 UTC, 30 September 2026. Two are the 500 hPa temperature on RAP’s 13 km (8.1 mi) grid (151,987 points) and on a coarser one (10,152). The other two are the heights of cloud base and cloud top. They have a value only where there’s cloud (6,824 and 434 points of 10,152).
Their 182,443 points match ecCodes’ reading: which points have no value, and the plain sum of every value. So do a sum weighted by each point’s position, which catches a value in the wrong place, and every 13th value alone. The test is
rap_messages_in_jpeg2000_decode_to_eccodes_valuesincrates/hpr-io/tests/grib2_gfs.rs.validation/oracles/grib2/whole_file.py cut-rapwrites ecCodes’ reading (the decision record on JPEG 2000 packing). -
A damaged JPEG 2000 image is refused, never a crash.
damaged_jpeg2000_never_panicsincrates/hpr-io/src/grib2/tests.rschanges bytes of one at random, 256 times in CI. Another test cuts one short at every length. -
The simulator refuses a site outside the file’s grid and text that isn’t GRIB2. It also refuses a cycle the model doesn’t run and a forecast hour its run doesn’t have. The decoder’s own tests build small files by hand. They pin the unpacking formula, bitmaps (masks of grid points with no value), both kinds of grid and complex packing’s groups. They also pin missing values, both orders of differencing, and refusals of every other kind of file by name.
What it leaves out
- A lossy JPEG 2000 image, one of more than 21 bits a value, or one coded otherwise than NCEP codes is refused by name. So is a bitmap field of more than 60,000 values (Files in JPEG 2000).
- Whole RAP files’ packing is read, but a whole file hasn’t been run through
hpr weather. - GFS’s coarser 0.5° and 1° files are refused: the simulator checks for the 0.25° grid.
- Nothing here checks a forecast’s accuracy against the weather that came.
- Each request is for one forecast hour, with no interpolation between hours.
- RAP stops at 100 hPa, about 16 km (52,000 ft), and GFS as asked for here at 10 hPa, about 31 km (102,000 ft). A whole GFS file goes on to 0.01 hPa, about 79 km (259,000 ft). The layer thickness check above stops at 10 hPa.
- Above the top level, the sounding continues as the standard atmosphere, shifted to pass through the top level’s temperature and pressure. It keeps the top level’s share of water vapor, capped where the air saturates. The wind holds the top level’s wind. The air and wind there are both marked extrapolated. A flight above 16 km (52,000 ft) in RAP’s forecast is flying on that guess.
- A kept level is blended from the four grid points even where one of them has that level underground. In the RAP cut, 850 hPa takes 13% of its weight from a point whose ground is at 845.8 hPa. The effect here is about 0.02 K, and larger in steep terrain.
- The pad is placed on the model’s smoothed terrain, not the site’s real height. The simulator doesn’t shift the profile to the real ground.
- Whether NCEP gives humidity over ice at cold levels is unsettled here. The difference moves the density by under 0.1%.
- Nothing tells you which runs NOMADS still holds before you ask.
- The Python package doesn’t fetch NOAA’s forecasts. The command line fetches them with
hpr weather gfsandrap.
A launch site’s elevation
Get a launch site’s elevation above sea level from Open-Meteo or a GeoTIFF of your own, so a flight starts in the right air.
This page covers two ways to get a launch site’s elevation, its altitude above sea level (the field elevation a club lists). The first looks it up from Open-Meteo, a free weather and terrain service. The answer is saved, so the same lookup works later with no network, on a field with no signal. The second reads it from an elevation file you have, a GeoTIFF (below).
The page is for anyone who needs a site’s height to start a flight at the right air pressure and
density. There’s no hpr command for either way yet: a Rust program calls the
library.
The example below shows the air 12.8% thinner over 1,400 m (4,593 ft). The recorded heights are whole meters; Open-Meteo doesn’t document its rounding. The tests replay two saved answers and never contact Open-Meteo. The live service was contacted by hand, over an encrypted (HTTPS) connection, to record them. So a change in Open-Meteo’s answers would show only when a program runs, as a refused answer.
Code:
- The online lookup is
hpr_net::elevation(API reference), written for the second launch-site increment. It needs thehprcrate’snetfeature. The choices are in the decision record on Open-Meteo’s elevation through the cache. - The file reader is
hpr_io::geotiff(API reference), written for the GeoTIFF increment. Thehprcrate re-exports it ashpr::hpr_io::geotiff, with no feature needed. The choices are in the decision record on a site’s height from a user’s GeoTIFF.
The weather over a site is on Launch-day weather, and the compass’s offset from true north on The magnetic field and declination.
What the simulator asks for
Open-Meteo’s elevation service (its documentation) takes a list of places, each a latitude and longitude in degrees. It answers one height for each, in the same order. The simulator asks for one place or up to 100 in one request, the service’s limit. Here’s a request recorded for the tests, for Spaceport America, the Dead Sea and a point in the open Atlantic:
| what | value |
|---|---|
| address | https://api.open-meteo.com/v1/elevation |
| the request’s places | ?latitude=32.99,31.5,0&longitude=-106.97,35.5,-30 |
| its answer | {"elevation":[1400.0, -427.0, 0.0]} |
| a saved answer stays fresh for | a year |
A request can name another server instead (ElevationRequest::endpoint), for a copy of
Open-Meteo you run yourself.
The simulator writes each coordinate to 5 decimal places, about 1 m (3.3 ft) on the ground. Your program keeps a place in radians and turns it back into degrees, which can change its last digits. The rounding allows for that: a place given to 8 decimals or fewer still finds its saved answer.
A saved answer is found again only by the same request: the same places, in the same order. If you look up three club fields in one request at home, a later lookup of one of them alone is a new request. Offline, that lookup fails. To use a site offline, look it up alone, or repeat the exact list you used before.
The terrain model
The heights come from the Copernicus DEM GLO-90, a digital elevation model (DEM): a grid of heights over the whole Earth. The European Union’s Copernicus program made it from radar satellites.
Its points are 3 seconds of arc apart north to south, about 93 m (305 ft). East to west they’re 93 m (305 ft) apart at the equator and 60 m (197 ft) at 50° of latitude. Further north and south the spacing widens in steps (product handbook, issue 5.0, Table 3, page 15). The model is a digital surface model: its heights include buildings and vegetation (the dataset’s readme).
Its stated accuracy is under 4 m (13 ft) for 90% of points (handbook, Table 1, page 10). That’s a mean over the world outside Antarctica and Greenland, and the makers warn it varies from place to place. Of the 16,363 tiles there, each about a degree across, 184 (1.1%) are worse than 10 m (33 ft). The handbook’s Table 12, page 31, prints 0.9%, but as a share of all tiles, Antarctica and Greenland included.
The ground doesn’t move, so a saved answer stays fresh for a year. Open-Meteo’s forecast for Spaceport America (Launch-day weather) gives the same ground height, 1,400 m (4,593 ft).
What the simulator refuses
The simulator refuses an answer with another number of heights than places asked for, or with a height that isn’t a number. It also refuses a height outside −1,000 m (−3,281 ft) to 9,000 m (29,528 ft). The lowest land, by the Dead Sea, lies a little over 400 m (1,312 ft) below sea level. The highest, Everest’s summit, is 8,849 m (29,032 ft) above it. So a height outside the simulator’s range is a broken answer, such as the value −32,768 that some terrain files use for “no data”.
An answer the simulator refuses is never saved, as on Online data and the cache. When Open-Meteo itself refuses a request, it answers with HTTP status 400 and a reason. The HTTP transport reports a failed fetch naming the status, without Open-Meteo’s reason. The simulator checks each place’s latitude and longitude before asking, so that’s rare.
What the height means
The height is above mean sea level. The model’s heights are measured from EGM2008, a worldwide model of the geoid. That’s the shape the sea’s surface would take if it were still, extended under the land (product handbook, section 1.2.1, page 13). A height above EGM2008 is the height above sea level the atmosphere is looked up by (Atmosphere: the height datum).
The sea has no tiles in the model and reads 0 m (0 ft), so a height of 0 can also mean “no data”. The Dead Sea reads −427 m (−1,401 ft): its surface when the radar satellites measured it, between December 2010 and January 2015 (handbook, page 30). The lake has fallen since.
A flight’s launch site takes its height above the WGS 84 ellipsoid instead (its ellipsoidal height). The two differ by the geoid undulation , the height of sea level above the ellipsoid there. Around the world, runs between about −107 m (−351 ft) and +86 m (+282 ft).
A geoid calculator gives for a place: GeographicLib’s GeoidEval gives EGM2008’s −23.85 m (−78.2 ft) at Spaceport America (32.99° N, 106.97° W). Then:
-
If you know , place the site with
Geodetic::from_degrees(latitude, longitude, H + N), where is the height from this page. Then give the flight’s environment withEnvironment::standard(site)?.with_geoid_undulation_m(N). At Spaceport America, = 1,400 m (4,593 ft) and = −23.85 m (−78.2 ft), so the site’s ellipsoidal height is 1,376.15 m (4,514.9 ft). -
If you don’t, place the site at and leave at 0, as the example below does. The atmosphere still sees the right height above sea level, so the air, the drag and the flight are right. The site’s place in space is off by . That offset moves gravity by about 3×10⁻⁴ m/s² per 100 m (328 ft), 0.003% (normal gravity’s height term).
A flight exported as KML keeps its heights above sea level, which stay right. The GeoJSON export’s heights are above the ellipsoid, and are off by .
An example
crates/hpr/examples/site_elevation.rs
looks up the three places above in one request. It makes these calls:
Client::new(transport, Cache::new(folder), Mode::Online)sets up the fetching. The transport is what fetches (Online data and the cache). A real program passeshpr_net::Http::new(), and keeps its saved answers inCache::platform_dir(), the system’s usual folder for them. This one never uses the network: a stand-in transport gives the answer recorded for the tests.ElevationRequest::new(places)says what to ask for. Thenelevation::fetch(&client, &request, now)fetches the heights and saves them;nowis the time, in seconds since 1 January 1970. Each height comes back with its place, asheight_msl_m, the height above mean sea level.- The same
elevation::fetcha day later, through a client inMode::Offlinewhose transport has no network, answers from the saved copy. Ussa76::standard().air(height)gives the standard atmosphere (the 1976 US Standard Atmosphere) at each height.Environment::standard(site)puts a flight’s start on the first place, Spaceport America.
Run it from a copy of the repository with
cargo run --example site_elevation -p fusionspace-hpr --features net. It prints:
Elevation data by Open-Meteo.com (CC BY 4.0), from the Copernicus DEM GLO-90. © DLR e.V. 2010-2014 and © Airbus Defence and Space GmbH 2014-2018 provided under COPERNICUS by the European Union and ESA; all rights reserved
first lookup: Fetched; offline a day later: Cached, the same heights: true
place lat (°) height (m) pressure (hPa) density / sea
Spaceport America, New Mexico 32.99 1400 856.02 0.872
the Dead Sea (its surface) 31.50 -427 1065.61 1.042
the open Atlantic 0.00 0 1013.25 1.000
A flight from Spaceport America, New Mexico starts 1400 m above sea level, at 856.02 hPa.
The first line is the credit Open-Meteo’s license and the terrain model’s ask for.
Show it wherever the height is shown. The column density / sea is the air’s density as a
fraction of sea level’s. Fetched and Cached say where an answer came from
(how long a copy stays fresh).
At Spaceport America’s 1,400 m (4,593 ft), the standard air is about 13% thinner than at sea level. So the drag at the same speed and drag coefficient is about 13% lower.
How it is checked
The tests in crates/hpr-net/tests/elevation.rs
replay two answers recorded from the service on 1 October 2026 (UTC). One is for Spaceport America
alone and one for the three places above. The tests read the expected heights from the recordings
themselves, not through the code being tested, and check that:
- a lookup gives each recorded height exactly, in order, each with the place asked for, and with the credit line;
- a second lookup online, inside the year, is answered from the saved copy without a fetch;
- offline, with a transport that fails the test if it’s ever called, the same lookup gives the same heights;
- that offline copy is still fresh an hour later and marked stale a year later;
- offline, a place never looked up is an error naming its address;
- an answer with no heights is refused and not saved, and a later good answer is saved;
- when an answer that isn’t JSON arrives after the year, that good copy comes back, marked stale with the reason;
- a saved copy the simulator would refuse, with a height of −32,768 m (−107,507 ft), is an error offline, naming the height;
- online, that copy is fetched again and replaced;
- a place turned into radians and back, which changes its last digits, finds its saved answer offline.
The code’s own tests check the address the simulator builds, for one place and three. They check that the address is the same after a trip through radians, for every longitude in steps of 0.01°. It’s the same, too, for 720,000 values given to 6 or 8 decimals, the 6-decimal ones all sitting on a rounding half step.
They check that the simulator refuses a request with no places, with 101, or with a bad server address. They check that it refuses a latitude or longitude out of range or not a number, and names the place, counting from 0. They also check the reader takes negative heights and the range’s edges, and refuses each kind of broken answer above.
What it leaves out
- A damaged answer or GeoTIFF gets an error, or a value from what was left, on the damage the tests try: each reader is tried on cut, changed and arbitrary bytes. Damaged files says what the tests cover and leave out.
- The command line has no elevation command yet, and
hpr simdoesn’t look a site up. A program calls the library and passes the height on. - There’s no geoid model. The height is above sea level, and turning it into a height above the ellipsoid needs the undulation , which you give (above).
- Nothing compares the model’s heights with surveyed ones. The 4 m (13 ft) is the makers’ statement.
- The height is a surface’s, not the ground’s. Over a tree line or buildings it can sit meters above the pad. For a pad cut out of forest, use a surveyed height.
- Each place gets one number: the model’s height there, at about 90 m (295 ft) spacing. A pad on a hill or beside a cliff can sit meters off it.
From an elevation file of your own
Most DEMs are published as GeoTIFF files: an image whose pixels are heights. Tags in the file say where on Earth each pixel lies (the OGC GeoTIFF Standard 1.1). The USGS publishes the United States this way, free and in the public domain, through its 3D Elevation Program:
- Its 1-arc-second tiles, with heights about 30 m (98 ft) apart, are what the simulator is tested on. Its 1/3- and 1/9-arc-second tiles use the same latitude and longitude grid, but none has been tried.
- Its 1 m (3.3 ft) files are on a map projection (UTM) and are refused. GDAL’s free
gdalwarptool converts them first. - Copernicus and NASA publish the world as GeoTIFFs too; no file of theirs has been tried.
Reading your own file
- Bring the reader in:
use hpr::hpr_io::geotiff::ElevationRaster;. - Read the whole file into memory:
let bytes = std::fs::read(path)?;. ElevationRaster::parse(&bytes)reads its tags.info()holds what they say: the size, the corner and pixel size in degrees, the CRS and the sample type. It also holds the scale and offset, the unit and whether the file states it (vertical_unit_stated), the vertical datum’s code (vertical_crs_epsg) and the nodata value.height_at(latitude_deg, longitude_deg), in degrees, givesResult<Option<f64>, GeoTiffError>:Ok(Some(height))in meters,Ok(None)where the file has no data, or an error from the table below.- For many places,
values_at(&[(lat, lon), …])reads them in one pass. It gives aVecwith oneResult<Option<f64>, GeoTiffError>per place, in order. Each is the raw stored value, not meters:info().meters(value)applies the scale, offset and unit.
The API reference shows the same steps as a short program that CI compiles and runs. The height is the value of the pixel the place falls in, as GDAL gives it. There’s no smoothing between pixels, so on a 1-arc-second grid it’s the ground within about 20 m (66 ft) of the site. A lookup decodes only the tile or strip of the file that holds the place, so it adds about one tile’s memory to the file’s.
| error | from | means |
|---|---|---|
Outside | a lookup | the place is off the file; the message names the file’s edges |
Location | a lookup | the latitude is past ±90° or a number is not finite |
Unsupported | parse | the file uses something HPR Sim doesn’t read (the table below); the message names it and, where there is one, the GDAL command that converts it |
Missing, Malformed | parse; rarely a lookup | the file lacks a tag a GeoTIFF needs, or holds one the standard doesn’t allow |
TooLarge | parse, values | a tile is larger than 256 MiB decoded; for values, which reads every pixel, the whole raster is past 2²⁸ pixels |
Tiff | any | the image itself can’t be decoded |
What it reads
You rarely need this table: a USGS 1-arc-second tile reads as it comes. It’s for checking an odd file.
| what | read | refused |
|---|---|---|
| the grid | latitude and longitude in degrees from Greenwich, on a datum within a few meters of WGS 84: WGS 84 itself, NAD83 and its updates, ETRS89, GDA94, GDA2020, NZGD2000, JGD2011, SIRGAS 2000 and CGCS2000 (the EPSG codes are NEAR_WGS84 in the API) | a map projection such as UTM, or an older datum such as NAD27, tens to hundreds of meters from WGS 84: the error names the code, and gdalwarp -t_srs EPSG:4326 in.tif out.tif converts the file |
| the pixels | one band of 8-, 16- or 32-bit integers, or 32- or 64-bit floats; tiles or strips; uncompressed, LZW, Deflate or PackBits; either byte order; BigTIFF | several bands; zstd, JPEG and other compression (gdal_translate -co COMPRESS=DEFLATE rewrites the file); a separate mask of missing pixels |
| where the pixels lie | one tiepoint (a pixel tied to a longitude and latitude) with a pixel size, or a matrix without rotation; pixel is area or pixel is point (whether the tiepoint names a pixel’s corner or its center); longitudes 0° to 360° as well as −180° to 180° | a rotated grid; several tiepoints (ground control points); a south-up pixel size, which GDAL and the standard read differently |
| the heights | a scale and offset as GDAL applies them (from the file’s pixel scale, or from GDAL’s own metadata tag); meters, feet or US survey feet as the file states (in its keys or in GDAL’s metadata tag), or as its vertical datum implies; meters if it says nothing, with vertical_unit_stated then false | a vertical datum outside a short list HPR Sim knows (VERTICAL_CRS_UNITS in the API: EGM2008, EGM96, NAVD88 and a few more), since its unit could be feet; forms GDAL may read differently (below); a unit other than these, or two that disagree |
| no data | the file’s nodata value, and NaN, read as None |
Also refused in the heights row, as GDAL may read them differently:
- a height scale in the pixel-scale tag when the file names a vertical datum in a way GDAL may not apply (HPR Sim can’t tell what GDAL would do);
- vertical keys GDAL ignores, unit and all, or reads by rules of its own (a private code, keys beside WGS 84 3D, datum 6030 beside WGS 84 with a model type, or keys with no model type and no unit);
- a scale, offset or unit in GDAL’s metadata tag with a namespace, capitals in an attribute’s name, a sample that isn’t plain digits, a value that isn’t plain text, a blank written as a character reference, or the
IMAGE_STRUCTUREdomain, which GDAL reads with quirks of its own.
Which height it is. The height is above the file’s own vertical datum. The reader reports the
datum’s EPSG code (vertical_crs_epsg) when the file names one, and doesn’t change the height.
Check two things in info(), the first one first:
- If
vertical_unit_statedisfalse, the file states no unit, and the simulator took meters. A file in feet read as meters gives heights 3.28 times too high. - If
vertical_crs_epsgisNone, the file names no datum. The USGS tile in the example below names none. The USGS’s own description of its data says its heights are above NAVD88, the North American vertical datum. Check your publisher’s description.
EGM2008 is a model of the geoid. NAVD88 was defined by leveling. The US National Geodetic Survey puts it about half a meter off the best geoid models. NAVD88 is tilted, too, by about a meter from coast to coast (NGS, new datums). Together, the offset and the tilt come to a meter or two at most.
The simulator takes a height above either as the of What the height means. A meter’s difference in changes the air’s density by about 0.01%.
An example with a file
crates/hpr/examples/site_geotiff.rs
reads two small files cut from the USGS tile around Spaceport America. Both have some pixels
blanked out as nodata. One is in meters, the other in whole US survey feet. It makes these calls:
ElevationRaster::parse(bytes)reads the tags;info()holds what they say.height_at(lat, lon)gives the height at three places: the runway and a place in a blanked-out hole (None). The third is Albuquerque, off the file (an error naming the file’s edges).value_atgives the feet file’s raw value, andheight_atthe same in meters.Ussa76::standard().air(height)gives the standard atmosphere at the runway’s height.
Run it from a copy of the repository with cargo run --example site_geotiff -p fusionspace-hpr. It prints:
70 by 50 pixels of 1.000" by 1.000", PixelIsArea, CRS EPSG:4269, values F32 in Meter (stated: false)
latitudes 32.98333 to 32.99722, longitudes -106.98500 to -106.96556
place lat (°) lon (°) height
Spaceport America, New Mexico 32.9900 -106.9700 1400.691 m
a hole in the data 32.9960 -106.9832 no data
Albuquerque, New Mexico 35.0844 -106.6504 refused: latitude 35.0844° and longitude -106.6504° are outside the raster, which spans latitudes 32.983333° to 32.997222° and longitudes -106.985000° to -106.965556°
in feet: 4595 UsSurveyFoot (vertical CRS EPSG:6360) = 1400.559 m, -0.132 m from the meters file
at 1400.7 m: 855.95 hPa, density 0.872 of sea level's
1.000"is one arc-second,PixelIsAreasays the tiepoint is a pixel’s corner, andEPSG:4269is NAD83.F32is 32-bit floating point, andMeter (stated: false)says the file states no unit.- In the feet file,
EPSG:6360is NAVD88 in US survey feet, which the file states.
The runway reads 1,400.691 m (4,595.44 ft). Open-Meteo’s answer for the same place, above, is 1,400 m (4,593 ft). That answer comes from a different terrain model whose cells are 90 m (295 ft) across, above EGM2008. The feet file stores 4,595 US survey feet, which is 1,400.559 m (4,595.01 ft), 0.132 m (0.43 ft) from the meters file. Rounding to whole feet moves a height by up to 0.152 m (0.50 ft).
How the file reader is checked
The oracle, the outside program HPR Sim is held to, is GDAL 3.12.2, run
through rasterio 1.5.2, its Python interface. A script,
validation/oracles/geotiff/dem.py,
cut 70 by 50 pixels around Spaceport America from the USGS’s 1-arc-second tile n33w107 and wrote
them in seven encodings:
| file | pixels | layout | georeferencing and heights |
|---|---|---|---|
usgs-f32-lzw-fp-tiles.tif | 32-bit floats, LZW, floating-point predictor | 16-pixel tiles | NAD83, pixel is area, nodata holes |
usgs-i16-deflate-strips-be.tif | 16-bit integers, Deflate, horizontal predictor | 7-row strips, big-endian | WGS 84 |
usgs-f64-raw-bigtiff-point.tif | 64-bit floats, uncompressed | BigTIFF | WGS 84, pixel is point |
usgs-u16-packbits-ftus-nodata.tif | 16-bit unsigned, PackBits | strips | NAD83 with NAVD88 in US survey feet, nodata holes |
usgs-u32-cm-scaled-egm2008.tif | 32-bit unsigned, Deflate | strips | WGS 84 with EGM2008; centimeters above 1,000 m (3,281 ft) by the pixel scale |
usgs-u8-metadata-scaled.tif | 8-bit unsigned, LZW | strips | WGS 84; quarter feet above 4,585 ft, scale, offset and unit all by GDAL’s metadata |
usgs-i32-lzw-tiles-lon360.tif | 32-bit integers, LZW, horizontal predictor | 32-pixel tiles | WGS 84, longitudes past 180° |
The script recorded what rasterio reads from each, and from the whole 3,612 by 3,612 tile:
- the corner, the pixel size, the CRS, the vertical datum and unit, the scale and offset, and the nodata value;
- the exactly rounded sum of every value, and of each value times its index (row × width + column), so a swapped pair of pixels would show;
- at 400 places in each small file and 2,000 in the tile, which pixel rasterio puts the place in, and its value. Some of those places are off the edge.
The tests in
crates/hpr-io/tests/geotiff_rasterio.rs
hold HPR Sim to all of it exactly:
| check | result |
|---|---|
| corner and pixel size | the same to the last bit, in all eight files |
| the two sums over every pixel | exact, 13 million pixels in the tile |
| places in the seven files | 2,800: the same pixel and value at all 2,368 on a file (9 of them nodata), and “outside” at the other 432 |
| places in the tile | 2,000: the same pixel and value at all 1,696 on it, and “outside” at the other 304 |
| unit | GDAL’s wherever GDAL reports one, and vertical_unit_stated false wherever it reports none |
| heights | at every 97th place, HPR Sim’s height is GDAL’s scale and offset applied to the value, in the file’s unit |
CI checks the seven small files. The whole tile (45 MB, fetched by cargo xtask refs fetch) is
checked where it’s been downloaded.
The code’s own tests build files to check each refusal in the table above. They also check the half-pixel move of pixel is point, the units, the scale and offset, and nodata. Property tests check, on random strip and tile layouts, that every place reads the pixel it’s placed in. They check, too, that a file with bytes changed is read or refused without a crash.
The places are random, so none sits exactly on a pixel’s edge. Rounding can put a place on either side of an edge, in HPR Sim and in GDAL. That happens only for a place closer to the edge than about 10⁻¹³ of a pixel’s width. A coordinate typed to a few decimals never comes that close.
What the file reader leaves out
- Map projections aren’t read: a UTM file, or one on an older datum, needs
gdalwarpfirst. - There’s no smoothing. A place reads its pixel’s value, and on a slope the next pixel can be meters higher.
- Datums aren’t converted. A datum within a few meters of WGS 84 is taken as WGS 84, and the vertical datum is reported. Near the rupture of a large earthquake since a datum was fixed, the ground has moved further, by several meters. Chile’s earthquake in 2010, for SIRGAS 2000, is an example.
- The file’s accuracy is the file’s. The reader gives back what’s stored, and the USGS and other publishers state their own accuracy.
- There’s no command: a program calls the library.
Motor stock and prices
Find which motors vendors have in stock, and at what price, from the motor finder site, saved so the list works offline.
HPR Sim gets motor stock and prices from motor.fusionspace.co, the motor finder. It’s a free site that reads a dozen U.S. vendors’ public listings every hour. It covers every AeroTech, Cesaroni and Loki motor of impulse class D and up that they carry. For each, it publishes who has it in stock and at what price. The simulator reads the site’s public data API (its machine-readable files) and saves each answer, so the same list works later with no network.
The list is for anyone choosing a motor they can actually buy: “which L motors are in stock, and what does one cost?” The simulator then matches each motor in stock to its record on ThrustCurve.org, the public database of motor data. It can download that record’s thrust curve, so a motor you can buy is a motor you can fly (A motor from a file).
At the command line, hpr motors search --in-stock --class L --max-price 150 lists the motors in
stock by class and price (Motors you can buy). A Rust program calls
the library, as below.
The site’s terms ask you to check stock and price on the vendor’s own page before relying on them. Prices are in U.S. dollars.
The three searches are ThrustCurve.org’s own answers, recorded on 29 October 2026 (evidence row G23). The project uses its motor records as published facts, with credit (the decision record on ThrustCurve.org’s records).
The match is by name. On ThrustCurve.org’s answers of 1 October 2026, all 282 motors in stock matched exactly one ThrustCurve.org record (below). Each matched record’s size, impulse, average thrust and burn time equal the motor finder’s.
The tests replay saved answers, and CI never contacts either live site. Both were contacted by
hand, over an encrypted (HTTPS) connection, to record them. If a site changes its format, you’ll
find out when your program, or hpr motors search, gets a refused answer, not from a failing test.
The code is hpr_net::motor_finder (API reference),
written for the first motor-stock increment, and
hpr_net::thrustcurve (API reference), written for
the second. They need the net feature of the hpr crate:
fusionspace-hpr = { version = "0.1", features = ["net"] } in Cargo.toml, then
hpr::hpr_net::motor_finder.
The choices are in
the decision record on motor stock through the cache
and
the one on ThrustCurve.org and the match.
hpr motors search was added by the third increment, and its
choices are in
the decision record on the command.
How saved answers work is on Online data and the cache. The motors the simulator
carries with it, with their thrust curves, are on Solid motors.
What the site publishes
The site documents its API, and its terms, in its own repository. The API is a handful of files, rebuilt about every hour. There’s no key, no limit on how often you ask, and no way to ask for part of a file. A program fetches a whole file and picks what it needs.
| File | What it holds | On 2026-10-01 |
|---|---|---|
meta.json | when the files were built, and how many motors, motors in stock and vendors they hold | 760 bytes |
motors.json | every motor some vendor lists, D class and up | 598 motors, 1.6 MB |
in-stock.json | the same, only those in stock at one vendor or more | 282 motors, 0.96 MB |
vendors.json | the vendors read, with how many motors each lists and has in stock | 12 vendors, 1.1 kB |
motors/{maker}/{motor}.json | one motor, as in the lists | 1.4 to 8.1 kB for the four recorded |
Each motor carries:
- its maker;
- its designation (
L1150R,3683L851-P), spelled as ThrustCurve.org spells it; - its impulse class, diameter, total impulse, average thrust and burn time, taken from ThrustCurve.org;
- its propellant;
- for a reload, the reusable case it needs (
RMS-29/180); - its delays;
- whether it’s discontinued (old stock only: two motors in stock were, on the recorded morning);
- whether it ships as hazardous material, as the site labels it from the propellant’s weight;
- every vendor’s listing of it.
A listing is one product page: its status, sticker price and pack size, and the price of one motor. It also holds the units on hand when the vendor shows them (267 of the 3,685 listings did), and when the site last read it.
The status is in stock, out of stock, special order or unknown. A special order is made or ordered for you, often with a lead time of weeks, and isn’t counted as in stock. A vendor may list one motor several times, for different delays or pack sizes. Each motor in stock also names its cheapest offer, by the price of one motor.
Prices are whole cents. The price of one motor is the sticker price over the pack size, to the nearest cent. A $38.49 two-pack is $19.25 a motor. The 263 of the 3,685 listings that fall on a half cent all round up.
What the simulator refuses
An answer is refused, and not saved, when:
- it isn’t JSON, or a field is missing or of the wrong type;
- its schema version (the number the API puts on its format) isn’t 1: the API puts a breaking change under a new address;
- its build time isn’t a UTC time;
- a list’s count disagrees with the list;
- a motor’s impulse class isn’t one capital letter, its diameter isn’t above zero, or its impulse, thrust or burn time is below zero;
- a motor’s listing count disagrees with its listings;
- a motor has a cheapest offer but isn’t in stock, or is in stock with none;
- a pack holds no motors, or a motor costs more than its pack;
in-stock.jsonholds a motor out of stock;- a motor’s own page holds another motor.
One broken value refuses the whole file. The simulator keeps its last good copy rather than a list it can’t trust. Online, it hands that copy back, marked stale, with the reason.
Two things the API allows are read, not refused. One is a cheapest offer with no price, when no vendor with the motor in stock shows one. The other is a listing status the API adds later, which reads as unknown.
Asking for a motor the site doesn’t list gets the site’s “not found” page. The simulator returns it
as an error naming the address, and doesn’t save it. The makers can be named in full or by their
short names, aerotech, cesaroni and loki, in any case.
Matching motors to ThrustCurve’s records
The motor finder carries no thrust curves, and no ThrustCurve.org id. ThrustCurve.org has both. It
aims to hold a record for every certified motor, each with its own id (24 hexadecimal digits, such
as 5f4294d2000231000000044f). It also has the simulator files people have uploaded for its
motors. HPR Sim asks ThrustCurve.org’s public API two
things:
| Request | What it gives | HPR Sim’s call |
|---|---|---|
| a search | motor records: id, maker, designation, class, diameter, impulse, burn time, delays, how many data files | thrustcurve::fetch_search |
| a download | one motor’s data files in one format, RASP (.eng) or RockSim (.rse), each with who measured it and its license | thrustcurve::fetch_download |
The match. The finder spells each designation exactly as ThrustCurve.org does. So the simulator
matches a motor in stock to the record with the same maker and designation, character for
character. The maker is matched by its full name, such as Cesaroni Technology.
If no record has that maker and designation, or more than one does, the motor is a miss. The
match’s report (Join::report()) lists it with the reason. A motor ThrustCurve.org spells
differently is reported as a miss, never matched by a guess. (The report and the code call a
matched motor mapped.)
thrustcurve::fetch_finder_records fetches the records the match needs, one search for each of the
three makers the finder reads. thrustcurve::join matches them.
On ThrustCurve.org’s answers of 1 October 2026, every motor in stock matched (the decision record on ThrustCurve.org and the match):
| Maker | Motors in stock | Motors matched | Motors missed | ThrustCurve.org records searched |
|---|---|---|---|---|
| AeroTech | 153 | 153 | 0 | 307 |
| Cesaroni Technology | 99 | 99 | 0 | 296 |
| Loki Research | 30 | 30 | 0 | 60 |
| All | 282 | 282 | 0 | 663 |
Every matched record listed at least one data file, in some format. For every match the diameter, total impulse, average thrust and burn time were the same on both sides. So each match was the right motor by more than its name. The motor finder copies ThrustCurve.org’s names and figures, so a full match is expected; the match is there to catch drift.
The tests replay ThrustCurve.org’s searches of the three makers, recorded unchanged on
29 October 2026 (the decision record on ThrustCurve.org’s records). They hold 307,
296 and 60 records, the same counts as on 1 October, AeroTech’s seven hybrids among them. Each
solid motor’s record is the same, field for field, as in the snapshot of 28 October 2026 that the
simulator carries (Solid motors;
the decision record on the licensing calls).
The tests of fetching one motor on demand (hpr motors fetch) replay invented answers instead,
for cases the real records don’t hold, such as a name two motors share or an empty search. The
invented motors’ designations end -INVENTED, -OTHER or -HYBRID; one invented record carries
AeroTech’s real F27R/L designation.
On them, too, all 282 motors match (the in-stock list is of 1 October, the searches of
29 October), each record lists a data file, and each match’s figures equal
the finder’s. The tests write the match’s report into
validation/reports/thrustcurve-join.md,
and check it against the match on every run.
The test that writes the report was added with the milestone for ThrustCurve searches and curves. The milestone’s goal was 95% of the motors in stock, and that test asserts it too.
The curve. A download’s file is read by the same readers as a motor file on your disk
(Solid motors): .eng by hpr_motor::eng, .rse by hpr_motor::rse.
DataFile::read() picks the reader by
the file’s format.
Curve::thrust_curve() gives the
first motor’s curve.
Each file says who measured it: cert, a certification test; mfr, the maker; or user. It also
gives its license: PD for public domain, free or other, or none given. ThrustCurve.org’s API
doesn’t define free and other, and the simulator doesn’t interpret them; only PD files are
recorded for the tests. An answer with no files gives an empty list, not an error. That’s how the
API answered an unknown id when tried by hand on 1 October 2026.
What the simulator refuses. A search or download is refused, and not saved, when:
- it carries the API’s error message, on the answer or on one of the search’s terms;
- a search returns more motors than it says match;
- an id isn’t 24 hexadecimal digits;
- a size, thrust, impulse, burn time or weight is below zero;
- a file isn’t base64 (the encoding the API sends files in);
- a download holds a file of another motor or format than asked;
- a search for the match was cut short: it says more motors match than it returned (it asks for up to 5,000). Refusing it means a match never runs on part of a maker’s records;
- a search for the match holds another maker’s record.
Records may leave out any field but the id, maker and designation: the API sends only the fields that have values. A file that decodes but isn’t plain text (UTF-8) isn’t refused. Reading that one file is an error, and the motor’s other files stay readable.
An example
crates/hpr/examples/motor_stock.rs
lists the L motors in stock, cheapest first, then matches the motors in stock to ThrustCurve.org
and reads one curve. It makes these calls:
Client::new(transport, Cache::new(folder), Mode::Online)sets up the fetching. The transport is what fetches (Online data and the cache). A real program passeshpr_net::Http::new(), and keeps its saved answers inCache::platform_dir(), the system’s usual folder for them. This one never uses the network: a test transport answers with the files recorded for the tests.motor_finder::fetch_meta(&client, now)andmotor_finder::fetch_in_stock(&client, now)fetch the build time and the in-stock list, and save them;nowis the time, in seconds since 1 January 1970.- Two hours later, the same
fetch_in_stockgoes through a client inMode::Offlinewhose transport has no network. It answers from the saved copy, marked stale: older than an hour. - It keeps the motors whose
impulse_classisL, and sorts them by theircheapest_in_stock.unit_price_cents, the price of one motor. thrustcurve::fetch_finder_records(&client, now)fetches ThrustCurve.org’s records of the three makers, andthrustcurve::join(&in_stock.motors, &records)matches the motors in stock.Download::new(id, Format::Rasp)andthrustcurve::fetch_downloadfetch AeroTech J450DM’s.engfile by its matched id, andread()?.thrust_curve()?reads it. It uses J450DM because the tests record only public-domain files.
Run it from a copy of the repository with
cargo run --example motor_stock -p fusionspace-hpr --features net. It prints:
Motor stock data from motor.fusionspace.co, licensed CC BY 4.0 (https://creativecommons.org/licenses/by/4.0/). It is aggregated from public vendor listings and ThrustCurve.org, provided as is, with no warranty. Check stock and price on the vendor's own page before relying on them
built 2026-10-01T07:07:29+00:00: 598 motors listed, 282 in stock, from 12 vendors
first read: Fetched; offline two hours later: Stale, the same list: true
20 L motors in stock; the five cheapest by the price of one motor:
manufacturer motor dia (mm) impulse (N·s) one motor cheapest at vendors
AeroTech L1520T 75 3715.9 $260.99 Balsa Machining Service 1
AeroTech L850W 75 3646.2 $282.74 Sirius Rocketry 2
Cesaroni Technology 3419L645-P 75 3419.8 $286.36 Performance Hobbies 2
Cesaroni Technology 3683L851-P 75 3683.2 $290.39 Animal Motor Works 3
AeroTech L1150R 75 3517.0 $324.99 Animal Motor Works 1
Motor data and thrust curves courtesy of ThrustCurve.org, https://www.thrustcurve.org/
663 records of the three makers; 282 of 282 motors in stock matched to one each, 0 missed
AeroTech J450DM: id 5f4294d2000231000000044f, a RASP file from source cert, license PD, 37 points from ignition
the file: total impulse 1061.6 N·s, burn time 2.28 s, average thrust 465.6 N
record: total impulse 1055 N·s, burn time 2.27 s, average thrust 465 N
CI checks it still prints this (cargo xtask examples --check). The first line is the credit
the site asks for, with its caution; show it wherever a price or stock is shown. Fetched and
Stale say where an answer came from
(how long a copy stays fresh). vendors is how many
vendors had the motor in stock. On that morning no L motor in stock cost $150 or less: the
cheapest was $260.99.
The last lines come from ThrustCurve.org, under its own credit line. The 663 records are its three recorded searches (above, evidence row G23), AeroTech’s seven hybrids among them.
J450DM’s file is a real answer: the certification test’s curve (source cert), public domain.
It’s the file the simulator already carries for J450DM (Solid motors).
Its curve starts at zero thrust at ignition, then follows the file’s 36 points. The simulator works
its figures out from those points. So they differ from the published figures on ThrustCurve.org’s
record:
| from the file | on the record | difference | |
|---|---|---|---|
| total impulse | 1,061.6 N·s | 1,055 N·s | +0.6% |
| burn time | 2.28 s | 2.27 s | +0.4% |
| average thrust | 465.6 N | 465 N | +0.1% |
The average thrust is the total impulse over the burn time.
Credit and terms
motor.fusionspace.co
The site’s terms are on its API page, under “Data licence”. The site licenses its API’s answers under Creative Commons Attribution 4.0 (CC BY 4.0). It asks for the credit “Motor stock data from motor.fusionspace.co” and allows keeping recorded answers, such as the test recordings below. The data is gathered from public vendor listings and from ThrustCurve.org, and comes as is, with no warranty.
Anyone may use and share the site’s compilation, commercially too, on CC BY 4.0’s main conditions:
give that credit, name the license with its link, and say if you changed the data. A program of
your own built on the library can show motor_finder::ATTRIBUTION, which carries the credit and
the license; saying what your program changed is yours to add. From 1 to 3 November 2026 the site
used narrower terms. It withdrew them on 3 November: a copy saved in those days is under CC BY 4.0
like any other, with the same credit, and needs no permission
(the decision record’s amendment).
The simulator puts its credit line, motor_finder::ATTRIBUTION, on every answer, fetched or saved.
hpr motors search prints it at the top of every list, in text
and in JSON, with ThrustCurve.org’s below it.
The site asks programs to use its files rather than read the vendors’ pages themselves. It also asks them to keep a copy rather than fetch on every use. The simulator’s saved copy counts as fresh for an hour, as often as the site rebuilds.
ThrustCurve.org
ThrustCurve.org grants no license for its motor records; its site reads “All rights under copyright
reserved”. The project uses those records as published facts about motors anyone can buy, with
ThrustCurve.org’s credit
(the decision record on ThrustCurve.org’s records).
Its API asks for no particular credit. The simulator puts thrustcurve::ATTRIBUTION,
“Motor data and thrust curves courtesy of ThrustCurve.org”, on every answer, as it credits the
catalog it carries. Each data file has its own license, set by whoever uploaded it: check it before
passing a file on.
The simulator’s saved copy counts as fresh for a day, since motor records and curves change seldom. So a program that asks again within the day doesn’t ask the site again.
How it is checked
The tests in crates/hpr-net/tests/motor_finder.rs
replay eight answers recorded from one build of the site, on 1 October 2026 at 07:07 UTC. They’re
the four lists and the pages of four motors. The motors are one each from AeroTech, Cesaroni and
Loki, plus AeroTech’s F27R/L, whose name holds a / (its page is F27R~L.json). The tests read
the expected values from the recordings themselves, not through the code being tested. They check
that:
- each answer, read and written back out, holds exactly the recording’s fields and values, and carries the credit line;
- the API’s words read with their meaning. H128W is a reload that ships as hazardous material, F27R/L a single-use motor whose shipping varies, and D13W a reload that doesn’t. The listing counts are 827 in stock, 2,363 out of stock and 495 on special order;
- a second read online, inside the hour, is answered from the saved copy without a fetch;
- offline, each read gives the same values, fresh for the hour and marked stale after it. The offline transport fails the test if it’s ever called;
- each motor’s page is the same motor as in
motors.json, and a maker’s name can be full or short, in any case; - the files agree with each other:
in-stock.jsonismotors.json’s motors in stock, value for value, andmeta.jsoncounts both lists and the vendors; - each rule in the list above refuses an answer that breaks it, naming the field. What the API allows (an offer with no price, a new status) is read;
- an answer that isn’t JSON is refused and not saved. When one arrives after a good copy has gone stale, the good copy comes back with the reason;
- a page holding another motor is refused and not saved;
- offline, a file never fetched is an error naming its address.
Some of the site’s rules the simulator doesn’t enforce when it reads an answer. The tests confirm the recording keeps them:
- each motor’s page is at the address it names;
- the price of one motor is the sticker price over the pack;
- the cheapest offer is the lowest-priced listing in stock;
- a motor is in stock exactly when one of its listings is;
- the vendor counts count distinct vendors.
The tests in crates/hpr-net/tests/thrustcurve.rs
replay two answers recorded from ThrustCurve.org on 1 October 2026 at 08:22 UTC. They’re AeroTech
J450DM’s .eng file and AeroTech F27R/L’s .rse file, both public domain. The tests also replay
the three searches described above
(evidence row G23). They check that:
- each answer, read and written back out, holds exactly the recording’s fields and values and carries ThrustCurve.org’s credit. It comes from the saved copy on a second read, and works offline, fresh for a day and stale after;
- each solid motor’s record is the simulator’s snapshot’s, field for field, and no hybrid is in it;
- the test builds its own name-to-id table straight from the searches’ JSON, and the match agrees for all 282 motors. Each match’s diameter, impulse, average thrust and burn time equal the finder’s, and the report is the committed one;
- a motor renamed, two records of one name, or a designation in another case is a miss with its reason. The report lists it with its counts. The same record given twice counts once, and another maker’s record of the same designation doesn’t disturb the match;
- J450DM, a matched motor in stock, has its downloaded file read by
hpr_motorto the points in its lines. The file is byte for byte the one the simulator carries. F27R/L’s.rsefile reads to the points in its XML; - each refusal above refuses an answer changed to break it, naming the field, and a record with only an id, maker and designation reads;
- a download of another motor or format, a search cut short and a search holding another maker’s records are refused and not saved. A file that isn’t plain text is that file’s error alone.
hpr motors search is checked by
crates/hpr-cli/tests/motors_search.rs.
That test runs the command on the recorded lists, from the file and offline from the cache
(how far to trust it).
What it leaves out
hpr motors searchlists stock and prices: it doesn’t match motors to ThrustCurve.org or download their curves. A program does, as in the example.- The match is by name only. A motor ThrustCurve.org spells differently from the finder is a miss; the simulator doesn’t fall back on impulse or diameter. None missed on the recording.
Curve::thrust_curve()reads only the first motor of a file; the two recorded files hold one each.- There’s no choice among files. A motor may have several files in one format (from a certification test, the maker or a user). The simulator gives them all, in the API’s order, and leaves the choice to the program.
- Prices are as listed: the simulator doesn’t screen out a shop’s placeholder price.
- It covers U.S. vendors and dollars only, and only the three makers the site reads.
- There’s no history. Each answer is the stock of one hour; the simulator keeps only the latest copy of each file.
Reading a flight log
Read an altimeter’s flight log with FusionSpace HPR’s analyzer to learn how high your rocket went, how fast it climbed and when it landed.
This page is for anyone with an altimeter’s log who wants to know what their rocket did. FusionSpace HPR · Analyzer reads the log on its own. It needs no design file and runs no simulation. So it works whatever the rocket was designed in, or if it was never designed on a computer at all.
What works today: logs from PerfectFlite altimeters in their .pf2 format, the Pnut’s, the
StratoLogger’s and the StratoLoggerCF’s (the format). The library also reads
these (the layouts read):
- PerfectFlite’s CSV and text exports
- AltOS’s CSV
- the Featherweight Raven’s FIP CSV
- the Blue Raven’s CSV
- the RRC3’s and Eggtimer’s (and an Eggtimer TRS’s terminal text)
- PerfectFlite’s
.pfa - AltimeterCloud’s and Entacore AIM’s CSV
- AerospaceNU’s SillyGoose logs and its flight computer board’s CSV and ground station text
- Silicdyne Fluctus’s CSV
- the ARTS2’s interpreted data
- a phone app’s
launchCSV - an Eggtimer’s download saved as RTF
- the Raven’s
.FIPaand the RRC3’s.rffraw downloads - the Featherweight app’s flight summaries (figures, no samples)
- the R-DAS’s raw text (its counts kept as written)
- AltOS’s radio telemetry and its
.eepromraw downloads - the ARTS2’s
.odfand raw CSV - GPS tracks from Featherweight’s GPS tracker, KML and NMEA files, and Missile Works’ RTx
tracker’s
.rtxfile and its exports - GPS tracks in GPX files, checked on invented files only (the evidence register’s row on GPX)
- tables from loggers no other reader knows, by the units their headers state, into the same record
- those tables in a CSV layout also from the sheets of an Excel workbook
- a team flight computer’s binary records, by a layout the caller states
- a Blue Raven’s USB download, each line held to its CRC
- a course’s Teensy data logger, its units held to the flight’s physics
- one team’s radio telemetry packets,
255:…:254 - a Raven FIP export pasted below no header, under a header you state
- an AltiMAX altimeter’s
.xlsexport and its own.ALSfile - Entacore AIM’s
.xtrafiles and raw dumps - a MARSA altimeter’s download
- AltOS’s radio telemetry decoded to a table
- AltOS’s CSV re-saved by a spreadsheet, its formulas kept as text, or cut to its columns
- tables whose headers state too little, by a column mapping you state; the sample tables’ mappings each hold every unit to a physical check
hpr analyze and Python read each layout the library tells from the file alone, each by its own
reader. They read one sheet of a workbook or one recording of a raw dump at a time
(below). They read a table or binary records by a column mapping or
a record layout (Reading your own logger). A zip archive’s files must be
unpacked first.
Since readings on every logger shipped, they come from any logger’s barometric altitude or pressure, each within a stated bound. A GPS track gives none. Since the rest of the readings shipped, they include burnout, the flight time and each canopy’s descent rate. They also include the top acceleration from an accelerometer along the rocket’s axis. Formats no sample holds yet, such as a CATS flight computer’s, are listed as needing samples (the evidence row on these formats).
One real flight’s log is public, but it isn’t committed here, so it isn’t checked in CI. On it, the analyzer reads the apogee as 1,009 ft above the pad, as the altimeter states it. Those are two readings of one pressure trace, not a measurement of the height (the analyzer’s evidence row).
Most of an apogee’s bound is the day’s air. A barometric altimeter turns pressure into height by
the standard atmosphere. So on a day 15 K from standard, its heights are off by up to 6.92%.
Standard air is 15 °C less 6.5 °C a kilometer of height. So 15 K over is 30 °C (86 °F) at a
sea-level field, and about 22 °C (72 °F) at a 1,190 m (3,904 ft) one. Past that, the bound may not
hold. The log may record the pad’s temperature and its height above sea level: from its pressure,
an altitude above sea level, or a stated ground elevation. Then hpr analyze says so beside each
reading the day moves (A hot or cold day).
The top speed is worked out from the heights. It’s withheld from 227.7 m/s (747 ft/s), Mach 0.8 in the coldest air the bounds allow (the top speed). At those speeds a barometer’s port may read the flow over the nose.
The known gaps, each an open issue, are listed under What it doesn’t do yet. For a record or a certification, the altimeter’s own reading is the one to log. The rules behind each reading are on Flight-log readings, with what they were checked against. A reading the log can’t support is left out and says why, rather than printed as a number.
From the command line
hpr analyze flight.pf2
reads any layout the library tells from the file alone. It prints the readings as text, each
with the bound its error stays within (“within …”), or as one JSON document with --json.
hpr analyze shows its output on an example log, and its
JSON schema lists
the fields.
Another logger’s table is read by a column mapping, --mapping, and its binary records by a
record layout, --layout. Each is a JSON file you write.
Reading your own logger works through both on an invented logger.
A file of several records
A spreadsheet’s workbook holds sheets. The workbook is an .xlsx, or an .xls written as one
bare worksheet (as an AltiMAX altimeter’s Excel export is). An Entacore AIM raw dump can hold
several recordings.
hpr analyze reads one at a time, each by its own reader. With no choice given, it reads the
workbook’s one sheet that reads as a log, or the dump’s one recording. Where there are several,
or no sheet reads, it refuses and names them, a sheet by its number and name, such as
2 (Second). Choose one, counted from 0:
hpr analyze flight.xlsx --sheet 2
hpr analyze flight.dump --recording 1
From Python, FlightLog.read(path, sheet=2) and FlightLog.read(path, recording=1) do the same.
A Featherweight Raven’s FIP export that lost its header line when it was pasted into a workbook
reads too. It’s read under a header you state, --fip-header
(Reading your own logger).
From a program
The library is hpr_flightdata. It reads a log’s text into a record in SI units, then takes the
readings from that record. It doesn’t depend on the simulator, so a program that only reads logs
doesn’t build one. This program reads the invented log the tests use, and prints each reading’s
value and where it came from. Each reading also carries its bound, as hpr analyze prints it:
//! A flight log read on its own: the invented PerfectFlite log the tests use, its readings printed
//! with where each came from, or why it was withheld. No design file, no simulation.
//!
//! It uses the workspace crate `hpr-flightdata`, which doesn't pull in the simulator, and `serde`
//! and `serde_json` to print each code as the JSON output spells it.
//!
//! Run it from anywhere in the repository:
//!
//! ```text
//! cargo run --example read_a_log -p fusionspace-hpr-flightdata
//! ```
//!
//! The guide's page *Reading a flight log* (`docs/reading-a-flight-log.md`) quotes it and what it
//! prints, which is kept next to it in `read_a_log.output.txt`; CI checks that the two still agree
//! (`cargo xtask examples --check`).
#![allow(
clippy::print_stdout,
reason = "the project's lints forbid printing in library code, and this program exists to print"
)]
use std::error::Error;
use hpr_flightdata::perfectflite::{self, FOOT_M};
use hpr_flightdata::readings::{self, Reading};
/// The invented log: a Pnut's file of a flight made up for the tests.
const LOG: &str = include_str!("../../../validation/fixtures/logs/synthetic-pnut.pf2");
/// A code as the JSON output spells it, such as `no_accelerometer`.
fn code(value: impl serde::Serialize) -> String {
serde_json::to_value(value)
.ok()
.and_then(|json| json.as_str().map(str::to_owned))
.unwrap_or_default()
}
/// A reading's value as text, or why it was withheld.
fn show<T>(reading: &Reading<T>, value: impl Fn(&T) -> String) -> String {
match reading {
Reading::Read(read) => value(read),
Reading::Withheld(withheld) => {
format!("withheld ({}): {}", code(withheld.reason), withheld.detail)
}
}
}
fn main() -> Result<(), Box<dyn Error>> {
let log = perfectflite::read(LOG)?;
println!("{}: {} samples", log.logger, log.time_s.len());
if let Some(stated) = log.stated.apogee_m {
println!("it states an apogee of {:.0} ft", stated / FOOT_M);
}
let read = readings::read(&log);
println!();
println!(
"liftoff {}",
show(&read.liftoff, |liftoff| format!("{:.2} s", liftoff.time_s))
);
println!(
"apogee {}",
show(&read.apogee, |apogee| format!(
"{:.1} m ({:.0} ft) at {:.2} s, source: {}",
apogee.altitude_m,
apogee.altitude_m / FOOT_M,
apogee.time_s,
code(apogee.source)
))
);
println!(
"highest sample {}",
show(&read.apogee, |apogee| format!(
"{:.1} m at {:.2} s",
apogee.highest_sample.altitude_m, apogee.highest_sample.time_s
))
);
println!(
"top speed {}",
show(&read.max_speed, |speed| format!(
"{:.1} m/s at {:.2} s, source: {}",
speed.speed_m_s,
speed.time_s,
code(speed.source)
))
);
println!(
"top acceleration {}",
show(&read.max_acceleration, |top| format!(
"{:.1} m/s²",
top.acceleration_m_s2
))
);
println!(
"burnout {}",
show(&read.burnout, |burnout| if burnout.is_floor {
// A floor: the pair printed is the reading and its bound, and the floor, their
// difference, is the soonest burnout can have come.
format!(
"no sooner than {:.2} s less {:.2} s, source: {}",
burnout.time_s,
burnout.bound_s,
code(burnout.source)
)
} else {
format!("{:.2} s, source: {}", burnout.time_s, code(burnout.source))
})
);
println!(
"landing {}",
show(&read.landing, |landing| format!(
"{:.2} s; down from apogee at {:.1} m/s on average",
landing.time_s, landing.mean_descent_rate_m_s
))
);
println!(
"flight time {}",
show(&read.flight_time, |flight| format!(
"{:.2} s",
flight.time_s
))
);
println!(
"drogue {}",
show(&read.drogue_descent, |leg| format!(
"{:.1} m/s",
leg.rate_m_s
))
);
println!(
"main {}",
show(&read.main_descent, |leg| match &leg.opening {
Some(opening) => format!(
"{:.1} m/s, opened at {:.2} s, {:.0} m up",
leg.rate_m_s, opening.time_s, opening.height_m
),
None => format!("{:.1} m/s", leg.rate_m_s),
})
);
Ok(())
}
It prints:
PerfectFlite Pnut: 984 samples
it states an apogee of 1281 ft
liftoff 0.80 s
apogee 390.1 m (1280 ft) at 10.28 s, source: barometer
highest sample 400.5 m at 11.35 s
top speed 78.3 m/s at 2.20 s, source: barometer
top acceleration withheld (no_accelerometer): the log has no accelerometer; HPR Sim doesn't difference a height twice to make one, as its steps would read as spikes of many g
burnout no sooner than 2.20 s less 1.32 s, source: barometer
landing 45.80 s; down from apogee at 10.9 m/s on average
flight time 45.00 s
drogue 21.7 m/s
main 6.0 m/s, opened at 21.40 s, 148 m up
What the readings say
The log is of a flight invented for the tests
(the flight). It reaches 80 m/s (262 ft/s) at burnout,
2.1 s after the start of the log. Then it coasts with no drag to 390.3 m (1,280.5 ft) at 10.26 s.
Each bound below is the one hpr analyze prints for the same log. A
bound’s feet are converted exactly here, where hpr analyze rounds them up: the drogue’s bound
below reads 7.2 ft/s here and 8 ft/s there.
-
Liftoff, 0.80 s, within 0.81 s: the last sample before the altitude climbs out of the pad’s noise allowance. The allowance is at least 2 m (6.6 ft) and a step. The rocket left the pad at 0.50 s; it took 0.30 s to climb that far.
-
Apogee, 390.1 m (1,280 ft) at 10.28 s, which is 10.275 s rounded. The top is flat over several samples, so the analyzer takes their middle as its time. It’s the top of the altitude after a 0.3 s running median. It’s 0.17 m (0.56 ft) below the true apogee, well within its 31.9 m (105 ft) bound.
-
The highest sample, 400.5 m (1,314 ft), a second after apogee, is the ejection charge’s pressure pulse, not the rocket. The median sets it aside.
-
The top speed, 78.3 m/s (257 ft/s) at 2.20 s, within 20.6 m/s (68 ft/s). It’s worked out from the heights, as the steepest slope of a 0.5 s fit, not read from the altimeter’s speed column. The true speed at burnout is 80.0 m/s (262.5 ft/s); the fit across the corner at burnout reads it a little low.
-
The top acceleration is withheld: a PerfectFlite has no accelerometer. HPR Sim doesn’t difference the heights twice to make one, as their one-foot steps would read as spikes of many g.
-
Burnout, no sooner than 0.88 s: the top speed’s time, 2.20 s, less its 1.32 s bound. With no accelerometer, burnout is a floor: its reading is the top speed’s time, and the floor that time less its bound. A rocket gains speed only while its thrust beats the drag and its weight. So the motor burned out no sooner than the floor. It may have burned on after the top speed’s time by any amount. The true burnout is 2.10 s.
The floor is loose by design: on the synthetic flights’ tuning set, the top speed came 0.24 s before the true burnout on average. The top speed’s time ranged from 1.03 s before the true burnout to 0.718 s after it. The floor lies its bound, about 1.3 s, earlier still (Checked against).
-
Landing, 45.80 s, within 2.11 s: the first sample back within the pad’s allowance. The rocket touches down 0.34 s later, at 6 m/s (20 ft/s) under its main.
-
The flight time, 45.00 s, within 2.91 s: landing’s time less liftoff’s. The true flight time is 45.64 s: liftoff is read 0.30 s late and landing 0.34 s early.
-
The mean descent rate, 10.9 m/s (36 ft/s), within 2.1 m/s (6.9 ft/s). It’s the height lost from apogee to landing over the time taken, drogue and main together.
-
The drogue’s descent, 21.7 m/s (71 ft/s), within 2.2 m/s (7.2 ft/s), from apogee at 10.28 s to the main’s opening at 21.40 s. It is the mean rate from apogee, as
hpr analyzesays on its line: the height lost over the time taken, so the fall from rest there is included. The rocket fell under its drogue at 25 m/s (82 ft/s), but started that leg from rest. Over the same span, the leg’s true rate is 21.74 m/s (71.3 ft/s). -
The main’s descent, 6.0 m/s (20 ft/s), within 0.8 m/s (2.6 ft/s), from its opening to landing, as the flight’s main truly fell. The opening is at 21.40 s within 1.06 s, 148.4 m (487 ft) up. It’s found by walking back from landing until the descent’s rate climbs well past the main’s. The main truly opened at 21.14 s, 150 m (492 ft) up, so the reading is 0.26 s late. It’s late because the rate, a slope fitted over 1 s, still sees some of the drogue’s faster fall just after the opening.
What the file states about itself, such as the altimeter’s own apogee of 1,281 ft, is kept in
log.stated. It sits beside the analyzer’s readings, never in their place.
The codes, such as no_accelerometer and barometer, are the ones the JSON output of
hpr analyze uses. The top speed is max_speed in both, the top acceleration max_acceleration,
and the canopies’ legs drogue_descent and main_descent. A reading that is a floor carries
is_floor, and a clipped top acceleration says why in clip, range or flat. Python’s
FlightLog.readings() returns the same readings, bounds included, as a dict
(From Python).
Every code a reading can be withheld with is in the table of reasons, with when it applies. Among them are those that came with the accelerometer and the canopies:
axis_unstated(no accelerometer named along the rocket)gravity_unstated(whether its readings hold gravity)direction_unstated(which way up it reads)one_canopy(no drogue’s leg in the descent)short_leg(a leg too short to read)
A hot or cold day
Each bound allows for air up to 15 K from the standard atmosphere. That is 30 °C (86 °F) at a sea-level field, and about 22 °C (72 °F) at a 1,190 m (3,904 ft) one. Past that, the bound may not hold. On a hot day a barometric altimeter reads its heights low, and with them the top speed and the descent rates. On a cold day it reads them high.
hpr analyze checks the day where it can. It compares the log’s temperature on the pad with the
standard atmosphere’s at the pad’s height above sea level
(A day past 15 K). That height comes from a pressure
column, an altitude above sea level, or the ground elevation the logger states. Past 15 K, a line
above the readings gives the log’s temperature and the offset. Below the apogee, the top speed,
the mean descent rate and each canopy’s rate, a note gives how far the day’s air alone may put the
true value from the reading:
the day's air may put the true height up to 289.2 m (949 ft) above the reading, 10.6%, where the bound allows 6.9% for the day's air
That figure is from the worked example on the physics page, not a real log. Its “up to” assumes the pad’s offset from the standard holds up the climb; under an inversion the day’s air can move the reading more. On a low flight, a day just past 15 K can move a reading by less than the bound’s 6.92%. The note then says the day is past 15 K, but within the bound’s share at this flight’s height. What to do then:
- Check the temperature. A logger’s temperature is often the electronics bay’s, warmed by the sun and the electronics. Take the field’s own weather reading at launch time. Subtract the standard’s at the field’s height, 15 °C less 6.5 °C a kilometer: 7.3 °C (45.1 °F) at 1,190 m (3,904 ft). If that is within 15 K, the pad’s reading suggests the day’s-air part of the bounds holds; the air aloft isn’t measured.
- If the air was past 15 K, the bound may not cover the day. Call the note’s share less 6.92% (if positive) its extra share. If the pad’s offset holds up the climb, the extra share is the most the day’s air may add beyond the bound, on the side the note names. In the example that is 10.561% less 6.924%, 3.637% of 2,738 m (8,983 ft): 99.6 m (327 ft). It is not a validated bound, and it can understate. A morning inversion leaves the air near the ground cooler than the air above it. A hot pad’s offset then grows up the climb, and the day’s air can move the reading more. The 90% interval isn’t validated past 15 K. A waiver, a record or a safety figure may rest on the reading. Then move the reading by its bound and by the extra share, the way the note gives. That is above the reading on a hot day, below it on a cold one. Show the note with that figure, and leave the call to the RSO and the safety code.
- For the descent rates, the same holds. A hot day’s true rate is faster than the reading, a cold day’s slower. Move the rate by its bound and by the note’s extra share, the way the note gives: above the reading on a hot day, below it on a cold one. Show the note with that rate, and leave the call on the recovery to the RSO and the safety code.
A log with no temperature, or with no pressure, no altitude above sea level and no stated ground
elevation, gets no check. Nor does a temperature outside −100 to 100 °C. Nor does a temperature
column of one value throughout at a unit’s zero (0 K, 0 °C or 0 °F), as a logger with no sensor
writes. Nothing then tells you the day was within 15 K, so check the day’s temperature at
the field yourself. The text output is silent both when the day is within 15 K and when there was
no check. --json’s day_air tells them apart: null means no check.
The 90% intervals and the health card
Beside its bound, a reading may give a 90% interval: where the truth lay nine times in ten on the synthetic flights. No real flight has checked one (evidence row G34). The bound is the size every error stayed within on the tuning set, and the one to use for a waiver or a load, unless the reading is a floor, which has no upper figure. A burnout floor or a clipped top acceleration gives a “95% lower end” in its place: about 19 truths in 20 lay above it. An apogee or top speed floor gives neither.
An interval can lie wholly to one side of its reading, as the reading’s error leans one way. Liftoff is read late, so its interval lies earlier (0.80 s, interval 0.41 to 0.64 s). The flight time, landing less liftoff, reads short, so its interval lies later (45.00 s, interval 45.38 to 46.11 s).
The last rows are the smoother’s, every sensor together, also unchecked on a real flight (evidence row G33). Its apogee is a cross-check: report the reading. Its health card says how each sensor fared. It can say the pad was assumed, as on a log that starts at launch, or the accelerometer set aside. Neither asks anything of you, though the track then rests on less. If it says the smoothed apogee is past the reading’s bound, go by the reading.
Two logs of one flight
Fly two altimeters and you have two logs, each counting from a zero of its own: when the board was
switched on, or when it saw the boost. Give hpr analyze both and it puts them on one timeline:
hpr analyze one.csv two.csv
It lines the clocks up by a shared liftoff: every board in a rocket leaves the pad at the same instant, so the time from one log’s liftoff to the other’s is the offset between their clocks. Each log keeps its own readings. They are never averaged, because two boards are two measurements, and each reading’s spread, the largest less the least, says how far apart they lie, not which is right. Two boards can agree and both be off by the day’s air. A log that ends on the climb gives floors for its top height and top speed, each without an interval, and a floor joins no spread. Nothing checks that the two logs are of one flight: that’s your word.
The offset’s bound is the sum of the two liftoffs’ bounds, and it held on every one of the 1,383 offsets the two-logger synthetic flights gave, the largest error 0.21 s and the median 0.03 s. Its 90% interval passed the same test as the readings’ (the report).
One real flight checks it against another clock, though not hard (evidence row G35). RocketPy’s Prometheus flight carried a TeleMetrum and a TeleMega, each with its own GPS receiver:
| Reading | TeleMetrum | TeleMega | Spread |
|---|---|---|---|
| Apogee, above its own pad | 3,892.1 m (12,769 ft) | 3,894.7 m (12,778 ft) | 2.6 m (9 ft) |
| Smoothed apogee | 3,985.7 m (13,076 ft) | 4,015.4 m (13,174 ft) | 29.7 m (98 ft) |
| Flight time | 223.01 s | 222.83 s | 0.18 s |
| Under the drogue | 26.5 m/s (87 ft/s) | 26.5 m/s (87 ft/s) | 0.0 m/s (0 ft/s) |
| Under the main | 6.5 m/s (21 ft/s) | 6.5 m/s (21 ft/s) | 0.0 m/s (0 ft/s) |
Their liftoffs read 0.23 s and 0.18 s, each on its own clock. The TeleMega’s clock less the TeleMetrum’s comes to −0.05 s, within 1.53 s, 90% interval −0.13 to 0.04 s. The two receivers’ UTC seconds, taken where each second ticks in each log, put it at −0.13 s: the ticks stay within about 0.02 s of that where the logs run at 100 samples a second, and any fixed difference between the receivers’ delays can’t be seen. So this offset is about 0.08 s away, and the interval’s low end, −0.129 s unrounded, is too close to that figure to say which side it falls. Both logs start at the boost, so their clocks hardly differ: an offset of zero would miss by 0.13 s, against this offset’s 0.08 s. That’s one flight: it can’t show whether the interval holds nine times in ten, and it says nothing of clocks that differ by minutes, as the synthetic flights’ do.
To see the flight rather than read it, --ghost flight.czml writes the logs’ paths for a viewer, as
ghost files explains.
--stages lays out one logger to a stage the same way, each leaving the pad with the stack, and
gives no spread, a booster’s apogee and a sustainer’s being different heights. It has been checked
only on simulated two-stage flights (evidence row G36).
What it doesn’t do yet
- Read a format no sample holds yet, such as a CATS flight computer’s (the evidence row on such formats). The formats that need samples are listed, each with what a reader would need. A sample can be offered in #662.
- Find the deployments as events: the main’s opening is read from the descent’s rate, not from the log’s record of when each charge fired.
- Give the Mach number and dynamic pressure.
- Take the top acceleration from a board’s three axes, which don’t say which lies along the rocket (#781). It comes only from an accelerometer the log names as the rocket’s axis (the accelerometer).
- Allow for a canopy’s filling time in the main opening’s bound (#779).
- Tell a fall under no canopy from one under a canopy: it’s read as one canopy’s descent (#780).
- Take a reading from a GPS track: a receiver’s altitude lags the climb, so no bound can be stated for it.
- Put a GPS track on a timeline with an altimeter’s log, or take a log read by a mapping into a pair, or read a pair from Python (#1086, #1085).
- Compare a flight with its simulation:
hpr comparedoes that (Comparing a flight with its simulation). - Check the heights near the speed of sound. It withholds the top speed from 227.7 m/s (747 ft/s), Mach 0.8 in the coldest air the bounds allow (the top speed). It doesn’t withhold the heights read there.
- Hold its bounds beyond what they were checked on: six simulated logger profiles (the loggers) and rockets leaving the pad at 2 g or more. A noisier logger or a slower rocket can be read outside its bound.
- Tell a charge’s spike from the top when the spike climbs into the top no faster than a coast can. Such a spike is read as the apogee, however high it stands (#761).
- Give the top speed when the height drops at ignition, then climbs
(
disturbed_pad). - Tell every disturbed top from the rocket’s own. Some tops withheld as
disturbed_topare the rocket’s own (#762). - Correct a barometric altitude for the day’s air. The altitude is the altimeter’s own conversion, which assumes a standard atmosphere (Barometric altimeter). The bound allows for air up to 15 K from standard instead. Past that, it notes the day but doesn’t widen the bound (A hot or cold day). It can only where the log records the pad’s temperature and its height above sea level: from its pressure, an altitude above sea level, or a stated ground elevation.
Reading your own logger
Read a logger FusionSpace HPR doesn’t know by a JSON file you write: a column mapping for a table, a record layout for binary records.
This page is for a flyer whose altimeter or flight computer writes a file no reader here knows. Theirs can be a board they built that logs to a card, a team’s flight computer, or a commercial logger whose format isn’t read yet.
FusionSpace HPR · Analyzer, the command line and the Python package read such a file by the mapping or layout you write. The file reads into the same record as every other log. Each column of numbers but the clock and those you skip becomes a channel on the logger’s clock. A channel’s values are in SI units (degrees for angles) where your mapping or layout states a unit. A mapping can mark the barometric altitude above the pad as the primary track, the one the readings are taken from.
The examples read invented files. All but the FIP export and the workbook two-flights.xlsx
are one flight’s, its logger’s and its GPS tracker’s
(the evidence register’s row on these files).
Check a unit against a known height, such as the launch site’s elevation from a GPS altitude, before trusting it.
The tests read this page’s files from the command line, Python and the Rust library, and hold the records equal, channel by channel. They do the same for each sample log the project reads by a stated mapping or layout, where present. The samples are other people’s, so CI reads this page’s only.
The logger
The logger’s examples read one made-up flight, as a home-built logger might record it. The
logger records a clock in milliseconds and its altitude above the pad in feet. It records the
air pressure in pascals, and an accelerometer along the rocket’s axis in g. The rocket peaks at
about 1,345.7 ft, 10.8 s after the logger starts; its highest sample, 10.6 s in, reads
1,345.2 ft. The logger writes the same samples three ways, each in
validation/fixtures/logs/own-logger/,
written by its make.py:
flight.csv, a table whose header names each column but states only some units.flight.bin, the same samples as binary records of 16 bytes. Each holds the clock as a 32-bit unsigned integer, then the altitude, the pressure and the acceleration as 32-bit floats, little-endian.flight-capture.txt, those records as the logger prints them over its USB serial console: base64 lines between two marker lines that name the block,flight.
A GPS tracker beside it writes gps-track.csv, read in A GPS tracker’s table.
A table, by a column mapping
A column mapping says how a table’s columns are read. It gives the header’s line, the separator,
the clock’s column, and what each column measures in which unit. You rarely write one from
nothing: --print-mapping prints what the header states, for you to edit. The invented table
starts with a comment, so its header is on line 2:
# An invented flight, written as a flyer's own logger would write it
Time (ms),Alt,Pressure (Pa),Accel X (g)
0,0.0,87823,1.00
What the header states
$ hpr analyze validation/fixtures/logs/own-logger/flight.csv --print-mapping
{
"header_line": 2,
"separator": ",",
"decimal_comma": false,
"clock": 0,
"columns": [
{
"name": "Time (ms)",
"quantity": null,
"unit": "ms"
},
{
"name": "Alt",
"quantity": null,
"unit": null
},
{
"name": "Pressure (Pa)",
"quantity": "pressure",
"unit": "pa"
},
{
"name": "Accel X (g)",
"quantity": "acceleration",
"unit": "g"
}
]
}
note: the column "Alt" states no unit the reader knows: kept as written
help: save it to a file and check each column's quantity and unit. Set "primary" to the column, from 0, that is the barometric altitude above the pad, mapped to altitude_above_ground. Then read the log with --mapping and that file
The header states the clock’s unit, ms, and the pressure’s and the acceleration’s. It states
none for Alt, so the reader keeps that column as written, "quantity": null, and a note says
why. A column it can’t read stays in the record, its numbers unconverted.
The mapping, edited
Save the printed mapping to a file, hpr analyze flight.csv --print-mapping > flight.mapping.json,
and give Alt what the header leaves out: its quantity, altitude_above_ground, and its unit,
ft. Then mark it as the primary track, "primary": 1, its column counted from 0. A mapping or
layout file may be UTF-8, or UTF-16 with its byte-order mark, as Windows PowerShell 5.1 saves what
> sends it. The file the folder holds:
{
"header_line": 2,
"separator": ",",
"decimal_comma": false,
"clock": 0,
"primary": 1,
"columns": [
{
"name": "Time (ms)",
"quantity": null,
"unit": "ms"
},
{
"name": "Alt",
"quantity": "altitude_above_ground",
"unit": "ft"
},
{
"name": "Pressure (Pa)",
"quantity": "pressure",
"unit": "pa"
},
{
"name": "Accel X (g)",
"quantity": "acceleration",
"unit": "g"
}
]
}
Each field, as the mapping’s schema lists them:
| field | what it says |
|---|---|
header_line | the header’s line, counted from 1; null for a file with no header row |
separator | the character between cells: a comma, ;, a tab, | or a space |
decimal_comma | whether a comma is the decimal mark, as in 1,5; only beside another separator |
clock | the clock’s column, from 0; its unit must be one of time, such as s, ms or us |
primary | the primary track’s column, from 0, mapped to altitude_above_ground; left out for a log with none |
columns | every column in the file’s order: its name, the quantity it measures (null keeps it as written), its unit, and "skip": true to leave a column out |
clock_wrap | for a counter that runs over, the count it turns over at, in the clock’s unit; left out for a clock that doesn’t |
rows | how a row is written: cells, the default; list, as [1, 2.5]; or stamped, a date and time first |
A quantity sets the unit the record holds the column in: SI, but degrees for angles. The
quantities for an altitude are altitude_above_ground, altitude_msl, gnss_altitude,
inertial_altitude and altitude (an altitude of unstated zero). The others are pressure,
speed, acceleration, temperature, voltage, current, latitude, longitude, angle,
angular_rate, distance, time_of_day, duration and number. A number is a count or a
code with no unit.
unrecognized is the same as null. The units a mapping can state are the ones a header can
(Tables read by their headers).
A mapping file that doesn’t follow the schema is refused before the log is read. The refusal names
the field by its path in the JSON, and its line and column. A unit written as 3 instead of
"ft" says
column mapping: `columns[1].unit`: invalid type: integer `3`, expected a string at line 16 column 15,
and a misspelled key, such as primry, is refused rather than left out. One the log contradicts
is refused naming the column: a primary track on the clock’s column, or a unit that doesn’t
measure its column’s quantity.
The log, read by it
$ hpr analyze validation/fixtures/logs/own-logger/flight.csv --mapping validation/fixtures/logs/own-logger/flight.mapping.json
flight.csv: read by the mapping flight.mapping.json
251 samples, from 0.00 s to 50.00 s
readings from the logger's barometric altitude, sampled every 0.200 s in steps of 0.030 m, after a 0.40 s running median
3 channels: Alt (altitude above ground), Pressure (Pa) (pressure), Accel X (g) (acceleration)
liftoff 1.20 s, within 1.05 s, 90% interval 0.69 to 0.99 s
apogee 409.5 m (1344 ft) above the pad, within 33.1 m (109 ft), 90% interval 388.4 to 430.4 m (1274 to 1412 ft); at 10.50 s, within 0.99 s, 90% interval 10.27 to 10.83 s, 9.30 s after liftoff
top speed withheld: the track's samples come every 0.200 s, too far apart for a 0.5 s fit of 5 samples. That fit needs them at most 0.125 s apart
landing 48.60 s, within 2.24 s, 90% interval 48.25 to 49.35 s; 38.10 s from apogee, at 10.7 m/s (35 ft/s) on average, within 2.1 m/s (7 ft/s), 90% interval 9.7 to 11.7 m/s (31 to 39 ft/s)
flight time 47.40 s, within 3.28 s, 90% interval 47.83 to 48.65 s
drogue descent 19.3 m/s (63 ft/s), within 1.9 m/s (7 ft/s), 90% interval 18.1 to 20.5 m/s (59 to 68 ft/s), from apogee at 10.50 s to the main's opening at 24.00 s, 409.5 m (1344 ft) to 148.7 m (488 ft) up; the mean rate from apogee: height lost over time taken, so the fall from rest there is included
main descent 6.0 m/s (20 ft/s), within 0.7 m/s (3 ft/s), 90% interval 5.5 to 6.4 m/s (18 to 21 ft/s), from the main's opening at 24.00 s, within 1.36 s, 90% interval 23.22 to 23.82 s, to landing at 48.60 s, 148.7 m (488 ft) to 1.0 m (3 ft) up
top acceleration withheld: the log's accelerometers (`Accel X (g)`) don't say which lies along the rocket's axis
burnout withheld: as for the top acceleration; and burnout from the speed's peak needs the top speed, which is withheld above
smoothed apogee 406.9 m (1335 ft), 90% interval 378.4 to 435.3 m (1241 to 1429 ft), at 10.40 s
health card pad assumed: too little of it in the log; heights on the readings' zero, noise from the flight's scatter
barometer: 251 samples, 249 fused, 0 rejected, 2 not weighed, 0 resets; 100.0% inside the gate; mean NIS 0.0402; largest test ratio 0.0577 at 11.6 s, Mach 0.03
barometer de-weighted: charge 9.80–11.4 s
pass back: every step smoothed
How far to trust it. The logger's own samples, read by HPR Sim in the units your mapping, layout or
FIP header states, not simulated. They are as right as those units are. Each reading states the
bound its error stayed within on HPR Sim's synthetic flights. They cover rates from 500 to 0.5
samples a second, steps up to 10 m or 100 Pa, and air within 15 K of standard. A reading the log
can't support is withheld, with the reason. The top speed is derived from the heights, and withheld
from Mach 0.8, where a barometer's port may read the flow over the nose. Those bounds hold only if
the units are right. Check a unit against a known height, such as the launch site's elevation from a
GPS altitude. For a record, go by the logger's own figures.
More: https://hpr.fusionspace.co/your-own-logger.html
The primary track, Alt in meters, holds every row. It’s a channel too, beside the pressure and the
acceleration, and the clock is each channel’s time_s. Each reading comes with the bound its error
stays within (Flight-log readings). The invented
flight peaks at 1,345.7 ft between samples, within the apogee’s bound of the reading. Three readings
are withheld, each with the reason:
- the top speed, as a sample every 0.2 s is too few for its 0.5 s fit;
- the top acceleration, as the accelerometer
Accel X (g)doesn’t say it lies along the rocket’s axis; - and burnout, which then needs the top speed.
A column is read as the rocket’s axis only where its logger’s reader names it so or its name holds
the word axial (the accelerometer). A column’s name
can be the header’s or the mapping’s. --json prints the same as one JSON document. --record
prints the whole record instead, every sample of every channel, as one JSON document. The record’s
schema
lists its fields:
hpr analyze flight.csv --mapping flight.mapping.json --record > flight.json
A table on a workbook’s sheet is read the same way. The workbook can be an .xlsx, or an .xls
written as one bare worksheet. Its sheet is named from 0 with --sheet, for --print-mapping and
--mapping alike; a workbook of one sheet needs none. A sheet one of the
library’s readers takes needs no mapping: --sheet alone reads it by that reader
(A file of several records).
A FIP export below no header
A Featherweight Raven’s FIP export, the CSV its Featherweight Interface Program writes, reads by
its own reader, but only with its header line. When it’s pasted into a workbook below no header,
nothing names its columns. So you state that line in a JSON file, a FIP header, and give it with
--fip-header
(its schema).
It has two keys:
header, the header line the program writes for an export of the same channels: each channel’sTime@clock, its value and itsbILBAstatus cell.pasted, the columns, counted from 1, that another table pasted over the export covers. A channel with a cell in them, in any row, is left out whole, with a note. Leave it out when no table is pasted over.
A key the schema doesn’t name is refused, naming it. The invented workbook
validation/fixtures/logs/several/fip-below-no-header.xlsx holds an export of three channels,
its header line gone. Its flight was made to peak at 273.5 m (897 ft) above the pad. The
workbook’s FIP header states that line:
{
"header": "Time@Axial Accel (Gs),Axial Accel (Gs),bILBA,Time@Baro (Atm),Baro (Atm),bILBA,Time@[Altitude (Baro-Ft-AGL)],[Altitude (Baro-Ft-AGL)],bILBA"
}
$ hpr analyze validation/fixtures/logs/several/fip-below-no-header.xlsx --fip-header validation/fixtures/logs/several/fip-below-no-header.header.json
fip-below-no-header.xlsx: Featherweight Raven
201 samples, from 0.00 s to 40.00 s
readings from the logger's barometric altitude, sampled every 0.200 s in steps of 0.337 m, after a 0.40 s running median
6 channels: Axial Accel (Gs) (acceleration), bILBA (number), Baro (Atm) (pressure), bILBA (number), [Altitude (Baro-Ft-AGL)] (altitude above ground), bILBA (number)
liftoff 1.40 s, within 1.10 s, 90% interval 0.87 to 1.18 s
apogee 273.0 m (896 ft) above the pad, within 23.9 m (79 ft), 90% interval 257.8 to 288.1 m (845 to 946 ft); at 9.90 s, within 1.03 s, 90% interval 9.66 to 10.24 s, 8.50 s after liftoff
top speed withheld: the track's samples come every 0.200 s, too far apart for a 0.5 s fit of 5 samples. That fit needs them at most 0.125 s apart
landing 37.40 s, within 1.46 s, 90% interval 37.17 to 37.89 s; 27.50 s from apogee, at 9.9 m/s (32 ft/s) on average, within 2.1 m/s (7 ft/s), 90% interval 8.8 to 10.9 m/s (29 to 36 ft/s)
flight time 36.00 s, within 2.55 s, 90% interval 36.33 to 36.97 s
drogue descent withheld: the descent shows no drogue's leg, which at the ground's density falls faster than 16.0 m/s up to the main's opening. That mark is 1.6 times the rate near the ground, 10.0 m/s, or 3 m/s more if that is more. A drogue's leg would also fall on median faster than 1.4 times the rate near the ground. So the rocket came down under one canopy, or under a drogue no faster than the mark, which reads as one. The main's descent is then the whole descent's, from apogee
main descent 9.9 m/s (32 ft/s), within 1.0 m/s (4 ft/s), 90% interval 9.3 to 10.5 m/s (30 to 35 ft/s), from apogee at 9.90 s to landing at 37.40 s, 273.0 m (896 ft) to 0.7 m (2 ft) up; the mean rate from apogee: height lost over time taken, so the fall from rest there is included
top acceleration withheld: the accelerometer `Axial Accel (Gs)`: no pad is read to tell by; no coast to apogee is read to tell by; its thrust says neither: as written, it never reads past 2 g either way up from liftoff's earliest time (the log's start where liftoff is withheld) to apogee: none of them says which way up it reads
burnout withheld: as for the top acceleration; and burnout from the speed's peak needs the top speed, which is withheld above
smoothed apogee 272.2 m (893 ft), 90% interval 257.7 to 286.7 m (845 to 941 ft), at 10.00 s
health card pad assumed: too little of it in the log; heights on the readings' zero, noise from the flight's scatter
barometer: 201 samples, 199 fused, 0 rejected, 2 not weighed, 0 resets; 100.0% inside the gate; mean NIS 0.00831; largest test ratio 0.0123 at 12.6 s, Mach 0.06
barometer de-weighted: charge 9.20–11.0 s
pass back: every step smoothed
How far to trust it. The logger's own samples, read by HPR Sim in the units your mapping, layout or
FIP header states, not simulated. They are as right as those units are. Each reading states the
bound its error stayed within on HPR Sim's synthetic flights. They cover rates from 500 to 0.5
samples a second, steps up to 10 m or 100 Pa, and air within 15 K of standard. A reading the log
can't support is withheld, with the reason. The top speed is derived from the heights, and withheld
from Mach 0.8, where a barometer's port may read the flow over the nose. Those bounds hold only if
the units are right. Check a unit against a known height, such as the launch site's elevation from a
GPS altitude. For a record, go by the logger's own figures.
More: https://hpr.fusionspace.co/your-own-logger.html
note: read under a header line the caller stated, the rows' own header missing
--sheet N picks the workbook’s sheet, counted from 0; with none, the workbook must have only one.
The rows saved as text read too. A log is read by one of --mapping, --layout and
--fip-header.
The readings are marked as read by your own description, as a mapping’s are. They’re only as right as the header you state. A FIP export pasted below no header says how the rows are read.
Binary records, by a record layout
A record layout says how a file of binary records is laid out. It gives each field’s name and kind, in the record’s order, and the byte order.
A field’s name states its unit as a table’s header does, such as Time (ms) or pressure__pa.
The records are written out as a table under those names and read by what they state. So one
field must be a clock in a unit of time. The invented logger’s layout:
{
"fields": [
{ "name": "Time (ms)", "kind": "u32" },
{ "name": "Alt (ft)", "kind": "f32" },
{ "name": "Pressure (Pa)", "kind": "f32" },
{ "name": "Accel X (g)", "kind": "f32" }
]
}
A field’s kind is one of u8, i8, u16, i16, u32, i32, u64, i64, f32 or f64.
The first eight are unsigned and signed integers of 8 to 64 bits. "byte_order": "big" reads
big-endian records, and little-endian is the default
(the layout’s schema):
$ hpr analyze validation/fixtures/logs/own-logger/flight.bin --layout validation/fixtures/logs/own-logger/flight.layout.json
flight.bin: read by the layout flight.layout.json
no primary track: each channel on its own clock
readings from the pressure, by the 1976 standard atmosphere, sampled every 0.200 s in steps of 0.093 m, after a 0.40 s running median
3 channels: Alt (ft) (altitude), Pressure (Pa) (pressure), Accel X (g) (acceleration)
liftoff 1.20 s, within 1.06 s, 90% interval 0.69 to 0.99 s
apogee 409.5 m (1344 ft) above the pad, within 33.2 m (109 ft), 90% interval 388.3 to 430.5 m (1274 to 1413 ft); at 10.60 s, within 1.00 s, 90% interval 10.37 to 10.93 s, 9.40 s after liftoff
top speed withheld: the track's samples come every 0.200 s, too far apart for a 0.5 s fit of 5 samples. That fit needs them at most 0.125 s apart
landing 48.60 s, within 2.27 s, 90% interval 48.24 to 49.36 s; 38.00 s from apogee, at 10.7 m/s (35 ft/s) on average, within 2.1 m/s (7 ft/s), 90% interval 9.7 to 11.8 m/s (31 to 39 ft/s)
flight time 47.40 s, within 3.33 s, 90% interval 47.83 to 48.66 s
drogue descent 19.5 m/s (64 ft/s), within 2.0 m/s (7 ft/s), 90% interval 18.2 to 20.7 m/s (60 to 68 ft/s), from apogee at 10.60 s to the main's opening at 24.00 s, 409.5 m (1344 ft) to 148.7 m (488 ft) up; the mean rate from apogee: height lost over time taken, so the fall from rest there is included
main descent 6.0 m/s (20 ft/s), within 0.7 m/s (3 ft/s), 90% interval 5.5 to 6.4 m/s (18 to 21 ft/s), from the main's opening at 24.00 s, within 1.36 s, 90% interval 23.22 to 23.82 s, to landing at 48.60 s, 148.7 m (488 ft) to 1.1 m (4 ft) up
top acceleration withheld: the log's accelerometers (`Accel X (g)`) don't say which lies along the rocket's axis
burnout withheld: as for the top acceleration; and burnout from the speed's peak needs the top speed, which is withheld above
smoothed apogee 407.0 m (1335 ft), 90% interval 385.0 to 428.9 m (1263 to 1408 ft), at 10.40 s
health card pad assumed: too little of it in the log; heights on the readings' zero, noise from the flight's scatter
barometer: 251 samples, 249 fused, 0 rejected, 2 not weighed, 0 resets; 100.0% inside the gate; mean NIS 0.0420; largest test ratio 0.0584 at 11.6 s, Mach 0.02
barometer de-weighted: charge 9.80–11.4 s
pass back: every step smoothed
How far to trust it. The logger's own samples, read by HPR Sim in the units your mapping, layout or
FIP header states, not simulated. They are as right as those units are. Each reading states the
bound its error stayed within on HPR Sim's synthetic flights. They cover rates from 500 to 0.5
samples a second, steps up to 10 m or 100 Pa, and air within 15 K of standard. A reading the log
can't support is withheld, with the reason. The top speed is derived from the heights, and withheld
from Mach 0.8, where a barometer's port may read the flow over the nose. Those bounds hold only if
the units are right. Check a unit against a known height, such as the launch site's elevation from a
GPS altitude. For a record, go by the logger's own figures.
More: https://hpr.fusionspace.co/your-own-logger.html
note: 251 binary records read by the caller's layout, written out as a table and read by its header
A name says a unit, not where the zero is, so Alt (ft) reads as an altitude of unstated zero.
The records have no primary track: a layout can’t mark one yet. So the readings come from the
pressure, turned into a height by the 1976 standard atmosphere and zeroed on the pad.
The serial console’s capture holds the same records, read by the same layout with one more field,
the block’s name: "block": "flight". A capture read by a layout that names no block is refused,
its blocks listed.
$ hpr analyze validation/fixtures/logs/own-logger/flight-capture.txt --layout validation/fixtures/logs/own-logger/flight-capture.layout.json
flight-capture.txt: read by the layout flight-capture.layout.json
no primary track: each channel on its own clock
readings from the pressure, by the 1976 standard atmosphere, sampled every 0.200 s in steps of 0.093 m, after a 0.40 s running median
3 channels: Alt (ft) (altitude), Pressure (Pa) (pressure), Accel X (g) (acceleration)
liftoff 1.20 s, within 1.06 s, 90% interval 0.69 to 0.99 s
apogee 409.5 m (1344 ft) above the pad, within 33.2 m (109 ft), 90% interval 388.3 to 430.5 m (1274 to 1413 ft); at 10.60 s, within 1.00 s, 90% interval 10.37 to 10.93 s, 9.40 s after liftoff
top speed withheld: the track's samples come every 0.200 s, too far apart for a 0.5 s fit of 5 samples. That fit needs them at most 0.125 s apart
landing 48.60 s, within 2.27 s, 90% interval 48.24 to 49.36 s; 38.00 s from apogee, at 10.7 m/s (35 ft/s) on average, within 2.1 m/s (7 ft/s), 90% interval 9.7 to 11.8 m/s (31 to 39 ft/s)
flight time 47.40 s, within 3.33 s, 90% interval 47.83 to 48.66 s
drogue descent 19.5 m/s (64 ft/s), within 2.0 m/s (7 ft/s), 90% interval 18.2 to 20.7 m/s (60 to 68 ft/s), from apogee at 10.60 s to the main's opening at 24.00 s, 409.5 m (1344 ft) to 148.7 m (488 ft) up; the mean rate from apogee: height lost over time taken, so the fall from rest there is included
main descent 6.0 m/s (20 ft/s), within 0.7 m/s (3 ft/s), 90% interval 5.5 to 6.4 m/s (18 to 21 ft/s), from the main's opening at 24.00 s, within 1.36 s, 90% interval 23.22 to 23.82 s, to landing at 48.60 s, 148.7 m (488 ft) to 1.1 m (4 ft) up
top acceleration withheld: the log's accelerometers (`Accel X (g)`) don't say which lies along the rocket's axis
burnout withheld: as for the top acceleration; and burnout from the speed's peak needs the top speed, which is withheld above
smoothed apogee 407.0 m (1335 ft), 90% interval 385.0 to 428.9 m (1263 to 1408 ft), at 10.40 s
health card pad assumed: too little of it in the log; heights on the readings' zero, noise from the flight's scatter
barometer: 251 samples, 249 fused, 0 rejected, 2 not weighed, 0 resets; 100.0% inside the gate; mean NIS 0.0420; largest test ratio 0.0584 at 11.6 s, Mach 0.02
barometer de-weighted: charge 9.80–11.4 s
pass back: every step smoothed
How far to trust it. The logger's own samples, read by HPR Sim in the units your mapping, layout or
FIP header states, not simulated. They are as right as those units are. Each reading states the
bound its error stayed within on HPR Sim's synthetic flights. They cover rates from 500 to 0.5
samples a second, steps up to 10 m or 100 Pa, and air within 15 K of standard. A reading the log
can't support is withheld, with the reason. The top speed is derived from the heights, and withheld
from Mach 0.8, where a barometer's port may read the flow over the nose. Those bounds hold only if
the units are right. Check a unit against a known height, such as the launch site's elevation from a
GPS altitude. For a record, go by the logger's own figures.
More: https://hpr.fusionspace.co/your-own-logger.html
note: read from the block `flight` of a console capture, line 2: 4016 bytes of base64 decoded
note: 251 binary records read by the caller's layout, written out as a table and read by its header
From Python
FlightLog.read reads a log into the record hpr analyze --record prints, by its format’s own
reader, a mapping, a layout or a FIP header. The mapping, layout or FIP header is a dict or the
path of its JSON file. FlightLog.header_mapping gives what a table’s header states, as a dict to
edit. This reads the invented table by its header’s mapping, edited in Python as above, then its
records by their layout:
import numpy as np
from fusionspace import hpr
folder = "validation/fixtures/logs/own-logger"
mapping = hpr.FlightLog.header_mapping(f"{folder}/flight.csv")
mapping["columns"][1]["quantity"] = "altitude_above_ground"
mapping["columns"][1]["unit"] = "ft"
mapping["primary"] = 1
log = hpr.FlightLog.read(f"{folder}/flight.csv", mapping=mapping)
print(log)
top = np.nanmax(log.altitude_m) # a gap is NaN
print(f"highest sample {top:.2f} m ({top / 0.3048:.1f} ft) above the pad")
for channel in log.channels:
print(f"{channel['column']}: {channel['quantity']} in {channel['unit']}")
records = hpr.FlightLog.read(f"{folder}/flight.bin", layout=f"{folder}/flight.layout.json")
print(records)
FlightLog(generic_table, 3 channels, 251 samples on the primary track)
highest sample 410.02 m (1345.2 ft) above the pad
Alt: altitude_above_ground in m
Pressure (Pa): pressure in Pa
Accel X (g): acceleration in m/s²
FlightLog(binary_records, 3 channels, 0 samples on the primary track)
The records’ log has no samples on its primary track, as a layout marks none. Each channel’s
time_s and values are NumPy arrays, a gap NaN. log.to_dict() is the whole record as
hpr analyze --record writes it, without its tool, a gap None. A mapping or a layout that
fails raises HprError naming the field or the column, in the command line’s words.
log.readings() returns the readings hpr analyze takes, as a dict. Its keys
are liftoff, apogee, max_speed, max_acceleration, burnout, landing, flight_time,
drogue_descent and main_descent. Each reading has its status, "read" or "withheld".
A reading read holds its value and its bound. The bound is bound_m for a height, bound_s for a
time, bound_m_s for a speed or a descent rate, and bound_m_s2 for the top acceleration. The
reading also holds its source, provenance and method. The apogee, the top speed, the
top acceleration and burnout also say whether each is a floor, is_floor. The
top acceleration says why it clipped, clip: "range", "flat" or None.
A reading withheld holds its reason and a detail in words. Beside the readings, these say how
they were taken:
- the track’s
source,sample_interval_sandstep_m; - the median’s
median_window_sandpeak_bound_m; pad_altitude_m;- and the
accelerometerread, if any.
Each code is the one the JSON output uses (Flight-log readings). The table’s log, read above:
readings = log.readings()
apogee = readings["apogee"]
print(f"apogee {apogee['height_m']:.1f} m above the pad, within {apogee['bound_m']:.1f} m")
print(f"from the {apogee['source']}, {apogee['provenance']}, by {apogee['method']}")
speed = readings["max_speed"]
print(f"top speed {speed['status']}: {speed['reason']}")
apogee 409.5 m above the pad, within 33.0 m
from the barometer, measured, by highest_filtered
top speed withheld: sampled_too_slowly
fip_header= reads a FIP export below no header, as the command line’s --fip-header does.
sheet= picks a workbook’s sheet, from 0, for a mapping, a FIP header or the sheet’s own reader,
and recording= a raw dump’s recording.
The same combinations are refused as on the command line. A log is read by one of mapping=,
layout= and fip_header=. recording= is refused with any of them or with sheet=, and
sheet= with layout=. This reads the invented FIP export above, then the second flight of the
workbook in A file of several records:
folder = "validation/fixtures/logs/several"
fip = hpr.FlightLog.read(
f"{folder}/fip-below-no-header.xlsx",
fip_header=f"{folder}/fip-below-no-header.header.json",
)
print(fip)
print(fip.notes[0])
second = hpr.FlightLog.read(f"{folder}/two-flights.xlsx", sheet=2)
print(second.notes[0])
FlightLog(raven_fip_csv, 6 channels, 201 samples on the primary track)
read under a header line the caller stated, the rows' own header missing
read from the sheet "Second" of an Excel workbook, its cells as stored
A GPS tracker’s table
A table of GPS fixes, with no barometer, reads by a mapping too. The invented tracker writes its
clock in seconds, its position in degrees and its GPS altitude in meters, once a second. Its
header states the clock’s and the altitude’s units, not the position’s, nor what Sats counts,
so its mapping states them:
{
"header_line": 1,
"separator": ",",
"decimal_comma": false,
"clock": 0,
"columns": [
{
"name": "Time (s)",
"quantity": null,
"unit": "s"
},
{
"name": "Lat",
"quantity": "latitude",
"unit": "deg"
},
{
"name": "Lon",
"quantity": "longitude",
"unit": "deg"
},
{
"name": "GPS Alt (m)",
"quantity": "gnss_altitude",
"unit": "m"
},
{
"name": "Sats",
"quantity": "number",
"unit": null
}
]
}
A GPS altitude is above sea level as the receiver states it, not above the pad. So the mapping marks no primary track, and the readings are withheld, each by name. A receiver’s altitude lags a climb and overshoots its top, so no bound can be stated for it:
$ hpr analyze validation/fixtures/logs/own-logger/gps-track.csv --mapping validation/fixtures/logs/own-logger/gps-track.mapping.json
gps-track.csv: read by the mapping gps-track.mapping.json
no primary track: each channel on its own clock
4 channels: Lat (latitude), Lon (longitude), GPS Alt (m) (GNSS altitude), Sats (number)
liftoff withheld: the log's only height is a GNSS receiver's, whose fix drops out or lags at liftoff
apogee withheld: the log's only height is a GNSS receiver's, whose navigation filter lags a climb and overshoots its top by more than a barometer's bounds allow
top speed withheld: the log's only height is a GNSS receiver's, whose navigation filter lags a climb and overshoots its top by more than a barometer's bounds allow
landing withheld: landing is found against the pad after apogee, and liftoff and apogee were withheld
flight time withheld: the flight time needs liftoff, which is withheld above
drogue descent withheld, as landing is
main descent withheld, as landing is
top acceleration withheld: the log has no accelerometer; HPR Sim doesn't difference a height twice to make one, as its steps would read as spikes of many g
burnout withheld: burnout from the speed's peak needs the top speed, which is withheld above
smoother withheld: the log's only height is a GNSS receiver's, which lags a climb with its fix flagged valid; the smoother needs a barometer to check it against
How far to trust it. The logger's own samples, read by HPR Sim in the units your mapping, layout or
FIP header states, not simulated. They are as right as those units are. Each reading states the
bound its error stayed within on HPR Sim's synthetic flights. They cover rates from 500 to 0.5
samples a second, steps up to 10 m or 100 Pa, and air within 15 K of standard. A reading the log
can't support is withheld, with the reason. The top speed is derived from the heights, and withheld
from Mach 0.8, where a barometer's port may read the flow over the nose. Those bounds hold only if
the units are right. Check a unit against a known height, such as the launch site's elevation from a
GPS altitude. For a record, go by the logger's own figures.
More: https://hpr.fusionspace.co/your-own-logger.html
What it doesn’t do yet
- Take the top acceleration from an accelerometer whose column doesn’t say it lies along the
rocket’s axis, as this logger’s
Accel Xdoesn’t. It doesn’t take one from a board’s three axes either (#781). A mapping has no field that marks a column as the axis yet. - Mark a primary track in a record layout. Binary records’ altitude reads as one of unstated zero.
- Read Excel’s own
.xls, a compound file of several streams, by a reader or a mapping. Only an.xlswritten as one bare worksheet, as an AltiMAX altimeter’s export is, reads. Save any other as.xlsxor CSV. - Read a zip archive’s files, from the command line or Python: unpack it and give the log inside. Both read every other layout the library tells from the file alone by its own reader (the layouts read). They read a workbook’s sheet or a raw dump’s recording as chosen, and another logger’s table or binary records by a mapping or a layout.
Comparing a flight with its simulation
hpr compare shows how far a flight’s logged height, speed and readings lie from a simulation of it.
This page is for a flyer or a team who has flown and wants to see where the simulation parted from the flight. NASA Student Launch’s handbook asks for this comparison after a team’s subscale flight and again after its full-scale flight. Reading a log with no simulation is Reading a flight log.
Run it
Give the log, then the design, its motor and the launch, as hpr sim takes them (the command line).
This example’s log is invented. It is the repository’s Level 1 guide rocket flown in a 6 m/s (13 mph) wind,
with its heights read 4% low and rounded to a foot (how it is made).
The simulation flies the same rocket in calm air, so you can see what a known lean looks like:
$ hpr compare validation/fixtures/logs/compare/level-1-flown.csv validation/fixtures/ork/guides/level-1.ork --mapping validation/fixtures/logs/compare/level-1.mapping.json
level-1-flown.csv against its simulation
flown: level-1.ork, [H170M-10]
clocks: a shared liftoff, within 1.73 s; the log's at 10.10 s, the simulation's 0.10 s after ignition
the simulation's height is read as a barometer on the pad would read it, as the log's is
Residuals, logged less simulated
height
ascent 0.0 to 11.5 s, 116 samples
mean -33.9 m (-111 ft), RMS 37.0 m (122 ft)
largest -49.0 m (-161 ft) at 11.30 s
descent 11.5 to 243.9 s, 2324 samples
mean -26.8 m (-88 ft), RMS 29.5 m (97 ft)
largest -48.9 m (-160 ft) at 11.60 s
speed, up
ascent 0.0 to 11.5 s, 116 samples
mean -4.2 m/s (-14 ft/s), RMS 14.1 m/s (46 ft/s)
largest -44.1 m/s (-145 ft/s) at 0.90 s
descent 11.5 to 243.9 s, 2324 samples
mean +0.2 m/s (1 ft/s), RMS 0.2 m/s (1 ft/s)
largest +2.1 m/s (7 ft/s) at 12.00 s
Readings, the simulation read as the log is
apogee, above the pad
logged 1015.6 m (3332 ft) (measured), within 76.9 m (253 ft), 90% interval 966.6 to 1064.2 m (3171 to 3492 ft)
simulated 1064.4 m (3492 ft)
logged less simulated -48.9 m (-160 ft)
apogee's time, after liftoff
logged 11.55 s (measured), within 1.81 s
simulated 11.50 s
logged less simulated +0.05 s
top speed
withheld on both: the climb's speed reaches 269.4 m/s, at or above 227.7 m/s, where the barometer's port may read the transonic flow over the nose
top acceleration
withheld on both: the log has no accelerometer; HPR Sim doesn't difference a height twice to make one, as its steps would read as spikes of many g
burnout, after liftoff
withheld on both: burnout from the speed's peak needs the top speed, which is withheld: the climb's speed reaches 269.4 m/s, at or above 227.7 m/s, where the barometer's port may read the transonic flow over the nose
flight time
logged 243.90 s (measured), within 4.95 s, 90% interval 244.55 to 245.78 s
simulated 245.20 s
logged less simulated -1.30 s
drogue descent
withheld on both: the descent shows no drogue's leg, which at the ground's density falls faster than 7.2 m/s up to the main's opening. That mark is 1.6 times the rate near the ground, 4.2 m/s, or 3 m/s more if that is more. A drogue's leg would also fall on median faster than 1.4 times the rate near the ground. So the rocket came down under one canopy, or under a drogue no faster than the mark, which reads as one. The main's descent is then the whole descent's, from apogee
main's opening, above the pad
withheld on both: the descent shows one canopy
main descent
logged 4.4 m/s (14 ft/s) (derived), within 0.4 m/s (2 ft/s), 90% interval 4.1 to 4.6 m/s (13 to 15 ft/s)
simulated 4.5 m/s (15 ft/s)
logged less simulated -0.2 m/s (-1 ft/s)
How far to trust it. A log, measured, against a simulation of it, on the inputs you gave. A residual
is the logged value less the simulated one, the sum of what the logger, the simulation and the
lining up of their clocks each got wrong: it can't tell them apart, and it says neither is right.
The simulated numbers state no error here. Each reading states the bound its error stayed within on
HPR Sim's synthetic flights. They cover rates from 500 to 0.5 samples a second, steps up to 10 m or
100 Pa, and air within 15 K of standard. A reading the log can't support is withheld, with the
reason. The top speed is derived from the heights, and withheld from Mach 0.8, where a barometer's
port may read the flow over the nose. For a record or a certification, the altimeter's own reading
is the one to log, and the RSO decides.
More: https://hpr.fusionspace.co/comparing-a-flight.html
note: the file's 1 recovery device flies as OpenRocket flies it. Each opens fully at its event, with the file's drag coefficient or OpenRocket's own. Once one opens, the rocket descends as a point under the open devices' drag alone
note: the log was read in the units your mapping or layout states, so its readings' bounds hold only if those are right
note: a log's main altitude, or a column you mapped, is taken as a barometer's: give --height-reads height-climbed for a GPS receiver's
The height’s mean residual is negative in both phases, because the log reads low. It is largest at apogee, and it shrinks with the height on the way down. A reading says “withheld” when the log can’t support it, with the reason beside it, as here for the top speed and the acceleration. A reading marked “a floor”, which this log has none of, means the true value may lie any amount above it. The notes at the end go to the error stream.
The simulation flies the conditions you give it. With no wind or air given, it flies a calm standard day,
which isn’t the day you flew. --json adds every sample’s residual, for a plot of your own, and holds the notes.
A logger HPR Sim has no reader for is read by --mapping or --layout, as in
Reading your own logger.
What a residual is
A residual is the logged value less the simulated one. A positive height residual means the log read higher than the simulation did. A positive speed residual means the log read faster upward, so during the descent it means a slower fall, and a negative one a faster fall. A descent’s rate in the readings is a size, not a velocity, so there a positive difference means the log fell faster.
They come by phase, cut at the log’s own burnout and apogee: boost, coast and descent; or ascent and descent where the log’s burnout can’t be read whole; or one flight where its apogee can’t. Each phase gives:
- the mean, with its sign, which shows a steady lean;
- the RMS (root mean square), which shows the size whatever the sign;
- the largest, with its sign and when it fell, which shows a single bad moment.
Here is a real one: Bella Lui’s 2020 flight, from the report. Its ascent’s height residual has a mean of −0.2 m (−0.6 ft) and an RMS of 3.2 m (10 ft). Its descent’s mean is −9.0 m (−29 ft) and its RMS 10.3 m (34 ft). So the simulation climbed with the log and then fell a little more slowly than it.
How the two are made comparable
A logged height and a simulated one aren’t the same quantity, so the simulation is read the way the log is. HPR Sim writes the simulated flight as a noise-free log, at the real log’s sample interval (held between 0.01 and 2 s), and hands it to the same reader. Three things follow.
- The height. A barometric logger reads the standard atmosphere’s altitude of the pressure
around it, so on a warm day it reads low. The simulated height is turned into what that barometer would read
in the air you gave the simulation. A log’s main altitude, or a column you map as a pressure or an altitude
above ground or sea level, is taken as a barometer’s. If it is a GPS receiver’s, give
--height-reads height-climbed. A log holding only a GPS channel is refused, as its liftoff can’t be read. The output says which reading it used. - The readings. Apogee, top speed and the rest come through the same filters on both sides. Each logged
reading keeps its bound, its 90% interval and whether it was measured or derived, as
hpr analyzegives it. The simulated cell has no interval or provenance, as it wasn’t measured. In--jsonit keeps a bound, which is only the reader’s. - The clocks. A log’s clock has no ignition on it, so the two line up by what the reader calls liftoff on each. The output gives the bound on that, from 1.32 to 3.21 s on the 7 public flights compared along the climb. That is what the reader can promise of a liftoff, not a measured misalignment. On a log with coarse steps, the log’s liftoff reads late, so an ascent’s height residual leans positive.
The heights are the log’s own samples, not smoothed. An ejection charge’s pressure spike, or a garbled row,
shows as a residual. The speeds are the smoother’s, each with its standard error in
--json, with any GPS set aside on a barometric log, so they stay on the height’s scale. If the smoother can’t
read the log, the speed says why.
What it leaves out
- A log that reads no landing stops at its end, and says so. A log that outlasts the simulated flight counts those samples and compares them with nothing.
- A one-stage design with no parachute falls ballistically after apogee, so a note says its descent means nothing.
hpr simflies no recovery device from a rocket’s.json; an.orkor.hprflies its own. - On a staged flight the simulated track is the stack’s, then the upper stage’s, so a booster’s log compares only up to the split.
- It doesn’t draw a plot yet (M7.3e). It fits nothing: the least-squares fit is in the library, with no command yet.
For a record or a certification, the altimeter’s own reading is the one to log, and the RSO decides.
Your own rocket
Build your own rocket in Rust part by part, find its center of gravity, center of pressure and stability margin, then fly it.
This page builds a rocket from your dimensions, your materials, and a motor from HPR Sim’s bundled catalog. Then it finds the rocket’s center of gravity (CG), its center of pressure (CP) and its stability margin, and flies it. Last, it turns the rocket into a design file and back. It needs the setup from Getting started, and some Rust.
Running the example
Run the program, meet the rocket it builds, and read what it prints.
Run it
cargo run --example own_rocket -p fusionspace-hpr-sim
This runs
crates/hpr-sim/examples/own_rocket.rs,
which prints this:
My 54 mm rocket (Cesaroni 168H54-10A): 1.120 m long, 56.3 mm across
Not yet validated: see the Accuracy page before trusting these numbers.
liftoff burnout
mass (kg) 0.675 0.579
center of gravity (m from nose) 0.671 0.610
center of pressure (m from nose) 0.779 0.779
stability margin (calibers) 1.92 2.99
Normal-force slope (per radian) and center of pressure, at Mach 0.3:
nose 2.00 at 0.102 m
fins 4.82 at 1.060 m
rocket 6.82 at 0.779 m
From a 1.8 m vertical rail, with no wind:
Rail exit: 21.7 m/s
Apogee: 1144.5 m above the pad, at 13.92 s
Top speed: 187 m/s (Mach 0.56)
Ejection: at 13.50 s, at 5.5 m/s
The fin set, as the design file stores it:
{
"id": "fins",
"name": "",
"part": {
"fin_set": {
"count": 3,
"planform": {
"kind": "trapezoidal",
"root_chord_m": 0.1,
"tip_chord_m": 0.04,
"span_m": 0.045,
"sweep_m": 0.05
},
"thickness_m": 0.003175,
"cross_section": "rounded",
"tab": null,
"cant_rad": 0.0,
"base_angle_rad": 0.0,
"material": {
"name": "Birch plywood",
"density": {
"kind": "bulk",
"kg_m3": 680.0
}
}
}
},
"position": {
"from": "bottom",
"aft_offset_m": 0.0
}
}
Like the first flight’s in Getting started, this output is committed in
own_rocket.output.txt.
CI (the project’s automated checks) runs the program on macOS, Windows and Linux, and fails if it
prints anything else.
To fly your own rocket, change the numbers in the program and run it again. Or copy it to a new
file in the same folder, say my_rocket.rs, and run that with
cargo run --example my_rocket -p fusionspace-hpr-sim.
The rocket
The rocket has a 54 mm (2.1 in) airframe (the tube’s inside diameter). It flies on a Cesaroni H54, a 29 mm reloadable motor (a propellant load for a reusable case). These are the program’s inputs:
| part | Rust type | in the program |
|---|---|---|
| nose cone | NoseCone | a tangent ogive (Shapes) 0.22 m (8.7 in) long, of ABS with a 1.5 mm (0.059 in) wall, and a 6 cm (2.4 in) shoulder that slides into the tube |
| airframe | BodyTube | 0.9 m (35 in) of kraft phenolic tube, outer radius 0.02815 m (1.108 in), 56.3 mm (2.2 in) across, 1.15 mm (0.045 in) wall |
| motor mount | InnerTube | 0.2 m (7.9 in) long, outer radius 0.0155 m (0.610 in), 1 mm (0.039 in) wall, so a 29 mm (1.1 in) bore; flush with the airframe’s aft end, with the nozzle 5 mm (0.20 in) past it |
| fins | FinSet | three trapezoidal fins of 1/8 in (3.175 mm) birch plywood with rounded edges: root chord 0.1 m (3.9 in), tip chord 0.04 m (1.6 in), span 0.045 m (1.77 in), and the tip’s leading edge 0.05 m (2.0 in) aft of the root’s |
| recovery bay | MassComponent | 200 g standing in for the parachute, shock cord and altimeter, packed as a cylinder 0.15 m (5.9 in) long and 50 mm (2.0 in) across (packing), 7 cm (2.8 in) below the airframe’s top |
| motor | MountedMotor | the Cesaroni 168H54-10A from the bundled catalog, with a 10 s ejection delay |
Every size is in meters, and every round part takes a radius, not a diameter: halve the diameters on your drawings.
What it printed
Mass, center of gravity and center of pressure
The liftoff column is the rocket on the pad, with the motor full. The burnout column is the rocket with the motor spent. Its case and nozzle are still aboard.
- Mass: 0.675 kg on the pad and 0.579 kg at burnout. The 0.096 kg between them is the propellant; the catalog lists 96.6 g for this motor.
- Center of gravity: where the mass balances, as a station: meters aft of the nose tip. It moves forward, from 0.671 m (26.4 in) to 0.610 m (24.0 in), as the propellant in the tail burns away.
- Center of pressure: where the air’s sideways push acts, 0.779 m (30.7 in) aft of the tip. It depends on the rocket’s shape and speed, not its mass, so it’s the same in both columns. Both use Mach 0.3, with the air straight along the rocket’s axis.
- Stability margin: how far the CP lies behind the CG, in calibers, in body diameters. At liftoff it’s (0.779 − 0.671) m ÷ 0.0563 m ≈ 1.9; the program works from the unrounded values and prints 1.92. At burnout the CG has moved forward, so the margin has grown to 2.99. This program works the margin out by hand. The simulator also gives it from the rail exit to apogee or the first deployment, with an optimum ejection delay, as Flight metrics shows.
A positive margin means that when something tips the rocket, the air turns its nose back into the oncoming air. That oncoming air is the relative wind: the airflow the rocket feels, from its motion over the ground combined with the wind. In a crosswind, the same turn swings the rocket upwind (weathercocking).
The simulator doesn’t judge whether a margin is enough; your club’s or range’s rules do.
Where the center of pressure comes from
Barrowman’s method works out each nose cone, transition and fin set on its own. Each gets a CP and a normal-force slope: how fast its sideways push grows with the angle of attack, per radian. A plain body tube has no line of its own: its sideways push appears only at larger angles, so its slope is zero. The rocket’s CP is the average of the parts’ CPs, each weighted by its slope:
| part | slope (per rad) | CP (m from the nose tip) | slope × CP (m/rad) |
|---|---|---|---|
| nose | 2.00 | 0.102 | 0.204 |
| fins | 4.82 | 1.060 | 5.109 |
| rocket | 6.82 | 5.313 |
So the CP is 5.313 ÷ 6.82 ≈ 0.779 m (30.7 in). The fins sit far aft and have more than twice the nose’s slope, so they pull the CP toward the tail. Moving the CP aft (bigger fins, or fins farther aft) or the CG forward (a heavier nose) raises the margin.
How speed moves the CP. In the simulator, only a fin set’s terms change with the Mach number (Aerodynamics). The fin set’s slope grows as the rocket speeds up toward Mach 1, and from Mach 0.8 its own CP moves aft too.
- With the fins at the tail, as here, the growing fin slope pulls the rocket’s CP aft as it speeds up.
- With canards (a second fin set near the nose), their slope grows too and pulls the CP forward. So which way the CP moves depends on both fin sets.
- HPR Sim keeps fin sets’ CPs a quarter of the way along their mean aerodynamic chords, a kind of average chord, up to Mach 0.8. From there it moves each CP aft, toward where supersonic linear theory puts it (Aerodynamics). Niskanen’s 2009 thesis, which the simulator’s aerodynamics also draw on, starts moving the fins’ CP at Mach 0.5. NASA’s wind tunnel found an Arcas Robin rocket’s CP moving forward, not aft, between Mach 0.6 and 0.8, so HPR Sim doesn’t. This rocket’s top speed, Mach 0.56, is well below either.
Flow::axial(0.0) in place of Flow::axial(0.3) gives the low-speed value Barrowman’s method
gives by hand.
The flight
The rocket flies from a 1.8 m (5.9 ft) vertical rail, 1,400 m (4,593 ft) up in New Mexico, with no wind. It has one parachute, 0.9 m (35 in) across (nominal diameter), which opens when the motor’s ejection charge fires.
- Rail exit: 21.7 m/s (71 ft/s). The design has no rail buttons, so the simulator takes the rocket as off the rail when its aft end passes the top (rail exit).
- Apogee: 1,144.5 m (3,755 ft) above the pad, 13.92 s after ignition (apogee).
- Top speed: 187 m/s (614 ft/s), Mach 0.56: the fastest airspeed at the end of any time step. With no wind, the airspeed is also the speed over the ground.
- Ejection: at 13.50 s, at 5.5 m/s (18 ft/s). The charge fires the 10 s delay after burnout. In the simulator, burnout is the thrust curve’s last point, 3.50 s for this motor. The ejection comes 0.42 s before apogee, while the rocket is still climbing slowly.
This motor has three times near the end of its burn, and they measure different things:
| time | what it is | where it comes from |
|---|---|---|
| 3.12 s | the burn time ThrustCurve.org publishes for the motor | the bundled catalog, which copies ThrustCurve.org’s values |
| 3.13 s | the burn time the simulator works out from this motor’s thrust curve, by the same NFPA 1125 rule: from when the thrust first reaches 5% of its peak to when it last falls to 5% | Solid motors lists it |
| 3.50 s | burnout: the curve’s last point, where the thrust reaches zero | the thrust curve; the ejection delay counts from here |
- The first two differ by 0.01 s. The simulator bundles a motor only if its computed burn time is within 1% of ThrustCurve.org’s (Solid motors).
- From 3.13 s to 3.50 s the motor still pushes, with under 5% of its peak thrust. The curve’s peak is 103 N, so that’s under about 5 N. The burn time leaves that tail out; the flight doesn’t.
The fin set as a design file
The last lines are the fin set in a design file’s JSON. As a design file explains the form.
The program, step by step
This is the whole program, line for line the file CI runs.
//! Your own rocket: a 54 mm rocket built part by part in Rust, with a motor from the bundled
//! catalog. It prints the rocket's mass, center of gravity, center of pressure and stability
//! margin, then flies it.
//!
//! Run it from anywhere in the repository:
//!
//! ```text
//! cargo run --example own_rocket -p fusionspace-hpr-sim
//! ```
//!
//! The documentation site's *Your own rocket* page (`docs/your-own-rocket.md`) walks through it.
//! What it prints is kept next to it in `own_rocket.output.txt`, and CI checks that the two still
//! agree (`cargo xtask examples --check`).
#![allow(
clippy::print_stdout,
reason = "the project's lints forbid printing in library code, and this program exists to print"
)]
use std::error::Error;
use hpr_aero::{AeroModel, Flow};
use hpr_core::geodesy::Geodetic;
use hpr_design::{
AutoDimension, BodyTube, Component, Configuration, FinCrossSection, FinPlanform, FinSet,
Ignition, InnerTube, MassComponent, Material, MotorMount, MountedMotor, NoseCone, NoseShape,
Overrides, Packing, Part, Position, ReferenceDiameter, Rocket, Shoulder, Stage, Wall,
materials,
};
use hpr_motor::{Catalog, Delay};
use hpr_sim::{
CanopyType, Channel, Device, DeviceDrag, Environment, EventKind, FlightSettings, Rail,
Recorder, Simulation, Trigger,
};
fn main() -> Result<(), Box<dyn Error>> {
// The nose: a 22 cm tangent ogive of ABS with a 1.5 mm wall and a 6 cm shoulder. Its base
// radius and its shoulder's radius are automatic: they fit the tube behind it.
let mut nose = component(
"nose",
Part::NoseCone(NoseCone {
shape: NoseShape::Ogive { radius_ratio: 1.0 },
length_m: 0.22,
base_radius_m: 0.0,
wall: Wall::Shell {
thickness_m: 0.0015,
},
shoulder: Some(Shoulder {
length_m: 0.06,
outer_radius_m: 0.0,
thickness_m: 0.0015,
capped: true,
}),
material: material("abs")?,
}),
None,
);
nose.auto = vec![AutoDimension::BaseRadius, AutoDimension::ShoulderRadius];
// The airframe: 90 cm of kraft phenolic tube, 56.3 mm across, with a 1.15 mm wall.
let mut airframe = component(
"airframe",
Part::BodyTube(BodyTube {
length_m: 0.9,
outer_radius_m: 0.02815,
thickness_m: 0.00115,
material: material("kraft_phenolic")?,
}),
None,
);
// Inside it, flush with its aft end, a 20 cm motor mount tube with a 29 mm bore. The motor's
// nozzle will stick out 5 mm past it.
let mut mount = component(
"motor-mount",
Part::InnerTube(InnerTube {
length_m: 0.2,
outer_radius_m: 0.0155,
thickness_m: 0.001,
radial_offset_m: 0.0,
angle_rad: 0.0,
material: material("kraft_phenolic")?,
cluster_m: Vec::new(),
}),
Some(Position::Bottom { aft_offset_m: 0.0 }),
);
mount.motor_mount = Some(MotorMount { overhang_m: 0.005 });
// Three trapezoidal fins of 1/8 in birch plywood, flush with the aft end.
let fins = component(
"fins",
Part::FinSet(FinSet {
count: 3,
planform: FinPlanform::Trapezoidal {
root_chord_m: 0.1,
tip_chord_m: 0.04,
span_m: 0.045,
sweep_m: 0.05,
},
thickness_m: 0.003175,
cross_section: FinCrossSection::Rounded,
tab: None,
fillet: None,
cant_rad: 0.0,
base_angle_rad: 0.0,
material: material("birch_plywood")?,
}),
Some(Position::Bottom { aft_offset_m: 0.0 }),
);
// The parachute, shock cord and altimeter, as one 200 g mass 7 cm below the tube's top, clear
// of the nose's shoulder. Its packing is the cylinder the mass fills: 15 cm long, 5 cm across.
let packing = Packing {
length_m: 0.15,
radius_m: 0.025,
radial_offset_m: 0.0,
angle_rad: 0.0,
};
let bay = MassComponent {
mass_kg: 0.2,
packing,
};
let top = Position::Top { aft_offset_m: 0.07 };
let bay = component("recovery-bay", Part::MassComponent(bay), Some(top));
// The fin set as a design file stores it, to print at the end.
let fins_json = serde_json::to_string_pretty(&fins)?;
airframe.children = vec![mount, fins, bay];
// The motor: a Cesaroni H54 from the bundled catalog, found by its designation, with the
// catalog's size, masses and thrust curve, and the 10 s delay its designation names.
let catalog = Catalog::bundled()?;
let entry = catalog
.find("168H54-10A")
.next()
.ok_or("not in the catalog")?;
let motor = MountedMotor {
mount: "motor-mount".to_owned(),
designation: entry.designation.clone(),
diameter_m: entry.diameter_mm / 1000.0,
length_m: entry.length_mm / 1000.0,
motor: entry.bundled_motor()?,
delay: Some(Delay::Seconds(10.0)),
ignition: Ignition::Launch,
failed_tubes: Vec::new(),
};
// The rocket: one stage, and one configuration, "h54", with that motor in the mount.
let rocket = Rocket {
name: "My 54 mm rocket".to_owned(),
stages: vec![Stage {
id: "sustainer".to_owned(),
name: String::new(),
components: vec![nose, airframe],
overrides: Overrides::default(),
override_rule: Default::default(),
added_mass: None,
drag_override: None,
parallel: None,
}],
reference_diameter: ReferenceDiameter::Maximum {},
configurations: vec![Configuration {
id: "h54".to_owned(),
name: String::new(),
motors: vec![motor],
}],
};
// Place the parts and the motor, and find the mass properties with the motor full and spent.
// A point `s` meters aft of the nose tip is at z = -s in the body frame.
let assembly = rocket.assemble("h54")?;
let full = assembly.mass_properties(0.0);
let spent = assembly.dry_mass_properties();
let (cg_liftoff_m, cg_burnout_m) = (-full.cg_m.z, -spent.cg_m.z);
// The center of pressure by Barrowman's method, at Mach 0.3 with the air straight along the
// axis. Barrowman's slopes are the small-angle limit, so this is the CP at small angles.
let flow = Flow::axial(0.3);
let aero = AeroModel::new(&assembly.layout)?;
let total = aero.normal_force(&flow)?;
let cp_m = total.cp_station_m.ok_or("no normal force")?;
let calibers = |cg_m: f64| (cp_m - cg_m) / assembly.layout.reference_diameter_m;
println!(
"{} ({} {}): {:.3} m long, {:.1} mm across",
rocket.name,
entry.manufacturer_abbrev,
entry.designation,
assembly.layout.length_m,
assembly.layout.reference_diameter_m * 1000.0,
);
println!("Not yet validated: see the Accuracy page before trusting these numbers.");
println!();
println!(" liftoff burnout");
let (m0, m1) = (full.mass_kg, spent.mass_kg);
println!("mass (kg) {m0:>7.3} {m1:>9.3}");
println!("center of gravity (m from nose) {cg_liftoff_m:>7.3} {cg_burnout_m:>9.3}");
println!("center of pressure (m from nose) {cp_m:>7.3} {cp_m:>9.3}");
let (s0, s1) = (calibers(cg_liftoff_m), calibers(cg_burnout_m));
println!("stability margin (calibers) {s0:>7.2} {s1:>9.2}");
println!();
println!("Normal-force slope (per radian) and center of pressure, at Mach 0.3:");
for part in aero.components(&flow)? {
let force = part.normal_force;
if let Some(station_m) = force.cp_station_m {
let (id, slope) = (&part.id, force.slope_per_rad);
println!("{id:<10} {slope:>5.2} at {station_m:.3} m");
}
}
let slope = total.slope_per_rad;
println!("{:<10} {slope:>5.2} at {cp_m:.3} m", "rocket");
// Fly it from a 1.8 m vertical rail, 1,400 m up in New Mexico, with no wind. The parachute
// opens when the motor's ejection charge fires, 10 s after burnout.
let site = Geodetic::from_degrees(32.99, -106.97, 1400.0)?;
let parachute = Device::new(
"parachute",
DeviceDrag::canopy(CanopyType::FlatCircular, 0.9),
Trigger::MotorDelay { motor: 0 },
);
let simulation = Simulation::new(
&rocket,
"h54",
Environment::standard(site)?,
Rail::vertical(1.8),
FlightSettings::default(),
)?
.with_recovery(vec![parachute])?;
// A recorder keeps the airspeed and the Mach number at the end of every step.
let mut recorder = Recorder::new(vec![Channel::Airspeed, Channel::Mach], None)?;
let flight = simulation.run(&mut recorder)?;
let rows = recorder.rows();
let fastest = rows.iter().max_by(|a, b| a[0].total_cmp(&b[0]));
let fastest = fastest.ok_or("no steps")?;
let rail_exit = flight.event(EventKind::RailExit).ok_or("no rail exit")?;
let apogee = flight.event(EventKind::Apogee).ok_or("no apogee")?;
let ejection = flight.event(EventKind::Trigger(0)).ok_or("no ejection")?;
let (rail_exit, apogee, ejection) = (rail_exit.sample, apogee.sample, ejection.sample);
println!();
println!("From a 1.8 m vertical rail, with no wind:");
let speed_m_s = rail_exit.cg_velocity_enu_m_s.length();
println!("Rail exit: {speed_m_s:.1} m/s");
let (height_m, time_s) = (apogee.height_above_ground_m, apogee.time_s);
println!("Apogee: {height_m:.1} m above the pad, at {time_s:.2} s");
println!("Top speed: {:.0} m/s (Mach {:.2})", fastest[0], fastest[1]);
let (time_s, speed_m_s) = (ejection.time_s, ejection.cg_velocity_enu_m_s.length());
println!("Ejection: at {time_s:.2} s, at {speed_m_s:.1} m/s");
// The whole rocket as a design file's text, JSON, and read back from it.
let text = serde_json::to_string_pretty(&rocket)?;
let read_back: Rocket = serde_json::from_str(&text)?;
if read_back != rocket {
return Err("the design file doesn't read back as the same rocket".into());
}
println!();
println!("The fin set, as the design file stores it:");
println!("{fins_json}");
Ok(())
}
/// A built-in material by its id; `hpr_design::materials` lists them, each with its source.
fn material(id: &str) -> Result<Material, String> {
materials::find(id)
.map(|builtin| builtin.material())
.ok_or_else(|| format!("no built-in material `{id}`"))
}
/// A node of the design tree holding `part`, placed at `position` along its parent. Body
/// components (nose cones, body tubes and transitions) have no position: they stack from the nose.
fn component(id: &str, part: Part, position: Option<Position>) -> Component {
Component {
id: id.to_owned(),
name: String::new(),
part,
position,
auto: Vec::new(),
motor_mount: None,
finish: None,
overrides: Overrides::default(),
overrides_include_children: false,
drag_override: None,
children: Vec::new(),
}
}
It has eight steps.
- The parts. Each part is a Rust value from the
hpr_designcrate, wrapped in aComponent. A component is a node of the design tree, with an id, the part, and where it sits. Thecomponenthelper at the program’s end fills in the fields a part seldom needs: a display name, a surface finish, mass overrides and children.Partlists every kind of part. - Where each part sits. Nose cones, body tubes and transitions are body components. They
go in a stage’s list, nose first, and stack from the nose tip aft, so they have no position.
Every other part hangs from a body component, or from an inner tube, and has a
Position. A position isTop,Middle,Bottom,AfterorAbsolute, with an offset in meters, positive aft (Positions). The mount and the fins are atBottomwith no offset, flush with the aft end.- A dimension named in a component’s
autolist is taken from the parts around it, and the value stored for it (0 here) is ignored. The nose’s base radius and its shoulder’s radius follow the airframe (Automatic dimensions). Other parts can take theirs the same way: a tube fin set’souter_radius_m, for one, can be automatic. Then three tubes or more are wide enough to touch the body and each other, and no wider, closing the ring. One or two tubes take the body’s radius. - Setting
motor_mountmakes a body tube or inner tube a motor mount. Itsoverhang_mis how far the nozzle sits aft of the mount’s end. - A
MassComponentis a mass and itsPacking: the size of the solid cylinder the simulator spreads the mass through. Here it’s 0.15 m (5.9 in) long withradius_m0.025, so 50 mm (2.0 in) across, inside the airframe’s 54 mm (2.1 in) bore.- The length places the mass. Its CG is the cylinder’s middle, 0.145 m (5.71 in) below the airframe’s top, since the cylinder starts 7 cm (2.8 in) down.
- Of the mass properties, the radius changes only the moments of inertia: how hard the mass is to turn.
- A cylinder a little wider than the tube’s bore, within the
fit tolerance, gets a warning; any wider is an
error.
AutoDimension::PackedRadiusin the component’sautolist fits it to the bore instead. radial_offset_mandangle_radmove it off the rocket’s axis. Parachutes, streamers and shock cords have a packing too.
- A dimension named in a component’s
- Materials.
material("abs")looks up one of the simulator’s 49 built-in materials by its id, each with the source of its density (Mass properties). Thematerialspage of the API reference lists them. For a material of your own,Material::bulk(name, kg_m3)takes a name and a density in kg/m³. - The motor.
Catalog::bundled()is the catalog of ThrustCurve.org’s 1,004 solid motors that comes with the simulator.findlooks one up by its designation or common name, ignoring case, spaces and hyphens, so"h54"finds this one too.bundled_motor()builds the motor from its thrust curve and the catalog’s size and masses.- The
MountedMotornames the mount by its id, and carries the ejection delay and the case’s diameter and length. It says when the motor lights:Ignition::Launchhere, and a later time for an air start or a sustainer (Staging). - The design checks compare the case with its mount. A case wider than the mount’s bore is an error. But a nominal 29 mm motor in a 1.140 in (28.956 mm) tube only warns. That’s because the real case is narrower than its name (a nominal motor in its matching tube).
- While the motor burns, the simulator also uses the case’s diameter for the base drag, the drag on the rocket’s flat aft end. The part of that end the burning case covers gets none.
- Solid motors describes the bundled motors, and shows how to use a motor file of your own, such as one from ThrustCurve.org, instead.
- The
- The rocket. A
Rocketholds its stages (one here), how its reference diameter is chosen, and its configurations.ReferenceDiameter::Maximum {}takes the diameter of the widest body part, the 56.3 mm (2.2 in) airframe. The margin and the aerodynamic coefficients are measured by that diameter (reference area). A configuration is one choice of motors, at most one per mount, under an id; this rocket has one,"h54". Add another to compare motors in the same rocket. - Mass, CG and CP.
assembleplaces every part and the configuration’s motor, and returns anAssembly.- Its
mass_properties(t)is the whole rockettseconds after ignition, anddry_mass_properties()is the rocket with every motor spent. - Each gives a mass, a CG and the moments of inertia, which the flight needs. The CG,
cg_m, is in the body frame, whose origin is the nose tip and whose axis points forward, out through the nose. So a point meters aft of the tip has , and the CG’s station is−cg_m.z. AeroModel::newbuilds the aerodynamic model from the placed parts. Itsnormal_force, atFlow::axial(0.3)(Mach 0.3, with the air straight along the axis), returns the rocket’s slope and its CP,cp_station_m. Barrowman’s slopes are the small-angle limit, so this is the CP at small angles of attack.components, at the same flow, returns each part’s share.- The margin is the CP’s station less the CG’s, divided by the reference diameter,
assembly.layout.reference_diameter_m.
- The flight. This is as in Getting started,
with three differences.
Simulation::newnames the configuration to fly,"h54", and runs the design’s checks first (Checks).- The parachute’s trigger is
Trigger::MotorDelay { motor: 0 }: the ejection charge of the configuration’s first motor (Recovery). - A
Recorderkeeps the airspeed and the Mach number at the end of every step, and the program takes the row with the highest airspeed. Recording a trajectory explains recorders.
- The design file. The end of the program writes the rocket as JSON, reads it back, and prints the fin set’s part of it. As a design file explains.
Design files
Write the rocket as a design file, and see what else a design can hold.
As a design file
A design file is a rocket written as text, to keep, share or edit outside Rust. Here it’s the
rocket’s JSON. That’s also the rocket key of a document of
the HPR design format. That form adds a versioned header, the motor
configurations, recovery and what a .ork held. To write the JSON and read it back:
serde_json::to_string_pretty(&rocket)gives the text, andstd::fs::writesaves it to a file.serde_json::from_str::<Rocket>(&text)reads it back. The program checks that the rocket it reads back is the one it wrote.
The JSON follows the Rust types, so the API reference documents every key. The fin set at the end of the output shows the rules:
| in Rust | in the JSON | in the output |
|---|---|---|
| a struct’s field | a key with the field’s name | "thickness_m": 0.003175 |
| the unit in the name | SI units: _m meters, _kg kilograms, _rad radians, kg_m3 kg/m³ | "span_m": 0.045 |
a Part | an object with one key, the kind of part | "part": { "fin_set": { … } } |
| a shape, planform, wall, density, finish or delay | an object whose "kind" names it | "planform": { "kind": "trapezoidal", … } |
a Position | an object whose "from" names it | "position": { "from": "bottom", "aft_offset_m": 0.0 } |
| a choice with no values | a string | "cross_section": "rounded" |
None | null | "tab": null |
- Some keys can be left out, and take a default: a component’s
name, or a fin set’stab,filletandcant_rad, for example.cant_radis the fins’ cant in radians, 0 by default; a cant spins the rocket (Roll: forcing and damping).filletgives the fins’ fillets, a radius and a material. It isn’t written when there are none, so the output above has nofilletkey. In Rust it’s, for example,fillet: Some(FinFillet { radius_m: 0.005, material: material("epoxy")? }), withFinFilletadded to theuse hpr_design::{…}list. - A key the simulator doesn’t know is refused, so a misspelt key is an error rather than silently ignored.
- A mounted motor is stored whole: its thrust curve, masses and size. Its
designationis only a label, so a design file doesn’t depend on the catalog.
For a complete file of a similar rocket, see
synthetic-54mm-three-fin.json.
The rocket has centering rings, rail buttons, a parachute and a shock cord as parts, and flies on
a 38 mm Cesaroni I175. A program in the repository writes the files in that folder, so edit a copy
rather than the file.
The file holds the rocket alone. It’s the rocket key of the open design format, a
documented and versioned design file with a schema, without the
rest of a .hpr file. The repository’s own designs are still kept this way.
What else a design can hold
The example leaves out several kinds of part and setting a design can have:
- More parts: transitions, centering rings (whose radii can be automatic), launch lugs, rail buttons, parachutes, streamers and shock cords. Fins can be elliptical or freeform too (The design tree).
- With rail buttons or launch lugs, the rocket leaves the rail when its last rail guide passes the top, not its aft end.
- Weighed masses go in an
Overrides. It sets a part’s mass, CG or inertia to measured values, for the part alone or with everything attached to it (Overrides). hpr_design::checks::checklists a design’s problems (Checks). Errors, such as a motor wider than its mount, describe a rocket that can’t exist, and a simulation refuses them. Put the 38 mm motorH170Min this program’s 29 mm mount and it stops withMotorWiderThanMount. Warnings, such as a step in the body’s radius, don’t stop a flight.
Limits and next steps
What the example can’t do yet, and where to go from here.
What it can’t do yet
- A rocket is built only in code or in JSON. The builder builds the same rocket
in fewer lines of Rust, and the Python bindings build one from
Python.
hpr simflies the JSON file from a terminal, but opens no parachute. A design file can carry a parachute’s weight as a mass part, but not the parachute itself or when it opens. - HPR Sim imports designs from one other program. OpenRocket
.orkfiles are read (.orkdesign files). On a file’s own curves and the bundled motors alone, most motor configurations fly.hpr simlooks up a missing curve once and keeps what it finds (how many fly). Their parachutes and streamers fly as OpenRocket flies them. RockSim.rktfiles can’t be read yet (RockSim import). - Drag near and past Mach 1 is lightly checked. Since drag through Mach 1 was built, the simulator’s own drag carries a flight from Mach 0 to 5, like its normal force. A flight that reaches Mach 5 stops with an error. Near and above the speed of sound, the drag has been checked against one wind tunnel, which measured from Mach 0.6 to 4.63. The simulator reads high there at every Mach number the tunnel measured, most of all with fins past Mach 1 (Aerodynamics).
- Against a worked example in a U.S. Army design handbook, the body alone reads a little low faster than sound. Against RASAero II’s drag for Calisto, a rocket with a short, steep boattail, the whole rocket reads low faster than sound. From Mach 1.05 to 2, where the comparison stops, it reads 5% to 15% low (Aerodynamics). It read about a quarter low until the simulator modeled a boattail’s drag faster than sound, and the rest is only partly explained.
- If your rocket goes supersonic, its drag there may be off either way. It may read low with a steep boattail. With thin, sharp fins, the drag of all but the base read 29.8% to 154.1% high from Mach 1.2 against the wind tunnel above. Treat a supersonic flight’s apogee as rough.
- Staging needs its settings. A motor lights at launch unless its
ignitionsays otherwise. So a two-stage design flies with both stages burning at once, until you give the sustainer its ignition and the flight a separation (Staging). A.orkfile’s own ignitions and powered separations are read for you. The ignitions come with the rocket, but the separations don’t. - Turn the configuration’s
stagings()into the flight’s separations withhpr::ork::separations, and pass them to the flight. Give each part a recovery device too, since the simulator refuses the flight without them. The exampleork_two_stage.rsdoes both. The flights of OpenRocket’s two-stage, three-stage, cluster, air-start and parallel-booster examples are within 5% of OpenRocket’s apogee and largest speed, with three cluster apogees compared with OpenRocket’s flight without the cluster’s parachute, which opened before apogee (a two-stage and a cluster design against OpenRocket; results). One of a pod example’s staged flights isn’t: in the conditions of OpenRocket’s recorded flight its sustainer turns over before apogee in both programs, and reads 37.93% low (Design files). - Pieces that land on their own are yours to declare. A nose cone on a shock cord comes down with
its rocket, and that’s what the simulator flies unless you say otherwise. To fly a nose cone, a
section or a payload that leaves and lands on its own, give the flight an
Ejectionfor each. Give each piece a recovery device too: a parachute, or its own tumble (Simulation::tumbling_piece). An ejection can push the pieces apart with the charge’s impulse (Ejection::with_impulse). - A
.orkfile’s recovery settings don’t make these ejections for you. A stage whose mass is overridden can’t be parted inside: remove the override, or put it on the components instead. Ejected pieces are checked against exact answers only (Recovery: ejected pieces, with the exampleejected_pieces.rs). - Mass that moves in flight is yours to declare too. To slide ballast or a payload along the
airframe, give the flight a
MassShiftfor it withSimulation::with_shifts. A shift gives the part’sid, how far it moves (positive toward the tail), how long it takes, and a trigger. The triggers are the same kinds a parachute has. The center of mass, the inertia and the stability margin follow it, andSimulation::mass_propertiesgives them at any time. - A shift must start after the rocket leaves the rail. A flight that separates or ejects pieces
can’t have one yet. Moving mass is checked against exact answers only
(Moving mass, with the example
moving_ballast.rs). - Mass released in flight is yours to declare too. To let ballast or a payload go, give it a
MassReleasewithSimulation::with_releases. A release gives the part’sid, a trigger, and the part’s own drag area once it’s out. The rest flies on without it, and the part falls to the ground on its own (FlightResult::released). - A release must come after the rocket leaves the rail. A flight can’t combine one with a
separation, ejected pieces or a mass shift yet. Check the stability margin after a release: the
simulator doesn’t warn. Released mass is checked against exact answers only
(Released mass, with the example
released_ballast.rs). - The simulator flies commercial solid motors only (COTS motors). With only catalog data, a motor’s own CG stays at its mid-length, full or spent (Solid motors).
- Tube fins fly as ring wings, below Mach 0.8, with three tubes or more. Tube fins are open tubes that run along the body, touching it, in place of flat fins. Each tube’s slope comes from a cited ring-wing formula. Its center of pressure comes from Fletcher’s wind-tunnel rings for short tubes. For tubes longer than 1.5 diameters, the center of pressure comes from this project’s own derivation, a judgment.
- The tube fins’ drag applies the flat fins’ rules. No tube fin rocket has been checked against a measurement. HPR Sim’s tube-fin drag probably reads low, so treat an apogee as high. On OpenRocket’s example HPR Sim’s margin is 0.79 calibers against OpenRocket’s 1.87; nothing measured says which is right.
- A flight that reaches Mach 0.8 stops with the tube-fin model’s error. The simulator also refuses fewer than three tubes, solid tubes, and tubes that overlap each other. It refuses a tube shorter than a third of its diameter, and tube fins on a pod or a tumbling airframe (aerodynamics: Tube fins).
- Pods fly on Barrowman’s rules, without their interference with the body. A pod set gives each pod’s parts their own normal force and drag, once per pod. It’s as if the airframe didn’t disturb the air around them. Nothing measured checks the pods yet, and a single pod’s off-axis moments are left out (aerodynamics: Pods). Canted fins on a pod are refused.
- Two nose shapes have no drag of the simulator’s own, on a nose cone or a widening transition,
since no drag data covers them. One is a bulged secant ogive:
NoseShape::Ogivewith aradius_ratiobelow 1, which bulges wider than the body just ahead of its base. The other is a Haack shape whose parameter is above 1/3, past the LV-Haack (Shapes). - Since drag through Mach 1 was built, the drag buildup refuses those two nose shapes, naming the part. The CP still works, and so does a flight on a drag table from another tool. A flight on the simulator’s own drag stops with that error.
- Faster than sound, every fin section takes a blunt leading edge’s drag. The square section takes a flat face’s, and the rounded and airfoil sections a rounded edge’s. The airfoil section differs from the rounded only in having no trailing-edge base drag. A blunt edge’s drag reads far high for thin, sharp fins. The one wind tunnel the simulator was measured against tested only double-wedge fins, so how well square or rounded edges fare is unmeasured (Drag limits).
Where next
- Getting started adds wind, tilts the rail and uses a drogue and a main parachute; the same code works with this rocket.
- Recording a trajectory keeps the whole flight as a table.
- The design tree, Mass properties and Aerodynamics explain the models behind these numbers.
How a flight is simulated
See what lies behind each number HPR Sim prints, stage by stage from ignition to landing, and which model computes it.
This page uses plain words. Read it before the model pages it links.
The drawing is the shape of the Getting started example’s flight, not to scale. Its apogee is 779 m (2,556 ft) up and 88.7 m (291 ft) west of the pad. It lands 90.2 m (296 ft) east of the pad.
What goes in
Building a simulation gathers five inputs, and works out once everything that doesn’t change during the flight.
| input | what the simulator takes from it | pages |
|---|---|---|
| the rocket | A tree of parts, such as a nose cone, body tubes and a fin set, with their positions. Their shapes and materials give each part’s mass, center of gravity and inertia. The design’s checks run first, and a rocket that can’t exist, such as one with a motor wider than its mount, is refused | Design tree, Shapes, Mass properties |
| the motor | The thrust at every instant, from its thrust curve. Its mass, center of gravity and inertia as its propellant burns away, so the whole rocket gets lighter, and its center of gravity moves, during the burn | Solid motors |
| the aerodynamics | Built from the rocket’s shape and surface: the normal force on each body part and fin set, the center of pressure where it acts, and the drag. They depend on the Mach number, the angle of attack and the Reynolds number | Aerodynamics |
| the surroundings | The launch site on the WGS 84 model of the Earth’s shape, and the launch frame: east, north and up from the pad. Gravity that changes with latitude and height, and the Coriolis acceleration, a small sideways push that anything moving over the rotating Earth appears to feel. The air’s density, pressure, temperature and speed of sound, and the wind, at each height. A turbulence model exists, but no flight uses it yet | Geodesy, Frames, Gravity, Atmosphere, Wind, Turbulence |
| the rail, recovery and settings | The rail’s length, direction and friction; each parachute or streamer and when it fires; how finely to step through time | Rigid-body flight, Recovery, Time integration |
From the pad to the ground
The numbers match the drawing.
-
Ignition and liftoff. Every motor lights at time zero unless its design gives it a later ignition: an air start, or a sustainer lit after its booster (Staging). A two-stage design that says nothing lights both stages on the pad.
The rocket stands on the rail, its aft end at the rail’s foot. It holds still until the push up the rail, mostly the thrust, beats the weight’s pull down it and the rail’s friction. That instant is liftoff.
-
On the rail. The rocket slides along the rail without turning: one degree of freedom. A flight that asks for tip-off lets it turn on its last guide. Rail exit comes when the rocket’s last rail guide leaves the top of the rail. That guide is a rail button or a launch lug (a short tube on the body). A rocket that stops on the rail comes to rest there (Rigid-body flight).
-
Powered flight, to burnout. Off the rail, the rocket is a rigid body free to move and turn in every direction. Those are the six degrees of freedom of a 6-DOF simulator. At every instant HPR Sim adds up the forces and their turning effects:
- the thrust of each burning motor, along the rocket’s axis. So a cluster of motors that all light at once is flown, with their thrusts added. A motor off the center line adds a turning effect, as when one motor of a cluster fails to light (Clusters). Tests check it;
- the weight and the Coriolis force, at the center of gravity;
- the air’s forces, from the air’s velocity past the rocket, wind included. They’re the drag along the axis, and each body part’s and fin set’s normal force at its own center of pressure;
- the burning propellant’s effects: the center of gravity moving inside the rocket, and jet damping (the exhaust carrying away some of any turning motion). They include the propellant’s internal momentum too, which is counted twice (see What is left out).
From these it works out how the rocket speeds up and turns (Rigid-body flight). A crosswind meets the rocket partly from the side. The fins’ normal force, behind the center of gravity, swings the nose into the wind, so the rocket climbs upwind (weathercocking). The top speed usually comes just before burnout, once the thrust no longer beats the drag and the weight. Burnout is the end of the last motor’s thrust curve.
-
Coast, to apogee. The same equations with no thrust: drag and gravity slow the climb. Apogee is where the vertical speed falls through zero.
-
The drogue. Each recovery device fires its charge at its trigger: apogee, a height on the way down, a time, or a motor’s ejection delay. After its lag, a set time from the charge to its lines stretching, it deploys. From the first deployment the rocket is a single point with mass. Its attitude (which way it points) freezes. It falls under gravity and the open devices’ drag while the wind carries it along, which is its drift.
-
The main. A second device, typically the main set to a height above the ground, adds its drag to the drogue’s. A device can also cut another away as it opens. A rocket can separate into parts that each come down on their own. Streamers and tumbling are recovery devices too (Recovery).
-
Landing. The flight ends when the center of gravity comes back down to the launch site’s height.
A flight can also end in other ways, each reported by name (Rigid-body flight):
| ending | what happened |
|---|---|
| on the pad | the motors burnt out before the rocket lifted off |
| stalled on the rail | it lifted off, then stopped on the rail after the motors burnt out |
| time cap | the flight reached its time limit, 3,600 s (an hour) after ignition by default, before landing |
| step limit | the integrator (below) used up its budget of steps, a million attempted steps by default, before landing |
| separated | the rocket split into parts, and each part’s own descent says where it landed |
The time cap and the step limit are safety stops, so a flight that doesn’t land still ends.
A stiff stretch of flight, one that forces very short steps, can show
up as the step limit (Time integration). Both limits
are fields of FlightSettings (max_time_s and step_limit), and a program can change them.
Anything else that stops a flight is an error, such as reaching Mach 5. Mach 5 is the top speed the simulator’s normal force and drag cover.
How the simulator steps through time
The rocket’s state at any instant is 13 numbers. Three give where it is, and three how fast it moves. Four give which way it points, as a quaternion, a compact way to store a rotation. The last three give how fast it turns.
The equations above turn a state into its rate of change. An integrator builds the flight from them by stepping forward in time, one short step after another (Time integration).
The simulator’s default method is Dormand-Prince 5(4). On each step it makes two estimates of the new state, one of fifth order and one of fourth; that’s the “5(4)”. The higher a method’s order, the faster its error shrinks as the step gets shorter. HPR Sim keeps the fifth-order estimate, and takes the difference between the two as the step’s error.
HPR Sim sizes the next step to keep that error within a tolerance. Steps are short where things change fast, at liftoff and burnout, and long in a steady descent (adaptive time step). At the default settings, the Getting started flight’s apogee is within about a micrometer of the answer at much tighter settings (Rigid-body flight). At those default settings a whole flight takes about a millisecond of computing (the same measurement).
Some moments where a force changes abruptly are known in advance, such as each point of the thrust curve and burnout. These are stop times. A step always ends exactly there, so none straddles a jump.
Other moments are found during the flight, such as liftoff, rail exit, apogee, an altitude trigger and landing. These are events. When the quantity that defines one changes sign within a step, the simulator finds the instant it crossed zero inside that step.
You get back every event, with a snapshot of the flight at that instant. The snapshot holds the
time, position, velocity, height, airspeed, Mach number, angle of attack, thrust, mass and more. A
program can also watch every step as it happens, as
Getting started does to find the top speed. Or it
can record chosen quantities at a fixed interval with a Recorder
(Recording a trajectory).
What is left out
Each model page lists what its model leaves out. These gaps matter most for a whole flight:
-
Near and past Mach 1, the drag is lightly checked. The normal force, center of pressure and drag all carry a flight from Mach 0 to 5. The normal force was checked against a wind tunnel to Mach 4.63 (Aerodynamics). The drag was checked at Mach 0.3 against other programs’ curves, and from Mach 0.6 to 4.63 against the same wind tunnel. Against the tunnel it reads high at every Mach number it measured, most of all with fins past Mach 1 (Aerodynamics).
Near and above the speed of sound the drag is Niskanen’s semi-empirical method (formulas fitted to measurements). Against Calisto’s curve, the one real RASAero II export, the drag reads 10.2% low to 16.5% high from Mach 0.85 to 1.15. From Mach 1.2 to 2.0 it reads 5.1% to 15.0% low, the most at Mach 2 (Aerodynamics; the drag against RASAero II; what backs it).
-
The aerodynamics are for small angles of attack, with no stall. But a flight uses them at every angle: just off the rail in a strong crosswind, and near apogee.
-
Staging, clusters and air starts are checked against OpenRocket on three of its examples. Each motor lights at its own time, and a sustainer flies on after a powered separation (Staging). The two-stage, cluster and air-start examples’ 12 flights are each within 5% of OpenRocket’s apogee and largest speed. Three cluster apogees are compared with OpenRocket’s flight with no parachute, since its parachute opened before apogee (a two-stage and a cluster design).
A motor that fails to light in a cluster is checked by tests only (Clusters). A rocket that separates more than once isn’t compared yet. Neither is one that ejects a nose cone or a payload to land on its own. Those pieces are checked against exact answers only (Recovery: ejected pieces).
-
Moving and released mass are checked against exact answers only. That’s ballast or a payload that slides along the airframe in flight, or leaves it. The exact answers are hand calculations and conservation laws, not another simulator or a real flight (Moving mass, Released mass).
-
Tip-off, unless a flight asks for it. Its cost is measured with RocketPy’s. The Rust library flies a tip-off phase when asked, and flying it by default is planned.
-
Thrust misalignment (a motor pushing slightly off the rocket’s axis) and turbulence, which no milestone plans yet. Roll from canted fins and roll damping are modeled, and checked against measurements only from Mach 1.5 up (Roll: forcing and damping).
-
One term is counted twice. A thrust curve measured on a test stand already includes the propellant’s internal momentum, and the equations of motion add it again, as RocketPy’s do. HPR Sim keeps it so the two codes can be compared like for like. On the Getting started rocket it adds 21 N to the push at liftoff. It changes the burnout speed by at most 0.05 m/s (0.2 ft/s) (Rigid-body flight).
-
Under a parachute, four things are left out. One is the drag overshoot as a canopy fills, so the opening load the simulator reports is no safe bound. By default a canopy opens at once. The others are the air carried along with the canopy (added mass), the airframe’s own drag, and the rocket swinging below the canopy (Recovery).
-
There’s no terrain: the ground is flat, at the pad’s height.
Accuracy
Judge how far to trust HPR Sim’s numbers from its checks against other programs and real flights, model by model, with every known gap.
This page gathers every check HPR Sim has passed so far, and every known gap, in words and numbers. Trusting a simulation explains what they mean for a flier.
When both codes fly the same drag (same-drag), HPR Sim’s whole flights match RocketPy’s in height, speed and time. Without wind they also land where RocketPy’s do. 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 Sim includes a sideways force on the body that RocketPy leaves out.
With each code’s own drag (predicted), HPR Sim’s heights differ from RocketPy’s by −7.280% to +10.302% (report). The larger gaps are where its drag differs most from the example’s.
Against the logs of 12 public real flights, HPR Sim’s apogees miss by 8.88% on average, outside the 5% target (evidence row G24). One by one they miss by −29.16% to +10.40%, and 7 of the 12 read low (real flights, report). Seven were compared as soon as they were flown. Of their five misses past 5%, four are consistent with HPR Sim’s drag, and one with the motor’s impulse. Five were predicted first. Four of those miss past 5%, and no explanation is claimed for them. Seven of the 12 altimeters’ kinds are assumed, and none is calibrated (evidence rows G21 and G39).
Against 60 more flights from a private collection, HPR Sim’s apogees are +8.01% above the logs on average. They miss by 12.09% (mean absolute), also outside the target. OpenRocket’s are +6.72% above (private collection, report).
No flight here is blind yet: all were seen during development. Blind flights will be predicted before their logs are read. Five of the public flights had their predictions merged before they were compared (predicted before compared). They aren’t blind either: their measured apogees were already public.
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 flies past Mach 1.
- The same flights with each code’s own drag, reported against a target rather than gated, the one past Mach 1 included.
- Twelve public real flights, ten of them flown in ERA5 weather, nine in their own day’s. Their apogees are compared with their altitude logs, and for seven the climb too (real flights).
- 60 more real flights of a private collection, flown by HPR Sim and OpenRocket in the weather of their day. They’re 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. Also against RASAero II, another code (fixture). And from Mach 1.08 to 3.15 against free flights of the Basic Finner, a standard finned test body, in a Canadian aeroballistic range (Aerodynamics).
- Drag from Mach 0.6 to 4.63 against the same wind-tunnel tests, the forebody only (Aerodynamics). And the drag and pitch damping from Mach 1.08 to 3.15 against the Basic Finner’s free flights (Aerodynamics).
- A boattail’s own drag and its base pressure, 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. 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 labeled RASAero II in RocketPy’s example rockets (Aerodynamics). Drag 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 analyzetakes from a flight log, against an invented log whose every reading is known (evidence row G10). Each is 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 Sim to, once each. It says what each group was compared with, how, how many flights it holds and how fast they flew. It’s also a check: CI fails when any of those numbers moves, better or worse, until the change is accepted with a written reason.
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. A change to the code that would move them is caught only when someone runs them again and commits the result.
| compared with | kind | held to | flights (speed) | result |
|---|---|---|---|---|
| RocketPy 1.13.0: descents under a parachute | code-to-code, same inputs | gate: each metric’s tolerance, 0.1% to 3% | 5 descents | 30 of 30 gated metrics pass |
| RocketPy 1.13.0, patched: whole flights on the same drag | code-to-code, same inputs | gate: each metric’s tolerance, 0.05% to 3% | 9 flights (8 subsonic, 1 transonic) | 142 of 142 gated metrics pass; apogee +0.04% to +1.21%; 11 not scored, each for a written reason |
| RocketPy 1.13.0, patched: whole flights, each code on its own drag | code-to-code, each code’s own drag | target: each metric’s tolerance, 0.1% to 3%, reported, not enforced | 6 flights (5 subsonic, 1 transonic) | 75 of 102 metrics within target; apogee −7.28% to +10.30% |
| OpenRocket 24.12: calm flights of OpenRocket’s examples | code-to-code, each code’s own model | no target; an apogee more than 5% off needs a written cause | 54 flights (53 subsonic, 1 transonic); 3 more not flown | apogee −37.93% to +13.80%; apogee within 5% on 45 of 53, largest speed within 5% on 50 of 53, margin within 0.2 calibers on 52 of 53, launch mass within 1% on 54 of 54, mass at rod clearance within 1% on 50 of 54, center of mass at rod clearance within 0.2 calibers on 54 of 54; 3 values withheld by the report |
| OpenRocket 24.12: calm flights of the private designs | code-to-code, each code’s own model | no target; an apogee more than 5% off needs a written cause | 35 flights (28 subsonic, 6 transonic, 1 supersonic); 2 more not flown | apogee −4.84% to +13.60%; apogee within 5% on 34 of 35, largest speed within 5% on 34 of 35, margin within 0.2 calibers on 35 of 35, launch mass within 1% on 35 of 35, mass at rod clearance within 1% on 35 of 35, center of mass at rod clearance within 0.2 calibers on 35 of 35 |
| the public flights’ altimeter logs: real flights | measured | target: mean absolute apogee error 5% | 12 flights (5 subsonic, 7 transonic) | mean absolute apogee error 8.88% (target 5%, missed); apogee −29.16% to +10.40%; apogee within 5% on 3 of 12, climb’s RMS height error within 3% of apogee on 2 of 7 |
Reading the table.
- Compared with names the reference and its version (census): RocketPy, OpenRocket or the public flights’ altimeter logs. “Patched” means RocketPy 1.13.0 runs with two fixes from RocketPy’s own pull requests. They correct the point it takes the burn’s turning moments about (whole flights against RocketPy).
- Kind says whether both programs flew the same inputs, each flew its own model, or HPR Sim 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’s RocketPy’s largest Mach number, and for OpenRocket’s flights OpenRocket’s. For the logged flights it’s HPR Sim’s own, since a log has none. A configuration an OpenRocket report lists and HPR Sim 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 the climb for the seven compared along it;
- 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 reports’ figures that explain a difference rather than measure one. A real flight’s apogee on its team’s own drag is one.
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 Sim 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. For a harness row it’s at least the harness’s reproduction bound: the larger of 2e-6 in the metric’s own unit and 1e-7 of the value. The scale is the row’s own tolerance where it has one. Otherwise it’s the bar of its kind. That’s 3% of its reference for a harness metric not scored, 5% for an OpenRocket apogee or largest speed and 1% for an OpenRocket mass. It’s 0.2 calibers for a stability margin or center of mass, and 5% for a logged apogee. A logged climb’s RMS gets 3% of the apogee, the bound three RocketPy comparisons hold a flight’s height RMS to (census). For example, a 3% tolerance on a 1,000 m (3,281 ft) apogee allows 30 m (98 ft). The census lets the difference move by 0.03 m (0.098 ft) 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 bound is only a target, is held that way too (census). That keeps HPR Sim’s own aerodynamics from drifting 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.
The scoreboard
In short: the scoreboard sets HPR Sim beside OpenRocket and RocketPy, one table per axis the project judges itself by. The axes are:
- accuracy against logged flights;
- bias;
- whether predicted ranges hold real flights;
- speed;
- round trips through each tool’s design file;
- features;
- steps to a first answer.
Every number is read from a committed report. Many cells aren’t measured yet. Each says so and links the milestone that will measure it. On each row where HPR Sim and another tool both are, it says which is ahead.
It’s also a check. CI fails when one of HPR Sim’s numbers there gets worse than the one main
holds, counts fewer flights, or stops being measured. The exception is a cell a decision record
accepts for the release the change ships in
(how the scoreboard works).
The other tools’ numbers, and HPR Sim’s on held-out flights, are shown, not held. cargo xtask scoreboard writes it from the committed reports.
Its steps rows count how many steps it takes to open a design’s .ork file, fly it once and get
its landing spread. Commands, script lines, clicks and typed entries are each counted apart. These
are counts of documented steps, not timings, and installing isn’t counted
(what counts as a step).
- HPR Sim: 2 commands, or 10 lines of Python, from files a test runs, so every counted step works. It has no window yet (its steps).
- OpenRocket 24.12: 7 clicks to open and fly a design, from its documentation. It has no Monte Carlo to spread the landing, and no command or documented script that flies a design (its steps).
- RocketPy 1.13.0: it reads no
.orkfile. A rocket is typed in as Python instead (its steps).
Reading the evidence
How the numbers are written, and the four kinds of check they come from.
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
esays how many places the decimal point moves, to the left when it’s 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 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’s 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 Sim’s value less the one it’s compared with, over that one. A plus means HPR Sim’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’re set out in the project’s validation plan.
| kind | what is compared | what agreement shows |
|---|---|---|
| Analytic | The code against exact answers: formulas solved by hand (closed forms), conservation laws, and round trips (converting a value and converting it back) | The code computes what its equations say |
| Published source | The code against a source’s printed tables and worked examples | The code implements the source correctly |
| Another code | HPR Sim against another simulator, such as RocketPy, flying the same inputs | The two codes agree on the physics; not that either matches reality |
| Real flights | HPR Sim against measured flights | The model matches reality, within the flight’s own uncertainty, which here is not measured |
The first three check the code. Only the fourth checks the physics against the world.
Twelve public flights have been compared so far, each as a whole. That’s the apogee, and for seven the climb to it, not each model on its own (real flights). Two recovery models are also checked against published drop tests (Recovery), and the normal force against NASA’s wind-tunnel tests of the Arcas Robin (Aerodynamics): measurements, but not flights.
Model by model
Which checks each model has passed, then its headline result.
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 Sim’s at the 23 heights its parachute descents sample. That was part of the descent comparison, and nowhere else (Recovery).
| model | analytic | published source | another code | real flights |
|---|---|---|---|---|
| Frames | ✓ | no | ✓ RocketPy; the codes of NASA’s check cases 1 to 3 and 6 to 10 | no |
| Geodesy | ✓ | ✓ | no | no |
| Gravity | ✓ | ✓ | ✓ RocketPy; the codes of NASA’s check case 1, whose field stops at its second term | no |
| The magnetic field | no | ✓ | no | no |
| Atmosphere | ✓ | ✓ | ✓ RocketPy, in the descents only; the codes of NASA’s check cases 6 to 10 | partial: its pressure altitude against two altimeters’ readings of their own pressure, to 0.195 m (0.64 ft) and 1.321 m (4.33 ft, report) |
| Wind | ✓ | no | ✓ RocketPy, in the descents only; the codes of NASA’s check cases 7 and 8 | no |
| Turbulence | ✓ | no | no | no |
| Design tree | ✓ | no | ✓ RocketPy, mass properties only | no |
| Shapes | ✓ | no | ✓ OpenRocket, probe parts and the parts catalog | no |
| Mass properties | ✓ | no | ✓ OpenRocket, the structure without motors, and the parts of its parts catalog | no |
| Solid motors | ✓ | no | ✓ RocketPy, ThrustCurve.org; OpenRocket for a curve file’s own numbers | no |
| Aerodynamics | ✓ | ✓ Barrowman’s examples; MIL-HDBK-762’s drag example, fins left out: 6 of 12 within 10%, the body reading 6% to 10% low faster than sound | partial: drag and the normal force against RASAero II to Mach 2, the drag with the fins and finish guessed and 5% to 15% low faster than sound; and in whole flights, against a target | partial: in the seven flights compared first, four of the five apogees past 5% are consistent with its drag (real flights, report); wind tunnel ✓: normal force, drag and boattails; the Arcas Robin’s drag reads high at every speed |
| Rigid-body flight | ✓ | no | ✓ RocketPy, with the drag given; and on each code’s own drag, against a target; OpenRocket on 53 configurations of its examples (results); the codes of NASA’s check cases 1 to 3 and 6 to 10, on a free body under the cases’ damping and drag (results) | partial: 12 public logged flights, as a whole: apogees 8.88% off on average, outside the 5% target (evidence row G24) (real flights, report) |
| Time integration | ✓ | no | partial: NASA’s check case 2, together with the rigid-body equations, against the two of its codes that agree with each other | no |
| Recovery | ✓ | ✓ | ✓ RocketPy | no (drop tests ✓) |
| Staging | ✓ ignition times, the mass step and momentum, against hand sums | no | ✓ OpenRocket: its two-stage, three-stage, cluster and air-start examples, every flight within 5% (three cluster apogees against OpenRocket’s flight with no parachute, because its parachute opened before apogee) (results) | no |
| Moving mass | ✓ the mass properties and the static margin against hand calculations, and both momenta kept in free flight | no | no | no |
| Released mass | ✓ the mass properties after a release against hand calculations, and mass and both momenta kept across it in free flight | no | no | no |
| Flight metrics | ✓ the boost’s peak, the margins of the page’s finless rocket with a boattail (including where a margin is withheld) and the landing placement against hand calculations; max q and top Mach against a 1 ms record; the least margins against 1 ms steps and a scan of every step; the flight margin and the optimum delay against HPR Sim’s own models and a flight with no recovery | no | no | no |
| Fin flutter | ✓ the scaling in thickness, stiffness and pressure, and the margin at max q against a 1 ms record | ✓ Martin’s formula and both of his worked examples reproduced, with his verdicts against his figure 3 band; not compared with flutter data | no | no |
| Flight-log readings | ✓ each reading of an invented flight within the bound its rounding and filter allow | no | partial: one public altimeter log’s apogee, read at 1,010 ft against the 1,009 ft the altimeter’s software states from the same trace; checked only where the log is fetched, not in CI | no |
| Synthetic flights | ✓ each noise term on a truth built for it, failing when changed | no: the terms are taken from datasheets and public logs, not yet compared with real logs’ statistics | no | no |
| Two logs on one timeline | ✓ the offset within its bound on all 1,383 two-logger and 135 staged synthetic flights that gave one, largest error 0.21 s; its 90% interval passes the coverage test on both two-logger sets, narrowed, widened and shifted each failing | no | partial: one real pair, a weak check: RocketPy’s Prometheus, about 0.08 s from the offset its two boards’ GPS time gives, where a zero offset would miss by 0.13 s; no real staged flight | no |
| A log against its simulation | ✓ the sign, a barometer’s reading on a warm day and the clock on constructed flights; a log of the simulation’s own flight leaves an RMS under 1 m (3.3 ft) | no | partial: each of the 7 public flights compared along the climb is reported, and its simulated apogee, read by the log’s reader, stays within 0.5 m (1.6 ft) of the flight’s own event; this reports residuals, and checks no claim about them | no |
| Ghost files | ✓ each format read back by outside readers and held to the others within 1 cm (0.39 in) | no | ✓ all 22 real flight logs in RocketPy’s repository with an altitude or a GNSS track: of the 16 logs with a barometer’s or a filtered height, 13 peak within 2% of a recorded apogee in RocketPy’s notebooks and 3 about 0.3% from its simulated one; the two with only a receiver’s altitude 4.9% and 5.9% over | no |
| The least-squares fit | ✓ each parameter’s 90% interval passes on sets A and B of the synthetic flights, the wind’s on logs with a track, sets seen while its model was chosen | no | no | no: no real flight with its inputs measured apart from its log yet (evidence row G38) |
| The smoother | ✓ at burnout, the top speed, apogee and a drawn moment, the three sets’ cells hold between 94.2% and 99.4% of the synthetic flights’ truths inside its 90% intervals; two logger cells fall under 90%, 88.7% on set B and 89.2% on set A, which the check’s rule allows; the test sets were seen while its rules were set (how well) | no | no | no: no real log with a truth taken apart from it yet (evidence row G33) |
| Interpolation | ✓ | no | no | no |
| Quadrature | ✓ | no | no | no |
Results by model
The headline results, one check to a row. Each model page opens with In short. Its verification section lists every test and its tolerance: how far a result may be from its reference and still pass.
| model | compared with | how close |
|---|---|---|
| Frames | RocketPy’s starting attitude, worked out from the launch rail’s angles, for 8 rail setups | within 1e-12 rad |
| Frames | an exactly solvable spin whose axis sweeps round a cone (coning), over 1e6 integration steps | attitude within 1e-9 rad |
| Frames | the codes of NASA’s check cases 1 and 2 (a free body against them, report): the height above the ellipsoid read back from the launch frame along a 4.4 km (2.7 mi) fall down the site’s vertical on the equator, where the ellipsoid’s shape hardly enters, and the Earth’s rate turned into the body’s axes | with the two named model differences taken off each kept code’s largest difference, at most 0.1364 mm (0.0054 in) of altitude and 0.001005 deg/s of inertial rate are left, both inside the codes’ spread; read at every sample, the rates are left just past it (the rigid-body flight row); the attitude is not compared |
| Frames | NASA’s check cases 9 and 10, a sphere with a constant drag coefficient shot from sea level at 1,000 ft/s (305 m/s) up and 1,000 ft/s east or north for 30 s, kilometers downrange, against six codes’ published positions, one left out in case 10 (a free body against them, report) | the position ends 1,980 and 1,977 mm (78 in) from the farthest kept code, inside the codes’ spreads of 1,989 and 1,986 mm (78 in); with the gravity and the codes’ own air taken off, 0.03830 mm (0.0015 in) and 0.04217 mm (0.0017 in) from the nearest, but 1,991 and 1,988 mm (78 in) from the farthest, just past the spread, so no cause is claimed |
| Geodesy | the ellipsoid values printed in Table 3.5 of the WGS 84 standard | to their printed digits |
| Geodesy | Karney’s published test set of 500,000 WGS 84 geodesics, solved both ways | all 500,000 within Karney’s 15 nm (nanometers): distance within 11.18 nm, far point within 14.02 nm, heading there within 13.99 nm; the computed bearing and distance, flown forward from the first place, land within 11.26 nm. CI checks every 500th line and the 21 mirror lines; the whole set where downloaded, measured on macOS |
| A launch site’s elevation from a file | GDAL 3.12.2’s reading, through rasterio 1.5.2, of seven GeoTIFF files cut from a USGS tile and of the whole tile (the tests) | the same corner and pixel size to the last bit, the same sums over all 13 million pixels, and the same pixel and value at all 2,368 of 2,800 places on the seven files (9 of them nodata) and all 1,696 of 2,000 on the tile, the rest off the edge; the whole tile only where downloaded |
| Geodesy | round trips at random points from −10 km (−6.2 mi) to +1000 km (621 mi): latitude, longitude and height to Earth-centered x, y, z, and back | latitude within 1e-14 rad, height within 2e-8 m |
| Gravity | the WGS 84 formulas, worked to 40 digits by a separate script, at 11 points from the equator to both poles and up to 200 km (124 mi) high | gravity’s strength within 2e-14 relative |
| Gravity | RocketPy’s gravity formula, at 8 points | under 1e-12 relative |
| Gravity | NASA’s check case 1, a sphere falling for 30 s from 30,000 ft (9,144 m) with no drag, against five codes’ published histories, a sixth left out (a free body against them, report) | the altitude ends 19.51 mm (0.77 in) lower, 137 times the codes’ spread of 0.1424 mm (0.0056 in). The codes’ field stops at its second term; the terms normal gravity holds past it account for 19.50 mm (0.77 in), worked out apart from the flight, which leaves at most 0.1364 mm (0.0054 in) of a kept code’s largest difference, inside the spread |
| The magnetic field | NOAA’s test values for WMM2025: the report’s 12 test points and NCEI’s 100 high-precision points | the 12 to their last printed digit; the 100 to their last digit in declination, inclination, the east component and four rates. The north component differs at 97 points by up to 7.18e-4 nT, and the horizontal and total intensities by up to as much with it; the down component, moved by the same residue, by up to 2.2e-6 nT, and the rates of the north, horizontal and total components by up to 1.5e-6 nT a year. A test places the north component’s difference in NCEI’s file; the rates’ difference has no known cause |
| Atmosphere | the tables of the 1976 standard atmosphere, at 32 heights from −2 to 86 km (−1.2 to 53 mi) | every value within 0.1% |
| Atmosphere | CIPM-2007 (Picard et al., 2008), a published reference formula for the density of humid air that treats air as a real gas, from 15 to 27 °C | humid-air density within 0.047% |
| Atmosphere | RocketPy’s air density, at the 23 heights its descents sample (Recovery) | within 3.7e-4 relative |
| Atmosphere | NASA’s check case 6, a sphere with a constant drag coefficient dropped for 30 s from 30,000 ft (9,144 m) through still air, against five codes’ published positions, a sixth left out (a free body against them, report) | the position ends 102.6 mm (4.0 in) from the farthest kept code, past the codes’ spread of 85.03 mm (3.3 in). The codes don’t fly the same air: one’s density runs up to 1.35e-3 above the 1976 standard atmosphere’s. The gravity past the codes’ second term and each code’s own density, flown apart from the flight, leave at most 77.57 mm (3.1 in), inside the spread; that code is brought inside, not explained |
| Wind | RocketPy’s wind, at the same heights (Recovery) | each component within 1e-9 m/s |
| Wind | the drift of RocketPy’s four descents with wind (Recovery) | the distance drifted within 0.28% |
| Wind | NASA’s check cases 7 and 8, case 6’s sphere in a steady 20 ft/s (6.1 m/s) wind and in one that grows with height to 70 ft/s (21 m/s) at the start, against five codes’ published positions, a sixth left out (a free body against them, report) | the position ends 102.8 mm (4.0 in) and 105.0 mm (4.1 in) from the farthest kept code, past the codes’ spreads of 85.24 mm (3.4 in) and 87.74 mm (3.5 in); the same model difference as case 6’s leaves at most 77.63 and 77.68 mm (3.1 in), inside, bringing SIM 1 inside without explaining it |
| Turbulence | the Dryden gust spectra, published formulas for how gust strength spreads over wavelength, over 2²⁰ random samples (about a million) | within 4 standard errors (the scatter expected by chance) in every octave band (a range of wavelengths spanning a factor of two): ±1–3% in the wide bands. Unvalidated for rockets (evidence row G12) |
| Design tree | a rocket worked by hand, loaded, burning and burnt out | mass within 1e-12 kg, center of mass within 1e-12 m, inertia within 1e-12 relative |
| Design tree | RocketPy, for twelve cases of its example rockets, at the times its equation solver computed the burning grains (up to 60 per case; the thirteenth case, Prometheus’s, has a motor with no such times) | mass, center of mass and inertia within 8.0e-10 relative (the center as a fraction of the rocket’s length) |
| Design tree | RocketPy, for all thirteen cases, at 103 even times through the burn and after it, where RocketPy interpolates between its solver’s times | mass within 1.4e-5 relative, inertia within 2.6e-5 relative |
| Design tree | the propellant mass left in the grains, at both sets of times | within 2.5e-9 of the initial propellant mass at the solver’s times, and 6.4e-5 between them |
| Shapes | exact formulas (closed forms) for filled noses and transitions | within 1e-10 relative |
| Shapes | separately computed high-precision integrals, for 22 noses and transitions | within 1e-12 relative |
| Shapes | the same kind of integrals, for 20 hollow shells of a given wall thickness | within 1e-10 relative |
| Shapes | OpenRocket 24.12’s mass of three walled probe parts: a conical and an ogive nose and a conical transition (probes) | within 3.93e-5 relative (the test holds 5e-5) |
| Mass properties | a cone, a tube, four fins and an off-axis payload, added up by hand | within 1e-11 relative |
| Mass properties | fin cross-sections, against exact numerical integration | within 1e-13 relative |
| Mass properties | material densities, converted from the units their sources print | the sources’ values, such as white ash at 678 kg/m³ |
| Mass properties | OpenRocket 24.12’s structure (every stage, no motor), on 71 compared designs in the current scratch-excluding survey | mass within 1% on 70 and center of mass within 1% of length on 70, the one file outside with a named cause: airfoil fins OpenRocket weighs by a factor, a cause named only when weighing them its way brings the design within both thresholds; pitch inertia within 1% on 63, the 8 outside with no named cause yet but the two copies of OpenRocket’s tube fin example (below); roll inertia a median 1.619% apart, which OpenRocket’s shortcut for fins accounts for, and on the cluster designs its stacking of their tubes on the axis (clusters): with the shortcut in HPR Sim’s place the median is 0.000%, and 7 files (4 distinct designs) remain outside 1% with a named cause. |
| Mass properties | the same survey, tube fins and airfoil fins | A ring of tube fins departs in both inertias, kept on purpose: OpenRocket’s roll inertia for it is more than any mass inside the ring could have, and its pitch inertia leaves out how far the tubes sit from the axis, which accounts for the tube fin example’s pitch inertia being 1.98% below OpenRocket’s (tube fins). HPR Sim’s airfoil fins are 19.4% lighter than OpenRocket’s, a departure kept on purpose (fins). |
| Mass properties | what a file leaves unsaid (a wall of no thickness, no material) and which override wins, held to OpenRocket’s on 32 probe designs, and each fin section and each kind of part alone on 50 more, packed parts among them (packed parts) | On those that ask what a file leaves unsaid: mass within 0.001%, center of mass within 0.001 mm (0.000039 in), bar an elliptical fin’s 0.18%, and an attached tube that writes no thickness (−2.4% on the committed probe; measured in the .ork conventions decision). On the override probes: two rules kept as measured departures, and flags that disagree (4.7 mm (0.19 in)) (probes); a stage’s override on the lower of two stages, the rocket’s inertia across the axis 4.95% and 3.33% over, and 1.6% and 1.1% under with a motor aboard (worked by hand) (decision) |
| Mass properties | fin fillets, on 9 of those probes (fillets, decision) | agree to 1e-15 in the fillets’ mass and center of mass (the test holds 1e-12), the whole probe’s pitch inertia up to 0.64% apart |
| Mass properties | an automatic radius inside a nose cone, on 14 more probes (13 of which HPR Sim flies) | puts every part inside but one packed mass component (#186) at OpenRocket’s mass to 1e-14 and station to 1e-15, as the test holds them; the nose cones’ and the transition’s own walls keep their earlier gaps, up to 3.93e-5 of mass and 2.5e-6 m (the format guide) |
| Mass properties | a tube fin set whose radius OpenRocket works out from the body, on 19 more probes | has OpenRocket’s radius and wall within 1e-15 and every part’s mass within 1e-14 but the one nose cone among those probes, within 5e-5 (the format guide) |
| Mass properties | OpenRocket 24.12’s mass and center of mass of the parts in its parts catalog that the builder makes (all 3,449 but four it refuses) (test, The builder) | tubes, rings, bulkheads, lugs, parachutes and streamers within 1e-14 of the mass; nose cones and transitions within 1e-3 of the mass, and their center of mass within 1e-3 of the part’s length (largest 6.3e-4 and 9.7e-4); but four blunt hollow nose cones, up to 4.8e-3 heavier here and 1.7e-3 of their length apart in center, where the two codes define a wall differently; masses stated in ounces, 8.8 parts in 10 billion apart (OpenRocket’s rounded ounce); and one streamer, whose stated mass OpenRocket ignores. A hollow part’s shoulder weighs nothing in OpenRocket and has the part’s wall here, and is taken out before comparing |
| Solid motors | ThrustCurve.org’s own statistics code (total impulse, burn time, average and peak thrust), on the 412 files that pass the 1% check; the 1,289 that fail have only that check (the whole catalog) | within 3e-15 relative, reading two or more samples at the same time as a step. ThrustCurve.org’s code averages such samples, and on 6 files that moves total impulse, burn time, average or peak thrust, by up to 6.5% (a peak thrust) (validation) |
| Solid motors | OpenRocket 24.12’s own reading of the same 32 curve files (total impulse, peak thrust, the 5%-of-peak burn-time window and the curve’s duration) | every one bit for bit equal. Its average thrust divides the window’s own impulse by the window where HPR Sim divides the whole curve’s, so HPR Sim’s is +0.0107% to +0.3147% higher (median +0.0965%). Nothing else in the motor model is compared with OpenRocket |
| Solid motors | RocketPy’s solid-motor model, on three bundled motors, at 203 times each | total mass and inertias within 7.9e-5 relative; the propellant’s own mass and inertias within 1e-4 of their values at ignition |
| Aerodynamics | Barrowman’s five worked examples, at Mach 0 (low speed): each rocket’s normal-force slope and center of pressure | every center of pressure within 1%. Every slope within 1% too, except the six-fin Recruiter’s: +2.87% (+3.42% on its fins alone) |
| Aerodynamics | drag curves labeled RASAero in RocketPy’s examples, at Mach 0.3, with the fins and surface finish guessed because the curves don’t record them | within 10% in two of seven cases; two boattailed ones −10.3% and −11.5%; −18.3% for Cavour power-on (motor burning), cause open |
| Aerodynamics | Valetudo’s drag table, which is 1.44 times the drag in the OpenRocket export for the same rocket | −47.0% power-off and −50.4% power-on. Against the OpenRocket export, HPR Sim is 23.5% under as designed here, and 1.9% under with the export’s own surface finish and launch lugs |
| Aerodynamics | the same curves every 0.05 from Mach 0.1 to 2.0, as far as each reaches; Calisto’s, the one real RASAero II export, to Mach 2 | Calisto within 10% at 15 of 15 subsonic Mach numbers, 5 of 7 transonic and 8 of 17 supersonic, where HPR Sim reads −14.9% to −5.1%, lowest at Mach 2 (−29.8% to −24.4% before the boattail’s supersonic wave drag) (evidence row G26). Other plausible fins put 14 to 17 of the 17 within 10%, though none puts every row within it, so most of what is left is within the unrecorded inputs; part of it is HPR Sim’s body, which reads low faster than sound against MIL-HDBK-762 too |
| Aerodynamics | MIL-HDBK-762’s worked drag example, a rocket whose every term the handbook calculates, from Mach 0.5 to 3.2: a calculation with every input known, not a measurement. Its fins are sharp-edged wedges, which HPR Sim can’t represent, so their pressure drag is left out on both sides | 6 of 12 within 10%. From Mach 0.9 to 1.2, +12.3% to +31.9%, mostly the nose and the base; from Mach 1.6, −6.0% to −9.6%, friction and the base |
| Rigid-body flight | the exact motion of a tumbling, spinning rocket in a vacuum, over 22 s | the center of mass within 1.7e-6 m of the exact parabola |
| Rigid-body flight | NASA’s check case 2, a brick of three unequal moments of inertia tumbling for 30 s with no aerodynamics, against four codes’ published histories, a fifth left out (a free body against them, report) | the inertial body rates differ by up to 0.01077, 0.01633 and 0.005500 deg/s in roll, pitch and yaw, past the codes’ spreads of 0.0008991, 0.001242 and 0.0003532 deg/s. HPR Sim’s rotational equations leave the Earth’s rate out (#1521); that accounts for all but 0.0008818, 0.001005 and 0.0001268 deg/s at each code’s largest difference, each inside the spread. Read at every sample instead, what is left is past the spread by up to 0.0000001701 deg/s |
| Rigid-body flight | NASA’s check case 3, case 2’s brick with a constant damping coefficient on each axis, applied by the test, against four codes’ published histories, a fifth left out (a free body against them, report) | the inertial body rates differ by up to 0.004873, 0.005633 and 0.005102 deg/s in roll, pitch and yaw, past the codes’ spreads of 0.003609, 0.003792 and 0.003503 deg/s. The Earth’s rate left out of the rotational equations, with the same damping on both sets, accounts for all but 0.003176, 0.001123 and 0.0007793 deg/s, each inside the spread; at every sample roll and yaw stay inside and pitch comes to the spread |
| Aerodynamics | NASA’s wind-tunnel tests of the half-scale Arcas Robin and a longer version, Mach 0.6 to 4.63: normal-force slope and center of pressure, 22 readings at 12 Mach numbers (fixture) | from Mach 1.5, every slope within target: +8.8% to −3.3% (short) and +9.4% to −2.3% (long), since the committed designs fly the shock-expansion method to their base; the center of pressure within 0.53 calibers, which misses the half-caliber target on the long model at Mach 1.8 and 2.3, where that model’s body alone reads 15% to 19% high (fins off, the short model’s reads as much as 38% high at Mach 1.5: the crossflow excess sized at every speed); from Mach 0.8 to 1.2, 2 of 9 within 15% and half a caliber |
| Aerodynamics | RASAero II’s normal-force slope and center of pressure for Calisto, Mach 0.1 to 2.0 (fixture) | within 15% and half a caliber at 11 of 15 Mach numbers; HPR Sim’s slope rises with Mach through subsonic flow where RASAero II’s stays flat (+21.9% at Mach 0.9), and from Mach 1.5, where its von Kármán nose flies the shock-expansion method behind a Newtonian cap, reads +8.3% to +12.9% |
| Aerodynamics | the body faster than sound, by a method no flight uses yet: the tables of NACA TN 3527, its source, for 144 cone- and ogive-cylinders at Mach 3 to 6.28, both its authors’ own values and their wind-tunnel measurements of the normal-force slope and center of pressure (fixture) | against the measurements, 117 of 120 slopes within ±0.2 per radian (−0.278 to +0.251) and 109 of 120 centers of pressure within 0.2 calibers (−0.540 to +0.328); against the authors’ values, 102 of 144 slopes within 0.05 (−0.134 to +0.146) and 125 of 144 centers of pressure within 0.1 calibers (−0.670 to +0.257), so the targets are not met, where a separate implementation of the same equations, an uncommitted script, agrees with HPR Sim outside the 12 rows at the method’s limit (#81) |
| Aerodynamics | the same method on the Arcas Robin’s nose and cylinder, against its measured body alone, Mach 1.5 to 4.63, 11 readings; no target, since the measurement includes the boattail and crossflow (fixture) | the short model within 5% from Mach 1.8 to 2.96, +16.4% at 1.5, −15.0% and −18.7% at 3.96 and 4.63; the long model −13.7% to −26.4% |
| Aerodynamics | a blunt or vertical nose tip’s Newtonian cap ahead of the same method: NASA TN D-4865’s sphere-cone (a nose radius of 0.175 diameters on an 11.5° cone), its measured normal-force slope and center of pressure at Mach 1.50 to 4.63, 6 readings; and the Arcas Robin’s committed power-series nose on its cylinder and boattail, the lip left off, against its measured body alone, 11 readings; no target (fixture) | the sphere-cone like for like (at its plotted angles, body lift included) −1.2% to +32.1%, high from Mach 2.96, where the report’s own method reads −3.3% to +13.6% overall, and the center of pressure within 0.06 diameters; the Arcas Robin like for like −4.8% to +37.2%, below the fitted secant ogive’s +3.4% to +41.0% at every Mach number and nearer the tunnel at nine of its eleven rows. No measurement checks a tip that isn’t spherical, and a nose that is nearly a cone but for a vanishing tip carries an unmeasured bias (issue #101) |
| Aerodynamics | the lip at the Arcas Robin’s base, a reflexed flare behind its boattail, which HPR Sim gives no normal force faster than sound: what the measured fins-off pitching moment says the lip’s share is, 11 readings at Mach 1.5 to 4.63; no target (fixture) | one share fitted to every row is +0.021 ± 0.019 per radian, so slender-body theory’s 0.178 sits 8.4 standard errors above it; fitted to each model alone it is −0.016 ± 0.022 (short, whose six rows disagree among themselves, per degree of freedom 6.4) and +0.108 ± 0.034 (long, whose five agree, 0.9). The number blames the lip for every miss in the center of pressure, so it rejects slender-body theory’s 0.178 but cannot separate zero from Seiff’s embedded Newtonian bound (0.044 down to 0.014) |
| Aerodynamics | NASA TN D-4865’s model 2, the one flared body in the sources whose normal force and pitching moment are printed: a blunt 2.75° cone with an 18.5° flare, Mach 1.50 to 4.63, six readings, three of them with its boundary layer separated; no target (fixture) | like for like (at its plotted angles, body lift included) the normal-force slope −1.9% at Mach 1.90, +7.0% at 2.30, +13.4% at 2.96 and +51.5% and +50.4% at 3.95 and 4.63, with the center of pressure within 0.05 calibers through Mach 2.96 and 0.088 at 3.95. |
| Aerodynamics | that flare’s separated boundary layer, against the unflared model 1 (fixture) | The report’s shadowgraphs show that flare’s boundary layer separated from Mach 2.96 up, though the cost only shows in the two fastest rows: the unflared model 1 reads +29.7% and +32.1% there against +12.5% at 2.96, so the flare itself adds 21.7 and 18.3 percentage points at 3.95 and 4.63 and between −1.9 and +0.9 below. |
| Aerodynamics | a flared body below about Mach 1.5289 | there is no marched reading at all and a flared body falls back to slender-body theory, carried up over 0.3 Mach by the join: drawing the flare out to the steepest turn its shock holds lands past the steepest the march itself takes |
| Aerodynamics | the Arcas Robin’s body alone, fins off, against the 15% target the milestone set before the work began, 11 readings at Mach 1.5 to 4.63, the same bodies as the row above, with the lip in place, which moves them under a point; the boattail cap does not reach these, whose boattail is 15° (fixture) | not met on six rows: the short model +37.7% at Mach 1.5, +25.9% at 1.8, +16.9% at 2.3 and 2.96, and the long +19.4% at 1.8 and +15.5% at 2.3; at Mach 3.96 and 4.63 both are within 5%. |
| Aerodynamics | where the miss sits, which can only be told so far | the measurement’s own fit trades its slope at against its curvature at a correlation of −0.96. At HPR Sim is within 1.5 standard errors on every row outside the target, and on five of the six most of the gap is in the curvature body lift adds (1.3 to 2.8 times the measured, and ×12.20 at Mach 1.8 where the tunnel’s curve barely bends); on the sixth, the short model at Mach 2.96, 77% of the gap is HPR Sim’s own slope |
| Aerodynamics | NASA’s wind-tunnel tests of the same two models, Mach 0.6 to 4.63: drag on the forebody (the models’ bases sat on a sting), fins on and off, 44 readings (Aerodynamics) | 2 of 44 within 10%, and every reading high. With the fins off, +13.5% to +24.1% from Mach 1.5 and +12.0% to +54.1% below, most of it the models’ 15° boattail, which HPR Sim over-predicts in a thick boundary layer. With the fins on, from Mach 1.5, +39.4% to +154.0%, where HPR Sim’s fins’ drag stays near 0.30 and the measured falls to 0.046. HPR Sim’s base drag behind a plain cylinder is not measured by the tunnel and has been checked at no speed faster than Mach 0.3 |
| Aerodynamics | the Basic Finner’s normal-force slope and center of pressure at a small angle of attack, from fits of free flights in the range of Canada’s DREV, Mach 1.08 to 3.15, six Mach numbers; no target. It leaves out the fins’ wedge section, the spin of the models whose fins were canted, and the table’s two rows past Mach 3.5 (report) | the slope low on every row, where the fits’ probable errors are 1% to 4%: 11.2% and 16.1% low from Mach 1.5 to 2.5, 24.9% low at both Mach numbers below 1.5, and 9.3% and 13.0% low from Mach 2.5 to 3.5. The center of pressure forward of the measured one on every row, which understates stability: 0.34 and 0.18 calibers from Mach 1.5 to 2.5, 0.07 and 0.03 below, 0.27 and 0.23 above. At each fit’s root-mean-square yaw, about 1°, the slope’s miss is 0.8 to 2.4 percentage points smaller. The cause is not found |
| Aerodynamics | NASA’s wind-tunnel tests of the two Arcas Robin models, Mach 1.5 to 4.63: roll forcing, the rolling moment per degree of cant, 11 readings (roll fixture) | from Mach 2.3, all 8 within 5.3%; at Mach 1.5 and 1.8, +14.3% to +47.8% |
| Aerodynamics | the Basic Finner’s zero-lift drag and pitch damping, against the same fits of DREV’s free flights, Mach 1.08 to 3.15, six Mach numbers; no target. The fins’ wedge section, which the design can’t draw, is modeled from published figures, a band. It leaves out the fins’ bases beside the body’s, the canted models’ roll, and the drag’s growth with angle (report) | the drag 16.5% and 20.6% low from Mach 1.5 to 2.5, 21.3% and 19.3% low from Mach 2.5 to 3.5, below every shot of its row and below DREV’s even with the fins’ bases at a vacuum; below Mach 1.5, 10.1% high at Mach 1.077 (band 9.5% low to 17.1% high) and 3.5% low at 1.293, inside the shots’ spread. The cause is not found. The pitch damping 24.7% and 26.2% low from Mach 1.5 to 2.5, 39.6% and 30.4% low from 2.5 to 3.5, and 16.8% low at Mach 1.293: less damping than measured, the side that does not flatter. At Mach 1.077 it is 25.4% high, the side that does |
| Aerodynamics | The Basic Finner’s roll damping measured in the US Naval Ordnance Laboratory’s (NOL’s) wind tunnel, Mach 1.53 to 2.76 (roll fixture); in the free-flight range of Canada’s DREV, Mach 1.83 to 3.15, from cached readings (DREV statistics); and Barrowman’s computed value at Mach 0.07 | +11.7% to +27.5% against NOL’s tunnel, most at Mach 1.53: HPR Sim overstates the damping. Against DREV, 8.8% high on average and 12.4% at most in the core band (Mach 1.83 and 2.38); 5.0% on average and 8.7% at most in the extended band (2.72 and 3.15). −2.0% against Barrowman’s computed value (a theory curve, not a measurement; it confirmed how HPR Sim reads his method). Barrowman’s Fig. 5-7 points, once scored here (HPR Sim 5.9% to 16.2% below them), sit 1.27 times BRL 799’s range data (Aerodynamics) and are no longer scored |
| Aerodynamics | conical boattails measured in six NACA and NASA reports, jet off, Mach 0.3 to 3.24: the boattail’s own pressure drag and the base pressure behind it (drag fixture) | attached boattails of 3° to 10° from Mach 1.2: −21.9% to +28.3%, within 0.0123 (58 readings); from Mach 1.0 to 1.1, −18.2% to −5.4% (4), and −46.2% to +60.0% at points near Mach 1 their report calls questionable (27); through the rise from Mach 0.85 to 0.95, −77.5% to +7.6% (28); under Niskanen’s rule to Mach 0.8, −100% to −83.5% (58). 16° in a boundary layer a fifth of the diameter thick, +26.4% to +54.2% (9). Separated 30° and 45°, −2.8% to +6.6% (3, which set the separation angles). |
| Aerodynamics | the base drag behind them | within 0.0102 of the measured on the cylinder’s area, though behind small bases that is up to about 40% of the base’s own drag (8 of the 12 set the ratio below Mach 2.5) |
| Aerodynamics | OpenRocket 24.12’s normal-force slope and center of pressure for tube fins, on 14 probe designs and its Tube fin rocket, at Mach 0.05 to 0.75 (the decision that measured it); a code-to-code comparison. Tube fins as a whole are unvalidated (evidence row G27): no measurement of a tube fin’s lift or center was found | not within the quarter caliber that the tube-fin lesson asks: HPR Sim’s center of pressure is 0.42 to 3.0 calibers forward of OpenRocket’s on every probe up to Mach 0.5, and 1.07 on the Tube fin rocket. From Mach 0.6, where OpenRocket moves the tubes’ center to their leading edge, 5 of 28 are within it. OpenRocket’s tubes lift 1.26 to 1.86 times HPR Sim’s, and up to Mach 0.5 it puts their center at a quarter of their length, ahead of which HPR Sim’s lies. All 70 probe gaps, and the Tube fin rocket’s, are pinned by a test |
| Rigid-body flight | RocketPy’s whole flights from the pad to the ground, for six rockets, one past Mach 1, both codes flying one declared drag coefficient | heights, speeds, times and accelerations within 3% (below), the largest +1.783% in the report; the path too, except the drifts of Juno III, Bella Lui and Prometheus 2022 in wind and NDRT 2020’s apogee drift, reported, not scored, as measured differences between the models (the decision) |
| Rigid-body flight | OpenRocket 24.12’s calm flights of the 54 configurations of its examples that HPR Sim flies, each figure by OpenRocket’s own definition: apogee, largest speed, and the stability margin at rod clearance (report); a code-to-code comparison, with no target set. OpenRocket aborts one, so the figures are over the other 53, and that one is compared at two points up to the abort (flights OpenRocket aborted) | margin within 0.016 calibers on 41 of 53, taken with the air along the axis as OpenRocket’s is; the Tube fin rocket’s is 1.08 calibers below OpenRocket’s (tube fins), the three-stage example’s three are 0.039 to 0.058 below, cause not yet sized (#185), and the five of Pods--airframes and winglets are 0.071 to 0.076 above, the flattering side (#325 and #326, two open causes in the fins), and the three of Pods--powered with recovery deployment are 0.070 above, cause not yet traced. |
| Rigid-body flight | the same flights, apogee and largest speed | With no named cause, apogee −4.34% to +1.95% (36 flights), and largest speed −0.69% to +6.10% (51 flights). The two-stage, three-stage, cluster, air-start and parallel-booster examples are within 5% in apogee and largest speed on every flight, the bar the staging milestone set before measuring; three cluster apogees and two three-stage ones are compared with OpenRocket’s flight with no parachute, since its parachute opened before apogee. |
| Rigid-body flight | the six apogees one named cause moves by more than 5% | OpenRocket’s parachute opening while the rocket still climbs (HPR Sim’s flight compared here flies none), up to +13.80%. OpenRocket flying those six again without it brings four within 5% (sizing the causes). |
| Rigid-body flight | the other two of those six, Base drag hack (short-wide) on a D12-3 and an E12-4 | whose part set to no drag now flies as OpenRocket flies it (a part’s drag override): against OpenRocket’s flight with nothing deployed they read +5.84% and +8.92%, and within 0.10% when HPR Sim flies OpenRocket’s own drag, so their gap is the drag coefficient, by OpenRocket’s breakdown the very blunt nose’s. With recovery in both, the basis the E12-4’s milestone judged, the D12-3 is within 5% (+4.52%) and only the E12-4 is over (+7.80%). HPR Sim keeps a value for that nose read between Hoerner’s measured round heads, so the gap stays (the decision, #177). |
| Rigid-body flight | a seventh, the Tube fin rocket | reads +6.95%, and within 0.03% when HPR Sim flies OpenRocket’s own drag, so the gap is HPR Sim’s tube-fin drag, which probably reads low (#228). |
| Rigid-body flight | the flight OpenRocket aborts, Pods--powered with recovery deployment’s first configuration | within 5% at both points (height −1.17% and −1.18%, speed −0.04% and +4.02%), weaker evidence than an apogee (its milestone) |
| Rigid-body flight | OpenRocket 24.12’s calm flights of the 35 configurations of 11 private designs that HPR Sim flies, published only as differences under anonymized ids (report); a code-to-code comparison, with no target set | covers 11 of the 12 private designs. Apogee −4.84% to +13.60%. One is more than 5% off: the one supersonic flight, C06/1, +13.60% in apogee and +7.98% in largest speed, whose cause is the drag coefficient: flown on OpenRocket’s own drag, HPR Sim reads +1.11% and +1.04%; the supersonic pressure drag (mostly wave drag) and HPR Sim’s base drag under power, checked against a measurement only below Mach 0.8, are open (#222: HPR Sim’s supersonic pressure drag is about twice OpenRocket’s) (evidence row G14). The rest: largest speed −0.65% to +2.28%. |
| Rigid-body flight | the same flights’ stability margin (report) | −0.0166 to +0.1108 calibers. HPR Sim calls four designs clearly more stable than OpenRocket does: C09 by 0.0350 to 0.0478 and C03 by 0.0564 to 0.0730 on every flight, cause not yet traced (#172); C08, a two-stage design, by 0.1108, a center-of-mass gap with a lead but no measured cause (#186); and C06/1 by +0.0604, most of it a center of mass 0.0447 calibers forward of OpenRocket’s, with a lead but no measured cause: its airfoil fins, which OpenRocket weighs by a factor of 0.85 (the mass survey’s fin-section cause, sized on the structure alone). |
| Rigid-body flight | a fifth design, C12, launched from a tilted rod: its margin | 0.0125 to 0.0366 calibers, most of it OpenRocket’s rocket clearing the rod at an angle of attack: at that angle HPR Sim reads 0.0033 to 0.0074 (a tilted launch rod) |
| Time integration | a separate line-by-line transcription of DOPRI5, the published Fortran integrator by Hairer and Wanner that HPR Sim’s Dormand-Prince stepper follows, on the problem Hairer’s own example program for DOPRI5 solves: the Arenstorf orbit, the closed, looping path of a small body pulled by two large ones that circle each other | the same step counts |
| Time integration | a vertical flight with drag that has an exact solution | apogee, deployment and landing times within 1.5e-8 s |
| Time integration | NASA’s check case 2 again, the model difference taken off, at the default tolerances and at 1e-12 (a free body against them, report) | the body rates sit 0.0000005866, 0.0000009229 and 0.0000002790 deg/s from the code nearest them at the default tolerances (SIM 1 or SIM 4, which agree with each other; the other two kept codes are up to 0.00004975 and 0.001242 deg/s away), and 0.000000002126, 0.000000003051 and 0.000000001089 deg/s at 1e-12: the first three are step error, read from HPR Sim’s own two flights. Not a check of the steps alone |
| Recovery | RocketPy’s descents under a parachute, for five rockets | every descent metric within 3% (below) |
| Recovery | the same descents: the heights where the later parachutes fire, and the descent rate under the drogue | within 0.17% and 0.01% |
| Recovery | published drop tests of five small models falling with nothing deployed (tumbling) | descent rate −10 to +19% off |
| Recovery | Kidwell’s streamer drop tests (2001) | descent rate +9% fast for his one flat streamer, and +58% fast for one folded into pleats, which HPR Sim doesn’t model |
| Interpolation | the exact formula of a smooth curve (a spline) through three points, | matched |
| Interpolation | property tests, which check a rule on many randomly generated tables | every table passes exactly through its own points |
| Quadrature | polynomials, whose integrals are known exactly | exact up to degree 22 |
| Quadrature | six test integrals with known answers, one of them infinite at an end | within 1e-11 relative |
Against RocketPy
The descents and whole flights compared with RocketPy, on the same drag and on each code’s own.
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. It 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 Sim’s defaults.
The committed validation report gives the six numbers below for each descent. All were scored, and all are within tolerance. The largest difference is +2.865%.
Each metric must agree within 3% of RocketPy’s value (landing speed 0.1%, the tighter gate; most others 0.3%, a tighter gate), with no absolute floor. Each case file argues why, for example NDRT’s. A floor would be a fixed allowance, in meters or seconds, that passes any smaller difference. 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: how far the rocket lands from where the descent started, not from the pad.drift_east_manddrift_north_mare its east and north parts. A drift to the south or west is negative.
A difference is HPR Sim’s value less RocketPy’s, over RocketPy’s. A positive one means HPR Sim’s value is larger in size, in the same direction. NDRT drifts south, and HPR Sim carries it further south.
Every result of the report, as HPR Sim’s difference from RocketPy:
| case | descent time, % (descent_time_s) | impact speed, % (impact_speed_m_s) | mean descent rate, % (mean_descent_rate_m_s) | drift, % (drift_m) | east drift, % (drift_east_m) | north drift, % (drift_north_m) |
|---|---|---|---|---|---|---|
descent-calisto-tests-motor-at-minus-1.373 | +0.077% | −0.029% | −0.077% | +0.075% | +0.074% | +0.080% |
descent-valetudo | −0.019% | +0.004% | +0.019% | −0.889% | −0.889% | −1.766% |
descent-ndrt-2020-nose-to-tail | +0.705% | +0.012% | −0.700% | +0.276% | +0.214% | +2.865% |
descent-prometheus-2022-generic-motor | +0.083% | −0.030% | −0.083% | +0.083% | +0.086% | +0.082% |
descent-juno-iii | −0.018% | −0.008% | +0.018% | −0.018% | −0.018% | −0.018% |
Each case is named after the RocketPy example it flies. Three names carry more:
descent-calisto-tests-motor-at-minus-1.373is Calisto as RocketPy’s own tests build it. They put the motor at −1.373 m (−4.50 ft) in RocketPy’s coordinates. RocketPy’s getting-started notebook puts it at −1.255 m (−4.12 ft, notes on RocketPy’s example rockets).descent-ndrt-2020-nose-to-tailis 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-motoris Prometheus 2022, whose motor RocketPy describes with its generic-motor model. That model treats the propellant as a solid cylinder (notes on RocketPy’s example rockets, Recovery).
The Valetudo case flies RocketPy’s own example, not the flight on Getting started. From the shared start, 800 m (2,625 ft) above the ground, it falls in still air under the example’s one drogue. With RocketPy’s drag area of 0.4537 m², it lands at 17.627 m/s (57.83 ft/s). Getting started flies the same airframe from the pad. That flight has its own drogue and a main parachute, in a 5 m/s (16 ft/s) wind (case file, Recovery).
In still air, Valetudo’s drift, 0.19 m (0.62 ft), comes only from the Earth’s rotation (the Coriolis acceleration). 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. HPR Sim 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. They’re Calisto, Valetudo, NDRT 2020, Juno III, Bella Lui and Prometheus 2022. They’re set up the same way (the decision on what’s compared):
- One declared drag coefficient, a constant 0.5 (case file), on the same reference area.
- The example’s launch rail, site, parachutes and motor. The thrust curve is flown as measured, with no correction for the site’s thinner air, 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 Sim’s own drag is compared below.
In short: how high, how fast and how long agree. So does where the rocket goes, except for rockets that leave the rail slowly in a wind. One of the six flights passes Mach 1, and three fly again in calm air. In all nine, the heights, speeds, times and accelerations agree within the 3% of each case’s gate (case file). The largest difference is +1.783% (report).
Still air means an example flown with no wind (Valetudo’s). Calm air is 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 (the wind-path decision).
Juno III and Bella Lui leave the rail slowly in the wind, at a steep angle to the airflow. There HPR Sim’s body lift, which RocketPy leaves out, moves their drifts. So do its later release from the rail and, for Juno III, its simpler fin model. Together they put the drifts 10.195% to 38.158% from RocketPy’s (report).
Prometheus 2022’s drifts 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 validation milestone’s landing offset 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. Rail-exit speeds must agree within 0.05%, landing speeds within 0.1%, burnout and top speeds and six burnout heights within 0.2%, six apogees within 0.35%, rail-exit times within 0.5%, and six apogee times within 1% (the tighter gates, more, the speeds, the apogees). The six are the flights with no written model difference. No same-drag apogee may read below RocketPy’s by more than 0.001%, since an apogee too low could wrongly clear a waiver; all nine read high today. Each case file argues why, for example Juno III’s. A number left unscored has its reason in its case file. Two more numbers compare the whole trace, 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 Sim also searches between its own step ends for the true peak. So its number doesn’t depend on where its solver happened to step.
That search can only raise a maximum. Against HPR Sim’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 wasn’t measured. Either way it’s far inside the 3% gate (the decision that also sets how peaks are found in both modes).
The definitions:
apogee_agl_mandapogee_time_s: the highest point, and when.flight_time_s: the time from ignition to landing.max_speed_m_sandmax_mach: the top speed over the ground, and the top Mach number.rail_exit_speed_m_sandrail_exit_time_s: when the forward rail button reaches the top of the rail, and the speed then. HPR Sim’s own rail-exit event waits for the last button, so the comparison finds RocketPy’s instant instead.burnout_altitude_agl_mandburnout_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_s2andmax_acceleration_time_s: the largest over the whole flight, and when. For NDRT 2020 that’s its main parachute opening, not a flight load (case file).apogee_drift_mandlanding_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. Heights are measured from where that point starts, as RocketPy’s are. HPR Sim’s own output follows the loaded rocket’s center of mass.
The nine flights are the six, and Juno III, Calisto and Bella Lui again in calm air. The validation report scores all but eleven of their numbers, and all the scored ones are within tolerance. The eleven are measured and reported but not scored, each for a reason in its case file (below). Every result of the report, as HPR Sim’s difference from RocketPy:
| case | apogee, % (apogee_agl_m) | apogee time, % (apogee_time_s) | flight time, % (flight_time_s) | top speed, % (max_speed_m_s) | top Mach, % (max_mach) |
|---|---|---|---|---|---|
flight-calisto-tests-motor-at-minus-1.373 | +0.052% | +0.103% | +0.123% | +0.015% | −0.120% |
flight-valetudo | +0.112% | +0.238% | +0.233% | +0.035% | −0.026% |
flight-ndrt-2020-nose-to-tail | +0.064% | +0.157% | +0.643% | +0.031% | +0.003% |
flight-prometheus-2022-generic-motor | +1.208% | +0.652% | +0.830% | −0.006% | −0.235% |
flight-juno-iii | +0.641% | +0.376% | +0.475% | +0.051% | −0.221% |
flight-bella-lui | +0.342% | +0.201% | +0.229% | +0.016% | −0.071% |
flight-juno-iii-calm | +0.085% | +0.073% | +0.066% | +0.015% | −0.123% |
flight-calisto-tests-motor-at-minus-1.373-calm | +0.045% | +0.099% | +0.118% | +0.022% | −0.105% |
flight-bella-lui-calm | +0.038% | +0.020% | −0.012% | +0.020% | −0.018% |
| case | rail-exit speed, % (rail_exit_speed_m_s) | rail-exit time, % (rail_exit_time_s) | burnout height, % (burnout_altitude_agl_m) | burnout speed, % (burnout_speed_m_s) | impact speed, % (impact_speed_m_s) |
|---|---|---|---|---|---|
flight-calisto-tests-motor-at-minus-1.373 | −0.010% | −0.072% | +0.019% | +0.019% | −0.020% |
flight-valetudo | −0.002% | −0.100% | +0.048% | +0.042% | +0.009% |
flight-ndrt-2020-nose-to-tail | −0.009% | −0.085% | −0.004% | +0.043% | +0.022% |
flight-prometheus-2022-generic-motor | −0.014% | −0.033% | +0.600% | −0.007% | −0.013% |
flight-juno-iii | −0.005% | −0.142% | +0.269% | +0.056% | −0.003% |
flight-bella-lui | −0.013% | −0.029% | +0.141% | +0.018% | +0.021% |
flight-juno-iii-calm | −0.002% | −0.137% | +0.042% | +0.020% | +0.001% |
flight-calisto-tests-motor-at-minus-1.373-calm | −0.001% | −0.074% | +0.023% | +0.025% | −0.003% |
flight-bella-lui-calm | −0.000% | −0.032% | +0.012% | +0.024% | +0.021% |
| case | peak acceleration, burning, % (max_acceleration_power_on_m_s2) | peak acceleration, % (max_acceleration_m_s2) | peak acceleration time, % (max_acceleration_time_s) | apogee drift, % (apogee_drift_m) | landing drift, % (landing_drift_m) |
|---|---|---|---|---|---|
flight-calisto-tests-motor-at-minus-1.373 | +0.099% | +0.099% | −96.811% | −0.902% | +1.257% |
flight-valetudo | +0.248% | +0.248% | +0.006% | −0.931% | −1.811% |
flight-ndrt-2020-nose-to-tail | −0.020% | +83.059% | +0.197% | −4.333% | +1.627% |
flight-prometheus-2022-generic-motor | +0.003% | +19.062% | +1.094% | −7.292% | +4.505% |
flight-juno-iii | −0.197% | −0.197% | +0.001% | −38.158% | +36.678% |
flight-bella-lui | +1.783% | +1.783% | +0.001% | −10.195% | −21.686% |
flight-juno-iii-calm | −0.012% | −0.012% | +0.046% | −1.750% | −1.807% |
flight-calisto-tests-motor-at-minus-1.373-calm | +0.108% | +0.108% | −96.811% | −0.246% | −0.415% |
flight-bella-lui-calm | +1.778% | +1.778% | +0.001% | −1.155% | −1.791% |
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 Sim’s height less RocketPy’s. To get it,
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, the point RocketPy’s series records.
Both are taken at RocketPy’s 120 series times, from ignition until HPR Sim 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). 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 in meters and meters per second, not percentages. Each is held to 3% of RocketPy’s apogee (for height) or top speed (for speed), or 1% and 0.5% (more). That’s the validation milestone’s 3% for one number, applied to the whole trace (case file).
All nine flights pass, each well inside its bound (the table below). The largest height RMS is Prometheus 2022’s, 35.4 m (116 ft), about a third of its 110.3 m (362 ft) bound. Its apogee is also the furthest off, +1.208%. Body lift accounts for that too. RocketPy flown with HPR Sim’s body lift and rail release reaches 3,723.8 m (12,217 ft), against HPR Sim’s 3,723.6 (case file). Juno III’s height RMS is 14.6 m (47.9 ft), about a fifth of its 78.4 m (257 ft). The other heights are under three tenths of theirs, and each speed RMS is under a third of its bound (report).
| case | height RMS, m (series_height_rms_m) | height bound, m | speed RMS, m/s (series_speed_rms_m_s) | speed bound, m/s |
|---|---|---|---|---|
flight-calisto-tests-motor-at-minus-1.373 | +1.84 | 26.1 | +0.0580 | 1.21 |
flight-valetudo | +2.12 | 7.7 | +0.172 | 0.56 |
flight-ndrt-2020-nose-to-tail | +2.43 | 12.1 | +0.125 | 0.91 |
flight-prometheus-2022-generic-motor | +35.4 | 110.3 | +1.55 | 10 |
flight-juno-iii | +14.6 | 78.4 | +0.810 | 6.7 |
flight-bella-lui | +1.66 | 15.9 | +0.274 | 2.9 |
flight-juno-iii-calm | +2.00 | 26.2 | +0.0658 | 1.13 |
flight-calisto-tests-motor-at-minus-1.373-calm | +1.82 | 26.1 | +0.0515 | 1.21 |
flight-bella-lui-calm | +0.0897 | 5.4 | +0.0227 | 0.49 |
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 (59 ft/s) in an 8.5 m/s (28 ft/s) wind, 26° off it (the wind-path decision). Three things differ there.
- HPR Sim’s normal force includes body lift, which grows with the square of that angle. RocketPy’s doesn’t. 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 Sim turns into it less.
- HPR Sim 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 Sim can’t model. RocketPy’s fin slope is 7.6% steeper than HPR Sim’s flat-plate one (the wind-path decision).
Juno III’s apogee is 245.3 m (805 ft) from the pad in HPR Sim and 396.6 m (1,301 ft) in RocketPy (−38.158%). Adding HPR Sim’s choices to RocketPy one at a time moves RocketPy’s apogee drift (the wind-path decision, measured by
wind_response.py). It’s 360.7 m (1,183 ft) with HPR Sim’s rail release and 286.5 m (940 ft) with its body lift too. With its fin slope as well, it’s 248.3 m (815 ft). Every windy drift lands within 1.3% of HPR Sim’s the same way. Bella Lui’s drifts are −10.195% and −21.686%. Prometheus 2022’s are −7.292% and +4.505%: within 0.1% of HPR Sim’s once RocketPy has its body lift and rail release (case file). NDRT 2020’s apogee drift is −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. That’s 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. That point is 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 a pull request to RocketPy, now merged. It builds on an earlier one, merged too. No release carries either yet. RocketPy 1.13.0 as installed still has the error, and the comparison applies both fixes (the wind-path decision). Without them, Juno III’s apogee drift was 582.4 m (1,911 ft). HPR Sim’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 Sim keeps the terms for the center of mass moving inside the body as the propellant burns. RocketPy’s rail equation leaves them out. At a sharp ignition spike, with thrust and mass the same to five digits, HPR Sim’s acceleration is 1.2 to 1.3 m/s² higher. That’s 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 Sim’s first peak the higher. So
max_acceleration_time_smoves from one peak to the other (−96.811%), and it’s reported but not scored. The peak’s size is scored, but its +0.099% compares two instants. At 0.05 s HPR Sim is 1.05% higher (report, case file). -
The main opening. RocketPy adds the air a canopy drags along (added mass), and HPR Sim has none. So NDRT’s peak deceleration as its main opens is +83.059% in HPR Sim, and Prometheus 2022’s is +19.062%. Both are 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. Both flights peak just above Mach 1, HPR Sim’s 0.235% below RocketPy’s. Until the normal force through Mach 1, HPR Sim stopped any flight at Mach 1, and the case was a known gap. Now it flies on its drag table to the ground (Aerodynamics). Its scored numbers agree within 1.208% (report). This flight is a light test of the transonic normal force. No committed check measures its angle of attack there. A local probe found it below 0.11 degrees from Mach 0.8 to 1.2 (case file).
What this shows: where rockets leave the rail slowly in a wind, the models differ, and which code is nearer the truth is for real flights to say. The real flights below so far compare heights, not drift. This says nothing about HPR Sim’s own drag, which the next section compares, or about a real flight. The comparison with OpenRocket is on its own page (HPR Sim’s flights against OpenRocket’s).
Whole flights with each code’s own drag
The same six flights fly again, in predicted mode. HPR Sim flies its own drag, from each design’s shape, where same-drag mode gives it the declared one. Both modes use HPR Sim’s own normal force, so only the drag differs. Everything else is set up as in the same-drag flights above (the predicted-mode decision).
RocketPy flies the drag each of its examples ships, as RocketPy 1.13.0 flies the example. That’s a drag curve for Calisto, Valetudo and Juno III, and a function of Mach for Prometheus 2022 (case file). It’s a constant for NDRT 2020 (0.44, case file) and Bella Lui (0.43, case file).
In short: HPR Sim’s heights are within 3% of RocketPy’s for Calisto (+0.601%), Bella Lui (+1.278%) and Juno III (+2.951%). They’re well above for Valetudo (+10.113%) and NDRT 2020 (+10.302%), where HPR Sim’s drag is well below the example’s. They’re 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-drag flights’ 3% (the validation milestone), but only as a target. The rail-exit and landing speeds are compared with 0.1% and the rail-exit time with 0.5% (the tighter targets). A miss doesn’t fail the test suite. It’s reported and explained in its case file (Valetudo’s and NDRT 2020’s, for example). The report is committed, so any number that moves shows up in review.
Every predicted result of the report, as HPR Sim’s difference from RocketPy:
| case | apogee, % (apogee_agl_m) | apogee time, % (apogee_time_s) | flight time, % (flight_time_s) | top speed, % (max_speed_m_s) | top Mach, % (max_mach) |
|---|---|---|---|---|---|
predicted-calisto-tests-motor-at-minus-1.373 | +0.601% | +0.209% | +0.411% | +0.500% | +0.371% |
predicted-valetudo | +10.113% | +6.179% | +8.916% | +2.292% | +2.237% |
predicted-ndrt-2020-nose-to-tail | +10.302% | +6.534% | +6.870% | +1.378% | +1.351% |
predicted-prometheus-2022-generic-motor | −7.280% | −4.920% | −4.978% | +1.280% | +1.069% |
predicted-juno-iii | +2.951% | +1.584% | +2.424% | +1.064% | +0.795% |
predicted-bella-lui | +1.278% | +0.732% | +1.011% | +0.273% | +0.185% |
| case | rail-exit speed, % (rail_exit_speed_m_s) | rail-exit time, % (rail_exit_time_s) | burnout height, % (burnout_altitude_agl_m) | burnout speed, % (burnout_speed_m_s) | impact speed, % (impact_speed_m_s) |
|---|---|---|---|---|---|
predicted-calisto-tests-motor-at-minus-1.373 | −0.009% | −0.071% | +0.328% | +0.729% | −0.020% |
predicted-valetudo | +0.029% | −0.109% | +1.326% | +2.883% | +0.009% |
predicted-ndrt-2020-nose-to-tail | +0.000% | −0.087% | +0.723% | +1.532% | +0.022% |
predicted-prometheus-2022-generic-motor | +0.001% | −0.036% | +1.227% | +1.778% | −0.013% |
predicted-juno-iii | −0.001% | −0.143% | +0.799% | +1.195% | −0.003% |
predicted-bella-lui | −0.010% | −0.029% | +0.288% | +0.336% | +0.021% |
| case | peak acceleration, burning, % (max_acceleration_power_on_m_s2) | peak acceleration, % (max_acceleration_m_s2) | peak acceleration time, % (max_acceleration_time_s) | apogee drift, % (apogee_drift_m) | landing drift, % (landing_drift_m) |
|---|---|---|---|---|---|
predicted-calisto-tests-motor-at-minus-1.373 | +0.190% | +0.190% | +0.002% | −0.644% | +1.597% |
predicted-valetudo | +0.250% | +0.250% | −0.030% | +12.215% | +10.437% |
predicted-ndrt-2020-nose-to-tail | +0.656% | +83.059% | +9.646% | +12.259% | +12.648% |
predicted-prometheus-2022-generic-motor | +0.848% | +19.062% | −6.903% | −17.642% | −6.167% |
predicted-juno-iii | +0.119% | +0.119% | +0.002% | −35.049% | +41.058% |
predicted-bella-lui | +1.797% | +1.797% | −0.029% | −8.940% | −20.255% |
The whole-trace numbers, in meters and meters per second, are defined as for the same-drag flights. Valetudo’s, NDRT 2020’s and Prometheus 2022’s height RMS are outside the target. So is NDRT 2020’s speed RMS. They miss for the reason their apogees do: HPR Sim’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 height RMS, 78.4 m (257 ft), is inside its 83.9 m (275 ft) here, at about nine tenths of it (report).
| case | height RMS, m (series_height_rms_m) | height bound, m | speed RMS, m/s (series_speed_rms_m_s) | speed bound, m/s |
|---|---|---|---|---|
predicted-calisto-tests-motor-at-minus-1.373 | +12.3 | 84.6 | +0.340 | 7.4 |
predicted-valetudo | +75.4 | 20.9 | +2.79 | 3.2 |
predicted-ndrt-2020-nose-to-tail | +116 | 38.1 | +6.78 | 5.5 |
predicted-prometheus-2022-generic-motor | +264 | 128.8 | +7.20 | 10.3 |
predicted-juno-iii | +78.4 | 83.9 | +1.13 | 6.8 |
predicted-bella-lui | +7.07 | 16.2 | +0.308 | 2.9 |
Why the misses, largest first:
- Valetudo and NDRT 2020 fly high: the drag. HPR Sim’s drag coefficient at Mach 0.3 is −47.0% from Valetudo’s table. That table is hand-edited, at 1.44 times the drag of the OpenRocket export for the same rocket (Aerodynamics). For NDRT 2020 it’s 0.318 against the example’s constant 0.44 (case file). These drags are compared at Mach 0.3 only. Less drag also means a later apogee, a longer descent and further to drift. That moves their times and drifts too.
- HPR Sim’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. These results compare HPR Sim’s drag for those designs, not for the rockets as built. For Valetudo, the rocket’s own OpenRocket finish and launch lugs take HPR Sim’s drag coefficient from 0.5566 to 0.714 (Aerodynamics). So a miss here isn’t a gap for HPR Sim to close toward the example’s drag.
- The drifts of Juno III and Bella Lui in wind: HPR Sim’s body lift and rail release, and Juno III’s fin slope. They act as in same-drag mode (the wind-path decision).
- Prometheus 2022 flies low: the drag again, the other way. Since the drag through Mach 1, it passes Mach 1 on HPR Sim’s own drag. It peaks at Mach 1.060 against RocketPy’s 1.048. Its coasting drag rises toward Mach 0.8, where the example’s falls. So HPR Sim peaks −7.280% low and sooner, and its drifts and times follow (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, the larger gaps are the two drags differing, not the flight. It doesn’t say which drag is right. The real flights below start to, one rocket at a time.
Real flights
In short: HPR Sim has flown 12 public real flights and compared each with its altitude log. Read the way each log’s altimeter reads the air, HPR Sim’s apogees miss the logs’ by 8.88% on average. That’s outside the 5% target (evidence row G24). With its sign the mean is −4.64%, and 7 of the 12 read low (report).
Seven are RocketPy’s logged flights, flown in ERA5 weather and compared as soon as they were flown (the decision). Their mean is 6.06%, and +0.03% with its sign. Five of them miss by more than 5%. Each has an explanation checked against the report’s numbers: four are consistent with HPR Sim’s drag, and one with the motor’s impulse. The other five flights were predicted first. They miss by 12.82% on average, and no explanation is claimed for them (report).
Seven of the 12 altimeters’ kinds are assumed and none is calibrated (evidence rows G21 and G39). In the ten designs built from RocketPy’s examples, a fin’s edge shape is a placeholder where no airfoil file or published section gives it (the predictions’ note on what is traced). So read the numbers as those 12 flights’ (report), not as a bound on every rocket. The rest of this part is about the seven compared first. The five predicted first have their own part.
What is flown. RocketPy’s documentation flies more than a dozen rockets against their teams’ logs. HPR Sim flies ten of them the way a user would: the seven here, and three of the flights predicted first. The design is built from the example’s masses and shapes, with HPR Sim’s own aerodynamics. The thrust is the example’s own file, read as RocketPy reads it, to the same total impulse.
It flies from the example’s launch rail and site. The weather is the launch hour’s, 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 Sim can fly today:
| rockets | why not yet |
|---|---|
| Camões, Halcyon, Hedy | they fly their teams’ own motors, outside HPR Sim’s scope of commercial motors (decision) |
| Valetudo, Defiance | their logs give an apogee, not a climb (decision) |
| Valkyrie | its inputs are only in a data file (decision) |
Astra, Andromeda and Erebus 11 are no longer left out: they are three of the five predicted first. Erebus 11 flies a COTS motor, a Cesaroni Pro54 K, most likely the 2437K660. Its thrust file gives 2,418 N·s over 3.657 s against that motor’s 2,437 N·s and 3.69 s (decision).
Juno III flies its team’s own motor too, but its design was already public. HPR Sim flies the thrust file as it would any other: nothing of the motor is modeled (decision).
The private designs add none. None is the rocket of a flight in the private collection of logs, so none has a log to compare with (the decision). A private flight collection added on October 4, 2026 pairs designs with their flights’ logs. Its 60 compared flights are below.
Reading the logs. Every log here comes from a barometric altimeter, or is assumed to (evidence rows G21 and G39). 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, and more on a cold one. It reads 6.5% less on a day 20 K warmer (worked example).
Two logs record their pressure, and their heights are that reading, to 0.195 m (0.64 ft) and 1.321 m (4.33 ft) (report). So HPR Sim’s height is read the same way, from the pressure of the air it flew in at its center of mass. The table gives HPR Sim’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, decision).
The kind of four of these seven altimeters is assumed rather than known (evidence row G21), and so is the kind of the three EuRoC 2022 ones among the flights predicted first (evidence row G39). Each row of the report gives its evidence. Reading all 12 logs as heights would give a mean of 7.90%, but five logs are known to be barometric. Reading only the seven assumed ones as heights gives 9.01%: the target is missed either way. Read that way, among the seven compared first, Lince, read as a height at 3,898.7 m (12,791 ft) against its log’s 3,587.7 m (11,771 ft), would miss by more than 5% with no checked explanation, and Genesis wouldn’t (report, decision).
Two logs also carry satellite (GNSS) heights, a geometric reference. Their barometric apogees are 0.943 and 0.935 of the satellite ones. HPR Sim’s conversion makes its own apogee 0.932 and 0.921 of its height (report). That’s 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 (66 ft) below its apogee, which would put its own ratio as high as 0.941 (decision).
Four of the seven logs are cut by hand just before a transient at their apogee, where the reading jumps. Juno III’s rises 62 m (203 ft) in 0.3 s as it levels off. The team’s reported apogee is that spike. At the cut its own velocity column still reads 17.5 m/s (57 ft/s) up. So its apogee may be 10 m (33 ft) to 20 m (66 ft) low (report). Cavour’s is read to its apogee event, just after its coast reached its peak of 2,785 m (9,137 ft). Two rows later its filtered height reads 2,789 m (9,150 ft), the team’s official apogee: a rise of 8 m (26 ft) in 0.2 s from a fall of 5 m/s (16 ft/s), which the rocket can’t fly. It comes about 2 s before the drogue charge most likely fires (decision).
What is compared.
- The apogee: the log’s highest reading, against HPR Sim’s highest point read the same way. A plus means HPR Sim flies higher.
- The climb: the root mean square (RMS) of HPR Sim’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 (98 ft). The RMS runs from there to the first of the two apogees (report). The descent isn’t 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 pinned copies of RocketPy and of the Macie XL repository (fetched with
cargo xtask refs fetch rocketpy rocketry-files) and commits only the numbers (report).
| flight | log apogee (m) | HPR Sim apogee (m) | apogee error | HPR Sim as a height (m) | climb RMS (m) | error on the team’s drag |
|---|---|---|---|---|---|---|
| Bella Lui, EPFL, 2020 | 459.0 | 464.0 | +1.10% | 464.7 | 3.7 | +0.24% |
| NDRT 2020, Notre Dame | 1,320.4 | 1,457.6 | +10.40% | 1,432.8 | 89.9 | +0.17% |
| Prometheus, Western Engineering, 2022 ¹ | 3,895.8 | 3,549.3 | −8.90% | 3,809.9 | 190.9 | +0.45% |
| Juno III, Projeto Jupiter, 2023 | 3,151.5 | 2,950.2 | −6.39% | 3,203.1 | 219.2 | −9.05% |
| Cavour, Politecnico di Torino, 2023 | 2,785.0 | 2,946.0 | +5.78% | 3,052.1 | 124.6 | −2.15% |
| Genesis, EuRoC 2023 | 2,916.7 | 2,746.0 | −5.85% | 2,875.3 | 95.2 | −0.08% |
| Lince, EuRoC 2023 | 3,587.7 | 3,732.5 | +4.04% | 3,898.7 | 69.9 | −12.20% |
¹ 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).
Over these seven the mean absolute apogee error is 6.06%, and over all 12 it is 8.88%, against the 5% target of the validation plan (gate and target). The largest climb RMS is Juno III’s, 6.95% 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 three 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 on the drag the example’s RocketPy notebook specifies, in place of HPR Sim’s. That drag is the team’s estimate, a table, a curve from RASAero II or a CFD analysis, or a constant given with no source. When the error falls inside 5%, the miss is consistent with HPR Sim’s drag. Neither drag is the truth. A team may have tuned its drag to this very flight. On the teams’ drag the seven’s mean absolute error is 3.48% (report).
A notebook can reshape its thrust file to a stated burn time and total impulse, as Juno III’s does. Where one does, a second diagnostic flies the file as recorded.
The five of the seven past 5%. Each explanation is a claim the report checks against its own
numbers. A change to HPR Sim that makes one false fails cargo xtask real-flights --check, which
runs only where the pinned copies are. CI checks each claim against the committed numbers
(decision).
- NDRT 2020 is +10.40%, consistent with HPR Sim’s drag. On the team’s constant drag coefficient, 0.44, the apogee is +0.17% (report). HPR Sim’s own drag is lower, as it was against RocketPy flying the same constant.
- Prometheus is −8.90%, consistent with HPR Sim’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 Sim’s conversion reads 1 to 2 points below the altimeter, both here and on Juno III. Juno III flew in its own day’s weather, so the wrong day’s share of the miss can’t be told apart.
- Juno III is −6.39%, consistent with the motor’s impulse. The notebook reshapes the team’s own motor curve to 8,800 N s, 4.9% less than the file. On the file as recorded (9,251.7 N s, its negative end read as zero) the apogee is +2.16%. On the team’s drag it’s −9.05% (report).
- Cavour is +5.78%, consistent with HPR Sim’s drag. On the curves the team labels RASAero II the apogee is −2.15% (report). HPR Sim’s drag is below those curves, 8.3% at Mach 0.3 with the motor off and 18.3% with it burning (Aerodynamics).
- Genesis is −5.85%, consistent with HPR Sim’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 Sim’s drag, is −12.20% on its team’s. That isn’t investigated (report).
Predicted before compared
In short: five more public flights were predicted before they were compared, and are now compared. Three are RocketPy’s logged flights from EuRoC 2022: Astra, Andromeda and Erebus 11. Two are flights of Macie XL, an OpenRocket design in a public repository. Those two are flown as the simulations saved in that design file, in standard air: no record gives the day’s weather. The five predicted apogees were merged, that is, committed to the project’s public history, before any of them was compared with its log (the predictions; decisions: the three, the two). Against their logs they miss by −6.53%, +4.14%, −8.05%, −16.20% and −29.16%. That is 12.82% on average, and −11.16% with its sign (report, the decision). One prediction was revised after it merged, Erebus 11’s, by a change to the base drag; both numbers are kept.
The seven flights above were compared as soon as they were flown. A number published only after
its comparison could have been tuned to its own miss, even without meaning to. These five went the
other way round. Their inputs, the rule each log’s apogee is read by, and HPR Sim’s
predictions went onto main first. The comparison came in a later change, which prints each
prediction below beside its error
(twelve public flights, predictions first).
| flight | impulse flown (N·s) | merged prediction (m) | flown today (m) | log apogee (m) | apogee error | as a height climbed (m) | every input traced |
|---|---|---|---|---|---|---|---|
| Astra (Cesaroni 4263L1350-P) | 4,280.2 | 3,037.1 | 3,037.1 | 3,249.5 | −6.53% | 3,155.4 | yes |
| Andromeda (its team’s thrust file) | 9,866.7 | 3,581.0 | 3,581.0 | 3,438.5 | +4.14% | 3,729.5 | no |
| Erebus 11 (a Cesaroni Pro54 K, the example’s thrust file) | 2,418.2 | 2,714.1 | 2,760.1 | 3,001.8 | −8.05% | 2,856.5 | yes |
| Macie XL, flight 1 (AeroTech I284W) | 599.5 | 706.2 | 706.2 | 842.8 | −16.20% | 706.3 | no |
| Macie XL, flight 2 (Cesaroni 601I350-16A) | 600.8 | 692.6 | 692.6 | 977.8 | −29.16% | 692.7 | no |
The error is of the apogee flown today, which for four of the five is the merged prediction to the digit printed. Worked from the printed numbers, the errors are −6.54%, −16.21% and −29.17% for Astra and the two Macie XL flights, and the same for the other two. Erebus 11 flies 46.0 m (151 ft) higher than its merged prediction since ADR-362 relieved the base behind a boattail below Mach 0.8; its merged prediction missed by −9.58% (report).
What the comparison shows. Four of the five read low, and four miss by more than 5%. The report claims no explanation for them. The two diagnostics it flies among the seven, each team’s drag and Juno III’s thrust file as recorded, aren’t flown for these five, and their climbs aren’t compared (the open issue). What the report does give is each flight’s tags, written before the comparison.
Astra and Erebus 11 are the two tagged as having every input traced. Over those two the mean is 7.29%, and −7.29% with its sign. The seven compared first carry no tag, because they were compared before tags existed, so they are counted in neither tagged group. Over the 10 flights flown in ERA5 weather the mean is 6.12%, and −1.03% with its sign (report, the decision).
How each log is read. By the rule merged with its prediction, which a test holds the reader to. The three EuRoC 2022 logs give the highest reading of their height column, with the log read whole. The two Macie XL logs give the apogee in the altimeter’s own header, never the highest sample. On flight 1 a spike of one sample lifts the highest sample to 1,052.8 m (3,454 ft), which is 210.0 m (689 ft) above the header’s apogee (report). Each log must be the file whose digest was committed with its prediction.
A prediction that changes. A merged prediction is never edited. If a later change to HPR Sim
or to an input moves one, cargo xtask real-flights fails until the code lists a revision for
it: the number flown now, and the reason. The report then prints both numbers and both errors,
and gives the means over the merged predictions too. One has been: Erebus 11, by ADR-362.
On the predictions as first merged, the 12 flights miss by 9.01% on average, and by −4.76%
with the sign (report).
The predicted apogee is what a barometric altimeter would read in the air the flight is flown in: the day’s for the three EuRoC 2022 flights, the stored simulation’s standard atmosphere for the two Macie XL flights. Each log is taken to be a barometric altimeter’s. For the three EuRoC 2022 flights that is assumed: no notebook says how its altimeter makes a height (evidence row G39). Astra’s reading is 3,037.1 m (9,964 ft), against a predicted climb of 3,155.4 m (10,352 ft) (the predictions). The reading is the lower of the two because an altimeter turns pressure into height with the standard atmosphere, and the air over the site that day was warmer than that (pressure altitude, the weather’s record). The comparison uses the reading, as it does for the seven.
Traced means the flight’s own record, here RocketPy’s example notebook, states every input that moves the apogee, bar what no RocketPy example records: the surface finish, the rail buttons’ size, the fins’ thickness where no airfoil file gives it, and their edge shape where no airfoil file or published section does. Those are placeholders in the designs built from the examples, the seven’s too, and they move the drag (the seven’s fin edges are evidence row G21’s guesses). So a traced flight’s inputs are stated, not exact.
How the three EuRoC 2022 flights are flown. By the seven’s method: the design built from the example’s masses and shapes, on the example’s own thrust file, from its rail and site, in the launch hour’s ERA5 air. The three share one weather file in a newer format. A committed script converts it and checks that the four fields’ values survived bit for bit (ERA5 weather files).
Andromeda is tagged not traced. Two things that move its apogee aren’t settled by its record. It flew air brakes, and nothing public says whether, when or how far they opened. If they did, a flight with none, like this one, reads high by an unknown amount. Its thrust file also holds 9,866.7 N·s, more than the 8,428.7 N·s on the bundled certified curve of the Cesaroni M2020 it is named for. On that curve the same design, at the same mass, is predicted at 3,050.3 m (10,008 ft). That figure is shown for scale and enters no average of errors. Against the log it reads −11.29% (report). The counted prediction is the team’s file’s, as every RocketPy flight here flies its example’s own thrust file. It is also the one prediction of the five that passes Mach 1, at Mach 1.019 (the predictions, Andromeda’s thrust curve).
The two Macie XL flights have no example notebook. Their record is a public repository (MIT): one OpenRocket design file, a page about the rocket and each flight’s logs. HPR Sim reads the file whole, as OpenRocket 24.12 saved it. Its stage’s mass override adds to its parts (a stage’s added mass). The file holds a stored simulation named for each flight: an OpenRocket run saved inside the design file, with its motor and its launch conditions. That is what is flown: its motor, from its vertical 1 m (3.3 ft) rod, in its steady 2 m/s (6.6 ft/s) wind and the standard atmosphere, at sea level (the Macie XL predictions). Four things are left out: the stored wind’s turbulence, the parachutes (the file opens one at apogee and the other lower, on the way down, so neither moves the apogee), the day’s weather and each pad’s height above sea level.
ThrustCurve.org can hold several data files for one motor, and HPR Sim bundles them. Each motor’s
thrust comes from the bundled file that the design names by its digest, the
file holding the curve OpenRocket flies. For the I284W that is not the first file of the bundle,
whose thrust is as far from OpenRocket’s curve as 0.372989 of that curve’s peak thrust
(the decision). The I284W’s masses stay the bundle’s for the motor, as every bundled
motor’s do: 313.6 g of propellant and 555.52 g loaded, where the digest’s file and OpenRocket give
310.016 g and 555.072 g. Both logs are a PerfectFlite altimeter’s, which is barometric
(.pf2 files). At these apogees, in the standard atmosphere, the reading and
the climb agree within 0.1 m (0.33 ft).
Both are tagged not traced (the decision). For these two the record is the
repository: its design file, its page and its logs. It gives no date, weather or rail. Of the
launch site it gives only each log’s pad height above sea level, 3.7 m (12 ft) for flight 1 and
11.3 m (37 ft) for flight 2. The stored simulation’s conditions are flown, its sea level among
them; all nine simulations in the file carry the same ones. Nothing says the rocket was weighed as
flown. And HPR Sim’s .ork reader warns on both curve files. The I284W file’s impulse is 1.28%
from ThrustCurve.org’s figure for the motor. The 601I350-16A file’s loaded mass is 616.3 g,
against ThrustCurve.org’s record of 782.0 g. The file the design names is flown all the same, and
each warning is kept with its prediction.
The design file also keeps the apogees OpenRocket’s own runs of the two simulations reached, 704.6 m (2,312 ft) and 691.6 m (2,269 ft) (the decision). They are another simulator’s numbers, not measurements, and are shown beside the predictions without being counted. Where the two programs agree, that is one program agreeing with another on the same file. It says nothing about how close either is to what flew.
Against the logs those two runs read −16.40% and −29.26%, beside HPR Sim’s −16.20% and −29.16% (report). So both programs miss these two flights by about as much, on a file whose record leaves the day’s air, the rail and the flown mass untraced. The report doesn’t say which input, if any, is behind the miss.
The choice to fly each stored simulation’s own conditions, and the tags, were written after HPR
Sim had first flown the file at hpr sim’s defaults, and that run’s apogee had been seen
(the decision). That order is the
maintainer’s statement; no check can show it.
RocketPy and the Macie XL repository had published the measured apogees before the predictions were made. Each log was also looked at, for its columns and for a spike near its peak, before its rule was fixed. The code keeps the merged apogees as first merged, to the digit the page prints, and Erebus 11’s revision beside its own (report). A test that CI runs fails a committed report whose prediction has moved from them with no revision listed.
Flying them again needs RocketPy’s files and the Macie XL repository’s, which CI doesn’t
have. After cargo xtask refs fetch rocketpy rocketry-files and the weather file’s
conversion,
cargo xtask public-predictions --check fails when a prediction flown now differs from the
committed one. cargo xtask real-flights --check flies all 12, reads the five logs again and
fails when the committed report doesn’t reproduce. The list of merged apogees is in the code, so a change to it shows in the code’s
history.
Real flights of the private collection
These are a private collection’s logged apogees (the decision), rechecked against the collection’s catalog (the recheck). In short: HPR Sim and OpenRocket flew 60 real flights in the weather of their day. Both over-predict: HPR Sim’s apogees are +8.01% above the logs on average (mean absolute 12.09%), OpenRocket’s +6.72% (11.26%). The two codes agree within 5% on 59 of the 60 (report). Neither meets the 5% target.
Where the two codes differ from each other, it is mostly in drag: drag is the largest part of the gap on 61 of the 68 flights both fly (report; the gap between the two codes, by cause).
The report’s histogram gives the low side, the one a waiver depends on: its bins below zero hold the flights whose simulated apogee is below the logged one.
The gap to the logs is mostly not a difference between the two codes, and what causes it isn’t shown here. The flights’ owners allow only aggregate statistics, so no flight is named here.
Held out. A hash of each flight’s id holds out a third in expectation, here 23 of the 60 (decision). On them HPR Sim misses by 16.34% (mean absolute) and OpenRocket by 14.98%; on the other 37, 9.45% and 8.95% (report). Fits across flights, the scoreboard’s check included, leave the 23 out. All 60 were seen before the split, so neither half is blind. A flight added later is compared only once its prediction, made with no logged apogee, has its hash merged first.
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
(decision).
Of its 89 best-documented flights (tier A, a first grading), 83 have an OpenRocket .ork design
(report). Its catalog, a
second reading of each flight’s sources made later, proposes a tier for each again
(recheck):
- A: the design, motor, log, day and site are each tied to the flight;
- B: one of them is inferred, most often the motor;
- C: the design isn’t shown to be the rocket flown.
HPR Sim 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 (164 ft) (report). Both fly OpenRocket’s curve for the motor the file names, from the same rail, with no parachute opened. A third row flies HPR Sim 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 (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.0366 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. Of the 83 readings, 24 differ from the collection’s own figure by more than 0.5%, each with its reason recorded (decision).
| over 60 flights | mean | median | mean absolute | flights within 5% | flights within 10% |
|---|---|---|---|---|---|
| HPR Sim | +8.01% | +7.60% | 12.09% | 12 | 31 |
| OpenRocket 24.12 | +6.72% | +6.08% | 11.26% | 13 | 31 |
| HPR Sim in OpenRocket’s air | +8.15% | +7.60% | 12.19% | 12 | 30 |
| HPR Sim against OpenRocket | +1.18% | +0.95% | 1.73% | 59 | 60 |
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 Sim’s apogee less OpenRocket’s, over OpenRocket’s. A positive value means HPR Sim flies higher. “Within 5%” and “within 10%” count the flights whose error is strictly smaller than that, either way (report).
The gap between the two codes, by cause
The last row above is over the 60 flights compared with a log. Both codes fly 68: those 60 and the 8 left out of the errors above, which the split can use because it needs no log. Over the 68, HPR Sim’s apogee is +0.98% above OpenRocket’s on average (mean absolute 1.68%, report). The split (decision) sizes how much of that gap each input carries. HPR Sim flies each flight again with OpenRocket’s own inputs in place of its own, one after another, each added to the ones before:
- Thrust: the thrust OpenRocket flew, against time.
- Mass: OpenRocket’s mass and center of mass, against time.
- Drag: OpenRocket’s drag coefficient along its own flight, against Mach number, one curve while the motor burns and one after.
- Air: OpenRocket’s air, the standard atmosphere through the pad’s temperature and pressure, in place of the day’s profile.
Each swap moves HPR Sim’s apogee, and that move is the swap’s part: the apogee before the swap less the apogee after it, over OpenRocket’s apogee. A positive part means the input as HPR Sim has it flies higher than OpenRocket’s does. So a positive drag part means HPR Sim’s drag is the lower of the two over that flight. Other is everything after the third swap, in two pieces. The air is the fourth swap’s part. The rest is what remains once all four inputs are OpenRocket’s: HPR Sim’s apogee on them less OpenRocket’s own. Thrust, mass, drag and other sum to the whole on every flight, and the run that writes the report stops on a flight where they don’t.
In the table, a part dominates a flight when its absolute value is the largest of the four. The last column counts the flights where a part’s absolute value is over 1% (report). A cell reading n/a is not counted. The rows below the four parts are pieces of other (the air and the rest) or checks on the parts (the whole, and drag swapped first), so none of them dominates a flight. Of those rows only the rest counts its flights over 1%, for the reading of the mass swap below.
| over 68 flights | mean | median | mean absolute | flights it dominates | flights where it is over 1% |
|---|---|---|---|---|---|
| thrust | +0.00% | +0.00% | 0.00% | 0 | 0 |
| mass | +0.10% | +0.00% | 0.10% | 1 | 1 |
| drag | +0.85% | +0.76% | 1.64% | 61 | 39 |
| other | +0.03% | +0.01% | 0.26% | 6 | 4 |
| other: the air | −0.15% | −0.17% | 0.25% | n/a | n/a |
| other: the rest | +0.18% | +0.19% | 0.33% | n/a | 2 |
| the whole | +0.98% | +0.85% | 1.68% | n/a | n/a |
| drag, swapped first | +0.85% | +0.76% | 1.64% | n/a | n/a |
All 68 flights are split. None lacks an input in OpenRocket’s record, none is refused by HPR Sim, and none fails the check on the thrust and mass swaps (report, thrust and mass from another program).
What the rows say:
- Drag is most of the gap. It is the largest part on 61 of the 68 flights, and its mean absolute value, 1.64%, is nearly the whole’s 1.68% (report). Its sign varies from flight to flight: its mean is +0.85%. Swapped first instead of third, its mean, median and mean absolute value are the drag row’s to the report’s two decimals. The report puts the drag swap in only these two places, first and third.
- Thrust is nil. Both codes fly the same thrust curve for each motor. Swapping in the thrust OpenRocket made of it moves the apogee by 0.00% on average, to the report’s two decimals (report).
- Mass is small on most flights. Its median is 0.00%, and it is over 1% on one flight, so its mean, +0.10%, isn’t typical of the flights (report).
- The air is small. With thrust, mass and drag already OpenRocket’s, HPR Sim flies 0.15% lower on average in the day’s profile than in OpenRocket’s air (mean absolute 0.25%, report).
- The rest holds what no swap replaces. With all four inputs OpenRocket’s, HPR Sim still flies 0.18% above OpenRocket on average (report). What stays HPR Sim’s through every swap is in it: the normal force, the center of pressure, the damping of pitching and yawing motion, the inertia, the steps in time, gravity, and what the drag table leaves out. None of those is measured apart here.
The mass swap and stability. After the mass swap HPR Sim flies OpenRocket’s center of mass against its own center of pressure. Where the two codes put the center of mass apart, that moves HPR Sim’s stability margin. What it does to the apogee is in the mass row, and no later swap undoes it: the flight on all four swaps keeps it, and the rest is measured from that flight to OpenRocket’s own. So the rest can take back what the mass row holds. On the one flight where the mass part is over 1%, the rest is over 1% too, with the opposite sign, which fits that reading and doesn’t prove it (report). The report counts such a flight by the two signs and the 1% floor alone, not by how much of the mass part the rest takes back. An open issue follows that flight (#1486): the lead is that the two codes weigh the rocket the same but put its center of mass apart.
As a worked example on a design anyone can run, take
mach-probe, an invented test
rocket that both codes fly faster than sound in still standard air. HPR Sim’s apogee is 3.06%
above OpenRocket’s, and the drag part is 3.03%: over that flight HPR Sim’s drag is the lower. Thrust and
mass are each under 0.005%, the rest is under 0.05%, and the air’s part is zero, since both fly
the same air. On the slower
pods-none the whole is 0.81% and the
drag part 0.79%. A test holds each of those (the test,
the_public_flights_split). From a clone, cargo test -p xtask the_public_flights_split
runs it. It needs neither OpenRocket nor the private flights: OpenRocket’s record of both
designs is committed.
The split has limits. The drag swap is a table in Mach number read from OpenRocket’s own flight, so it leaves out how OpenRocket’s drag changes with the Reynolds number and the angle of attack away from that flight’s path. The air’s part is taken with that table in place, so it holds the air’s density and speed of sound, not what the air does to friction. The mass swap keeps HPR Sim’s inertia and can change its stability, as above. And the split doesn’t say which part of the drag differs. One part is sized by itself, below: the pressure drag of tangent-ogive noses above Mach 1. And the drag part is split by Mach band.
Early deployments. On 19 of the 60, 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 (decision). Without them, over 41 flights, HPR Sim is +3.70% (mean absolute 9.46%) and OpenRocket +2.41% (8.81%). The two sets differ in which rockets they hold more than in what the early charges cost.
The recheck. The catalog flagged 68 of the 83 flights where its reading and this comparison’s differed. Each flag was settled against the flight’s log and sources (decision). Most changed nothing: a simulator’s miss, a spin or a recovery fault after apogee stays in the comparison. Four flights changed, and every flight gained its proposed tier:
- one launch day moved to the event’s date;
- one logged apogee dropped 0.23%, to the reading before a drogue charge (decision);
- one flight left the errors because it tumbled through its climb, which the drawn design, at over 3 calibers of margin, can’t show;
- one left because its posted design is the flier’s later, heavier rebuild.
Nothing in HPR Sim changed at the recheck; the comparison’s flights did. The recheck lowered HPR Sim’s mean error over the compared flights, and the tumbling flight explains more than all of the fall: its error was the largest in the set by a wide margin, and leaving it out lowered the mean by 1.28 points. Leaving out the rebuild raised it by 0.19 (decision). Later, HPR Sim came to read a fin tab as its file states it, even past the root’s ends (decision), and so flies seven more of the flights (#357), which gives the 60 compared above (report).
The catalog proposes 15 flights below tier A (decision). Over the 49 compared flights it keeps in tier A (report):
| over 49 flights | mean | median | mean absolute | flights within 5% | flights within 10% |
|---|---|---|---|---|---|
| HPR Sim | +7.30% | +7.10% | 11.60% | 9 | 26 |
| OpenRocket 24.12 | +6.09% | +5.84% | 10.84% | 10 | 26 |
What is not flown, and why. Of the 83, HPR Sim flies 68, and each cause of the rest has an open
issue (report). OpenRocket flies 79, missing the motor in one
(#362). For HPR Sim, most are small
reading problems in its .ork importer that OpenRocket accepts:
- 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);
- a part in an off-axis inner tube (2, #181).
Two 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).
The six tier-A flights in other formats wait until HPR Sim reads RockSim, RASAero and RocketPy files. The climb traces wait for their logs to be read.
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.
The tangent-ogive nose’s line
This part goes back to the gap between the two codes and sizes one difference inside its drag part: the pressure drag of a tangent ogive nose above Mach 1 (M2.3c13, the nose’s line, decision). Pressure drag is the drag from the air’s pressure on the nose, mostly wave drag past Mach 1. It is for anyone comparing the two codes on a rocket that flies faster than sound. Like the split, it is code against code, and here over 5 flights only. None of the 5 passes Mach 1.3, so the line sizes how the two noses differ between Mach 1 and 1.3 (report). The public probe covers that band too: there OpenRocket 24.12’s nose coefficient is below HPR Sim’s at each of the 31 Mach numbers from 1 to 1.3, in steps of 0.01, by 0.155 to 0.163 on the nose’s base area (the probe).
From Mach 1.3 up, OpenRocket 24.12 gives a tangent-ogive nose almost no pressure drag. HPR Sim gives it the drag of the cone with its length and base. On an invented rocket at Mach 1.5 the nose’s coefficient is 0.00073 in OpenRocket and 0.13028 in HPR Sim, both on the nose’s base area (the probe). Between Mach 1 and 1.3 each code joins its value at Mach 1 to its value at Mach 1.3. HPR Sim’s rises to 0.23428 at Mach 1.1, and OpenRocket’s to a hump of 0.07551 there, falling to 0.00098 at Mach 1.3 (the probe). A maintainer of OpenRocket confirmed the defect and merged a fix, which no release carried by November 14, 2026 (the probe’s section).
The line is taken inside the drag step. With thrust and mass already OpenRocket’s, HPR Sim flies once more with one thing changed: above Mach 1, the nose’s pressure drag is the one OpenRocket reports for that nose, at each Mach number. Everything else in the drag stays HPR Sim’s. On the probe, whose tube is as wide as the nose’s base, at Mach 1.5 that takes 0.13028 off the rocket’s drag coefficient and puts 0.00073 back (the probe’s table). The flight after that is the drag swap as before, on OpenRocket’s whole drag.
- The nose’s line is the apogee before the nose’s swap less the apogee after it, over OpenRocket’s apogee. A negative line means HPR Sim climbs lower on its own nose drag than on OpenRocket’s.
- The rest of the drag is the apogee after the nose’s swap less the apogee on OpenRocket’s whole drag.
The two sum to the flight’s drag part, and the run that writes the report stops on a flight where they don’t.
The line’s flights are those both codes fly whose own HPR Sim flight passes Mach 1 with a tangent-ogive nose: 5 of the 68. All 5 are swapped (report).
| over the 5 flights swapped | mean | median | mean absolute |
|---|---|---|---|
| the nose’s pressure drag above Mach 1 | −1.28% | −1.33% | 1.28% |
| the rest of the drag | −0.43% | +0.90% | 2.02% |
| the drag part | −1.71% | +0.51% | 2.40% |
What the rows say:
- The nose’s line is small, and negative. On its own nose drag HPR Sim climbs 1.28% lower on average than on OpenRocket’s. The mean absolute value is the same to two decimals, so the line is negative on every one of the 5, to that rounding (report).
- These flights only just pass Mach 1. Their top Mach numbers, by HPR Sim’s own flights, average 1.06, and none passes Mach 1.3 (report). That is the band from Mach 1 to 1.3, where the probe’s runs from Mach 1 to 1.3 set the two noses side by side (the probe). So the line sizes how the two codes’ noses differ just past Mach 1, not the near-zero drag OpenRocket gives from Mach 1.3 up. It says nothing of a faster flight.
- The rest of the drag is larger in mean absolute value, and of either sign. It is 2.02% against the nose’s 1.28%, with a mean of −0.43% and a median of +0.90% (report). In the means the nose is most of the drag part, −1.28% of −1.71%, because the rest’s positive and negative flights partly cancel.
A flight of the line that can’t be swapped is counted under a reason. The column here is
OpenRocket’s pressure drag for the nose against Mach number, as recorded for that design. The
reasons: more than one nose cone; a flight not split; no column in OpenRocket’s record; a nose
whose drag the design states, itself or through a stage or parent that covers it; or a flight
that HPR Sim fails with the column in or that leaves the Mach numbers the column covers. Each
counts 0 flights (report). A
test holds the rule for the line’s flights and each reason on public designs
(the tests);
from a clone, cargo test -p xtask nose_line runs them without OpenRocket or the private
flights.
The flight this difference was first found on is not in the line. It is in the design library’s report, not this one, and that report holds no record of OpenRocket’s thrust and mass against time, which the line is taken on (#222, the supersonic drag gap to OpenRocket). The library’s report swaps the nose on it instead, on HPR Sim’s own thrust and mass. The swap alone moves the flight’s apogee from +13.60% to +31.73% of OpenRocket’s. With OpenRocket’s base rule under power as well, it comes to +0.45% (a supersonic flight).
The drag part by Mach band
This part takes the drag difference between HPR Sim and OpenRocket in the gap between the two codes and splits it by the speed the drag acts at, over the same 68 flights of the private collection (report; M1.14i1, the drag part by Mach band, decision). It is for anyone asking where the two codes’ drag differs, and it set what the project works on next. By mean absolute value, the largest share is below Mach 0.8. Like the split, the parts are code against code: they don’t say which code is nearer a real flight, and the flights are private, so no table by flight is shown. A second table sets the bands beside the logs.
The bands are in Mach number: below 0.8, from 0.8 to 1.2, and above
1.2 (report). The report’s data names them subsonic, transonic and
supersonic (as data); the first stops at Mach 0.8, short of the speed
of sound, where the second begins
(transonic and supersonic). A Mach number at an edge
is in the faster band
(the tests,
a_mach_number_s_band). With thrust and mass already OpenRocket’s, HPR Sim flies three
more times. First OpenRocket’s drag coefficient replaces its
own below Mach 0.8 only. Then it does below Mach 1.2. Then at every Mach number, which is the
split’s drag swap. Outside the bands swapped the drag stays HPR Sim’s own.
- A band’s part is the apogee before its swap less the apogee after it, over OpenRocket’s apogee. A positive part means HPR Sim’s drag in that band is the lower of the two over that flight.
- A flight has a part in a band when that part is not zero: the swap changed the flight. A swap that changes no drag the flight reads leaves it the same to the last digit, so its part there is exactly zero. The flights with a part are the ones that reach the band, or come close enough that one of the solver’s time steps reads the drag inside it.
- A band dominates a flight when its part’s absolute value is the largest of the three. The table’s last column counts the flights where that absolute value is over 1% (report).
The three parts sum to the flight’s drag part, and the run that writes the report stops on a flight where they don’t. All 68 flights split are split by band (report).
| over 68 flights | flights with a part in it | mean | median | mean absolute | mean absolute over those flights | flights it dominates | flights where it is over 1% |
|---|---|---|---|---|---|---|---|
| below Mach 0.8 | 68 | +0.39% | +0.29% | 0.94% | 0.94% | 50 | 24 |
| Mach 0.8 to 1.2 | 28 | +0.24% | +0.00% | 0.48% | 1.16% | 11 | 9 |
| above Mach 1.2 | 7 | +0.23% | +0.00% | 0.23% | 2.21% | 7 | 7 |
| the drag part | 68 | +0.85% | +0.76% | 1.64% |
The mean, the median and the mean absolute value are over all 68 flights, zeros included, so the two faster bands’ medians are +0.00%: most flights have no part there. The next column is over the band’s own flights only (report).
What the rows say:
- Below Mach 0.8 is the largest band. Its mean absolute part is 0.94% of the apogee, against 0.48% and 0.23%, and it dominates 50 of the 68 flights (report). Every flight has a part in it.
- The faster bands are larger where they act. Over the flights with a part in them, the mean absolute part is 1.16% from Mach 0.8 to 1.2 and 2.21% above Mach 1.2 (report). They rank lower over the collection because their swaps change fewer flights: 28 and 7.
- Below Mach 0.8 the sign varies from flight to flight. The mean is +0.39% against a mean absolute 0.94% (report).
- Above Mach 1.2 HPR Sim’s drag is the lower. Over the 7 flights with a part in that band, its mean and its mean absolute value are both 2.21%, and each of the 7 is over 1%. So its part is positive on each of the 7 (report, as data).
Each swap changes the speed the next band is flown at, so a band’s part depends on the swaps before it. To check that, each band is also swapped alone, first: on HPR Sim’s own thrust and mass, with its own drag in the other two bands. Over the collection the two ways give sizes within 0.01 points of each other: alone, the three bands’ mean absolute parts are 0.94%, 0.48% and 0.24% (report).
Beside the logs. Four kinds of flight are set beside the logged apogees of the 60 flights compared: HPR Sim’s own, HPR Sim’s with one band swapped alone, HPR Sim’s on OpenRocket’s whole drag, and OpenRocket’s own. Each row is the apogee less the logged one, over the logged one. A row moves a flight when its apogee is not that of HPR Sim’s own flight. The last two columns count the moved flights that come nearer their log than HPR Sim’s own flight, and the ones that go farther (report). The first row is HPR Sim as it flies, and the last is OpenRocket’s own flight. The four between fly HPR Sim’s own thrust and mass, and none of them is a model HPR Sim could fly: the coefficient is read, by Mach number, along OpenRocket’s own flight of the same design.
| HPR Sim’s drag, over 60 flights | flights moved | mean | median | mean absolute | flights nearer their log | flights farther from it |
|---|---|---|---|---|---|---|
| its own | +8.01% | +7.60% | 12.09% | |||
| OpenRocket’s below Mach 0.8, its own above | 60 | +7.45% | +6.77% | 11.68% | 38 | 22 |
| OpenRocket’s from Mach 0.8 to 1.2, its own elsewhere | 25 | +7.68% | +7.46% | 11.81% | 16 | 9 |
| OpenRocket’s above Mach 1.2, its own below | 7 | +7.72% | +6.66% | 11.91% | 6 | 1 |
| OpenRocket’s at every Mach number | 60 | +6.85% | +6.33% | 11.27% | 38 | 22 |
| OpenRocket’s own flight, for comparison | 60 | +6.72% | +6.08% | 11.26% | 40 | 20 |
- On OpenRocket’s whole drag, HPR Sim’s mean absolute error is OpenRocket’s to 0.01 points: 11.27% against 11.26%. Its mean stays above OpenRocket’s, +6.85% against +6.72%, and so does its median, +6.33% against +6.08% (report).
- The band below Mach 0.8 moves the score the most. Its swap alone takes HPR Sim’s mean absolute error from 12.09% to 11.68%. The band from Mach 0.8 to 1.2 takes it to 11.81%, and the one above Mach 1.2 to 11.91%. Part of that is reach: the first swap moves all 60 flights, the others 25 and 7 (report).
- Not every flight comes nearer. With OpenRocket’s drag below Mach 0.8, 38 flights come nearer their log and 22 go farther (report).
As a worked example on designs anyone can run, take the two public test rockets of
the split.
pods-none
stays below Mach 0.8, so its drag part of 0.79% is all in the slowest band, and its parts in the
other two are exactly zero.
mach-probe
passes Mach 1.2. Its three parts are −0.08%, +0.26% and +2.85%, which sum to its drag part of
3.03%: nearly all of that flight’s drag difference is above Mach 1.2. A test holds each of
those (the tests,
the_public_flights_split_by_band). From a clone, cargo test -p xtask drag_bands runs it,
with neither OpenRocket nor the private flights.
What it decided. The band below Mach 0.8 was worked on next: M1.14i, drag below Mach 0.8 (the decision that orders the work). Over these flights it has the largest mean absolute part, 0.94% against 0.48% and 0.23%, and it dominates the most of them (report). The faster bands are larger where they act, but on 28 and 7 flights; they keep the steps they had. The steps the accuracy work takes by Mach band began at Mach 0.8, so this band needed one of its own. That step first splits the band’s part into friction, pressure and base drag. It then looks for a measurement of the largest of the three, from a wind tunnel or a flight, to check HPR Sim’s model against; if it finds none to add, the step ends there with the gap written down. It does not make HPR Sim’s drag OpenRocket’s.
The slowest band, by term
This part takes the band below Mach 0.8 and splits its share of the drag difference by the term of the drag it comes from: friction, pressure and base drag, over the same 68 flights (report; M1.14i2, the part below Mach 0.8 by term, decision). It is for anyone asking which of HPR Sim’s drag models to check first. The largest term is the base drag, four fifths of it while the motor burns; the pressure term, of the other sign, cancels part of it. Like the bands, the parts are code against code. A measured reference of that term is then the check (below).
The terms, set against each other. OpenRocket’s flight data splits its
drag coefficient into friction, pressure and base. The two
codes don’t file every part of the drag under the same name, so a small probe flies one public
design four more times in OpenRocket, each time with one thing added, and records which of
OpenRocket’s terms moves (record, written by
drag_terms.py):
- A launch lug or rail buttons raise OpenRocket’s pressure term by 0.012 to 0.018 and leave its base alone. HPR Sim files them as parasitic drag, so its pressure term here is its pressure plus its parasitic drag.
- A drag coefficient stated for a part shows up in none of OpenRocket’s three terms: the coefficient less the three is the stated value, 0.3 on the body tube and three times 0.3 on a three-fin set (the probe). So the fourth term, the rest, is a stated coefficient in both codes.
Each code’s four terms sum to its whole coefficient, under power and coasting, and a test holds
both sums and the probe’s record
(the tests,
each_codes_four_terms_sum_to_its_whole,
openrocket_books_lugs_and_buttons_as_pressure_and_stated_drag_in_the_rest).
The split. With thrust and mass already OpenRocket’s, HPR Sim flies four more times. OpenRocket’s friction replaces its own below Mach 0.8, then its pressure too, then its base, then its rest. Above Mach 0.8 the drag stays HPR Sim’s own. A term’s part is the apogee before its swap less the apogee after it, over OpenRocket’s apogee. A positive part means HPR Sim’s term is the lower of the two over that flight. The last of the four flights is the band’s own flight below Mach 0.8, to the last digit, so the four parts sum to the band’s part, and the run that writes the report stops on a flight where they don’t. All 68 flights split by band are split by term (report).
| over 68 flights | flights with a part in it | mean | median | mean absolute | flights it dominates | flights where it is over 1% |
|---|---|---|---|---|---|---|
| friction | 68 | −0.17% | −0.16% | 0.17% | 0 | 0 |
| pressure, launch lugs and rail buttons among it | 68 | −0.64% | −0.11% | 0.66% | 17 | 12 |
| base | 68 | +1.20% | +0.91% | 1.20% | 51 | 33 |
| the rest: stated drag coefficients | 0 | +0.00% | +0.00% | 0.00% | 0 | 0 |
| the part below Mach 0.8 | 68 | +0.39% | +0.29% | 0.94% |
A term dominates a flight when its part is the largest of the four in absolute value, and the last column counts the flights where its part is over 1% of the apogee (report).
What the rows say:
- The base is the largest term. Its mean absolute part is 1.20% of the apogee, against 0.66% for pressure and 0.17% for friction, and it dominates 51 of the 68 flights (report). It is positive: HPR Sim’s base drag is the lower of the two.
- Most of the base difference is the base under power. On a flat base, coasting, the two
codes’ base drag agree: 0.13170 against 0.13170 at Mach 0.3 on the public test rocket, a test’s
pinned numbers
(the tests,
both_codes_terms_are_pinned_at_mach_0_3_and_0_6). While a motor burns, HPR Sim takes the burning motor’s cross-section off the base, and OpenRocket 24.12 keeps the whole base. Behind a boattail below Mach 0.8, HPR Sim keeps of the flat-base value and OpenRocket all of it, since ADR-362 (below). Swapped alone, the base moves HPR Sim’s apogee by a mean absolute 1.17%; swapped only while a motor burns, by 0.94% (report). - Pressure and the base partly cancel. The pressure term is negative, HPR Sim’s the higher. Its mean, −0.64%, is far from its median, −0.11%, and it is over 1% on 12 flights. That is why the band’s mean, +0.39%, is smaller than its mean absolute part, 0.94% (report).
- Friction is small. Its part never dominates a flight (report). On the
public test rocket HPR Sim’s friction is the higher: 0.30690 against OpenRocket’s 0.30310 at
Mach 0.3
(the tests,
both_codes_terms_are_pinned_at_mach_0_3_and_0_6). - No flight states a drag coefficient in either code, so the rest is zero on every flight.
Beside the logs. As with the bands, each term is also swapped alone, on HPR Sim’s own thrust and mass, and set beside the logged apogees of the 60 flights compared. The columns are the bands’ (report).
| HPR Sim’s drag, over 60 flights | flights moved | mean | median | mean absolute | flights nearer their log | flights farther from it |
|---|---|---|---|---|---|---|
| its own | +8.01% | +7.60% | 12.09% | |||
| OpenRocket’s friction below Mach 0.8 | 60 | +8.19% | +7.74% | 12.18% | 15 | 45 |
| OpenRocket’s pressure below Mach 0.8 | 60 | +8.63% | +8.23% | 12.21% | 23 | 37 |
| OpenRocket’s base below Mach 0.8 | 60 | +6.67% | +6.63% | 11.49% | 45 | 15 |
| OpenRocket’s rest below Mach 0.8 | 0 | +8.01% | +7.60% | 12.09% | 0 | 0 |
| OpenRocket’s whole drag below Mach 0.8 | 60 | +7.45% | +6.77% | 11.68% | 38 | 22 |
On OpenRocket’s base alone, HPR Sim’s mean absolute error falls from 12.09% to 11.49%, more than on OpenRocket’s whole drag below Mach 0.8, and 45 of the 60 flights come nearer their log (report). Its friction and its pressure alone each take HPR Sim farther from the logs. That doesn’t show OpenRocket’s base rule is the truer one: both codes climb above the logs on average, so more drag from any cause moves the mean toward them.
As a worked example anyone can run, take
pods-none,
which stays below Mach 0.8 and burns there. Its band’s part of +0.79% splits into −0.37%
friction, +0.04% pressure, +1.12% base and 0% rest
(the tests,
the_public_flights_split_by_term; from a clone, cargo test -p xtask drag_terms).
The base under power, against a measured flight
This part sets HPR Sim’s base drag below Mach 0.8, coasting and with the motor burning, beside a measured flight (the rows are in the fixture report). It is for anyone weighing the term above against something other than another code. It stops at Mach 0.8 because that is the band the term split covers.
The reference. A 1955 NACA report gives free flights of rocket-propelled models of the Hermes A-3A from Wallops Island, with the sustainer motor burning and then coasting, and the pressure on the base measured during both (Jackson 1955, NACA RM SL55F15, a US government work in the public domain). Its figure 20 gives the base drag coefficient on the model’s largest cross-section, from Mach 0.6 to 1.8, with the motor burning and (from about Mach 0.65) coasting. The report believes the error of these faired curves to be less than ±0.005 (printed p. 10). The curves are read off the figure by pixels to ±0.001 more (the reading script, the readings and the model’s sizes). At Mach 0.7 the report’s own base pressures, in its figure 22, read by eye (a research note), give base drag 0.0042 above figure 20 under power and 0.0057 above it coasting, about the stated error. The figures don’t settle which is right (the readings’ notes).
The model is 8 in across, with a 4.5° cone narrowing to a 4.8 in base. Its motor, a nominal 5 in case, sits forward in the body, and a blast tube carries the jet to a 3.0 in nozzle exit at the base. The jet leaves below the outside air’s pressure, past fixed vanes in it (the model’s sizes).
HPR Sim’s rule and OpenRocket’s. Below Mach 0.8, HPR Sim’s base drag coefficient on the base is (Drag), coasting on the whole base, and behind a boattail it keeps of that, the base’s diameter over the boattail’s fore diameter (the largest, where the boattail starts at it): a conical afterbody’s base drag scales with that ratio cubed on the largest cross-section where the rule on the base’s area scales with its square (Stoney, NASA TR R-100, 1961, p. 11, from tunnel data; ADR-362, which this reference decided). In a flight, with the motor burning, HPR Sim takes the motor case’s area off the base, down to zero. Here the case is wider than the base, so as HPR Sim flies it there is no base drag under power. Given only the nozzle exit’s area, which is what this base holds of the motor, the same rule leaves the ring of base around the exit, the area the report measured on: that tests the coefficient, not the area HPR Sim flies. OpenRocket 24.12 keeps the whole base under power, on the flat-base rule with no relief behind a boattail: times the table’s last column, which is the whole base on HPR Sim’s coefficient. As a worked example at Mach 0.7: on the base. The base is of the largest cross-section, and behind the cone it keeps of the rule, so coasting HPR Sim gives . Under power the ring is of it, so given the nozzle exit HPR Sim gives 0.0242, and with the case off 0. The flight measured 0.0105 coasting and 0.0244 under power (fixture report). Before ADR-362 the base kept the whole rule behind a boattail, times as much coasting.
| Mach | measured base drag coefficient, power off | HPR Sim’s base drag coefficient, power off | measured base drag coefficient, under power | HPR Sim’s base drag coefficient, under power, case off | HPR Sim’s base drag coefficient, under power, nozzle exit off | the whole base’s drag coefficient, under power, on HPR Sim’s coefficient |
|---|---|---|---|---|---|---|
| 0.65 | 0.0127 | 0.0378 | 0.0270 | 0.0000 | 0.0230 | 0.0378 |
| 0.70 | 0.0105 | 0.0397 | 0.0244 | 0.0000 | 0.0242 | 0.0397 |
| 0.75 | 0.0096 | 0.0417 | 0.0221 | 0.0000 | 0.0254 | 0.0417 |
| 0.79 | 0.0086 | 0.0434 | 0.0204 | 0.0000 | 0.0265 | 0.0434 |
(fixture,
written by cargo xtask aero; the same rows are in the fixture report)
What the rows say. Which way each rule errs, past the stated error and the reading, is held by a
test
(the tests,
the_power_off_rule_reads_high_the_flown_power_on_rule_low, with two mutation probes in
ADR-362):
- Under power, HPR Sim’s rule as it flies reads low, by 0.0204 to 0.0270: it leaves no base drag where the flight measured some. Too little drag gives too high an apogee: the optimistic side for a flier aiming at a target altitude, not the side that flatters a flight near a waiver’s ceiling (which error flatters; fixture report).
- Given the nozzle exit instead, the same rule comes within 0.007, from 0.0040 low to 0.0061 high: within the stated error and the reading together, ±0.006, at Mach 0.65 to 0.75. The whole base kept under power reads high by 0.0108 to 0.0230 on HPR Sim’s coefficient; on OpenRocket 24.12’s, the flat-base rule with no relief behind the boattail, by 0.036 to 0.052 (the fixture’s flat-base column less the measured; fixture report).
- Coasting, HPR Sim reads high, by 0.025 to 0.035: its value is 3.0 to 5.1 times the measured. Before ADR-362 it read high by 0.050 to 0.064, 5.0 to 8.4 times: the mean absolute error over the four rows fell from 0.0574 to 0.0303, and no row’s grew. Hoerner’s rule, which also lowers the base for a thicker boundary layer, reads high by 0.012 to 0.016 (fixture report; the rules side by side).
- The jet raised the measured base drag, to 2.1 to 2.4 times its coasting value, as the report says in its own words: “more than twice”. HPR Sim’s rule given the nozzle exit lowers it, to 0.61 of coasting, and the whole base keeps it. Neither moves the way the flight did. Kept on the measured coasting value instead, the whole base would read low, by 0.0118 to 0.0143 (fixture report).
What it leaves out: one vehicle and one motor, whose jet left through a blast tube, past fixed vanes, below the outside air’s pressure. How far the result carries to another motor and base is not measured. The base model was changed on this reference for a boattailed base, power off (M1.14i3, ADR-362), and what that moved is above (the slowest band, by term). Nothing here covers the jet (evidence row G14), and no hobby rocket’s base behind a boattail has been measured (evidence row G41).
Known gaps
These are the largest known differences and missing pieces. Each model page’s In short lists the rest.
- HPR Sim’s own drag in a whole flight. Its heights differ from RocketPy’s by −7.280% to +10.302%, where its drag differs from the examples’ (report). Against the seven real flights compared first, four of the five apogees more than 5% from their logs are consistent with HPR Sim’s drag (real flights, real-flight report).
- Four of the five public flights predicted first miss by more than 5%, and no explanation is claimed for them. The five miss by −29.16% to +4.14%, four of them low (predicted before compared, real-flight report).
- Drag faster than sound reads high against NASA’s wind tunnel, above all with fins. With the fins on, it’s +39.4% at Mach 1.5 to +154.0% at 4.63. The fins take a blunt leading edge’s formula. 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. Boattails of 16° read +26.4% to +54.2% from Mach 1.0 to 1.28. The Arcas Robin’s 15° boattail puts its forebody, fins off, +13.5% to +24.1% high from Mach 1.5. From Mach 1.0 to 1.2 it’s +20.3% to +50.8%. 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. Part of it is HPR Sim’s body, which reads 6% to 10% low faster than sound against MIL-HDBK-762’s worked example as well (Aerodynamics).
- Drag and pitch damping read low on the Basic Finner faster than sound. Against its free flights from Mach 1.83 to 3.15, with its wedge fins’ drag modeled from published figures, HPR Sim’s drag reads 16.5% to 21.3% low and its pitch damping 24.7% to 39.6% low; at Mach 1.077 the damping reads 25.4% high, the side that flatters. The drag’s cause is not found (#1513). A square fin’s trailing edge may also take too little drag faster than sound (#1514; Aerodynamics).
- Roll: the forcing high near Mach 1.5, the damping high, nothing committed 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. There, linear theory’s load climbs toward Mach 1 faster than the fins’ does. The roll damping reads 11.7% to 27.5% high against the Basic Finner’s in NOL’s wind tunnel, Mach 1.53 to 2.76, and against DREV’s free-flight range 8.8% high on average in the core band and 5.0% in the extended band. No committed comparison checks either below Mach 1.5, where uncommitted measured sets put the damping 24.5% to 200% high (Aerodynamics).
- A flared rocket’s supersonic normal force rests on one measured flare. A conical flare now flies the shock-expansion method (the change). On a test rocket with a 10° flare, its center of pressure moves 0.089 to 0.238 calibers forward of the old model’s (evidence row G28). The move grows 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. It isn’t that rocket (Aerodynamics). No other flare angle has been checked. 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) takes the older generalized method instead. No measurement checks that either. It leaves a step where the corner’s pressure crosses its tangent cone’s (Aerodynamics). On a body with a short shoulder that crossing isn’t near-flat at all (0.7° to 4.6°). There the step reaches +4.3% of the body’s normal force and 0.19 calibers. 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, four shapes keep slender-body theory for the whole body. Two are a step in a body’s radius (#87) and a flare behind a boattail too long for its wake (#120). The others are a pointed tip steeper than 30° (#121) and a vertical tip steeper than its cap’s handover. The sizes are measured at Mach 3 and 4° on two test bodies. In normal force they’re −8.65%, −27.5%, −7.7% and −7.0%, with the center of pressure 1.03, 0.29, 0.81 and 0.64 calibers 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’re first in supersonic accuracy, and in the extended band 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 Sim’s slope runs up to +27.1% high. Its center of pressure is up to 2.36 calibers off. From Mach 1.5 up its slope holds to within 9.4% (fixture, Aerodynamics). Its center of pressure holds to 0.53 calibers, missing the half-caliber target on the long model (Aerodynamics: body lift). On another body, the Basic Finner, free flights from Mach 1.08 to 3.15 show HPR Sim’s slope 9.3% to 24.9% low and its center of pressure 0.03 to 0.34 calibers forward (Aerodynamics).
- Tube fins’ center of pressure is unmeasured, and OpenRocket’s differs. HPR Sim’s is 0.42 to 3.0 calibers forward of OpenRocket 24.12’s on 14 probe designs up to Mach 0.5. On OpenRocket’s Tube fin rocket it’s 1.07, and HPR Sim gives the margin as 0.79 calibers to OpenRocket’s 1.87. Neither code has been checked against a measured tube-fin rocket. HPR Sim leaves out the body’s interference, which slender-body theory predicts (#234). 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 two of seven cases, with the fins and finish guessed, as the curves don’t record them. Two boattailed cases, Juno III and Calisto’s getting-started fins, are −10.3% and −11.5%. Cavour power-on is −18.3%, cause open. Valetudo’s −47.0% and −50.4% are against a table 1.44 times the OpenRocket export’s (Aerodynamics).
- Six fins. The normal-force slope of Barrowman’s six-fin Recruiter is +2.87% above his printed value, mostly from HPR Sim’s different six-fin rule (Aerodynamics).
- Tumbling is −10 to +19% off its source’s own drop tests. It’s used far outside the fit behind it. That fit comes from small models falling at 5.0 to 6.6 m/s (16 to 22 ft/s). If Valetudo came down tumbling, with nothing deployed, HPR Sim would bring it down at 36.4 m/s (119 ft/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 Sim 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 or low: a separated body falls with no drag until its device opens (Recovery).
- No added mass under a canopy. It’s the likely cause of the 2.86% drift difference above (Recovery). It also causes 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. There HPR Sim’s body lift, which RocketPy leaves out, is the largest reason its drift differs. How much body lift a rocket body makes is itself uncertain. HPR Sim 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 Sim’s rail release and fins, that puts Juno III’s apogee 248.3 m (815 ft) from the pad. HPR Sim’s own is 245.3 m (805 ft, case file). The same runs set Galejs’s constant , which HPR Sim used before, across its source’s range. It gives 240.2 m (788 ft) at 1.0, 231.1 m (758 ft) at 1.1 and 194.1 m (637 ft) at 1.5. With no body lift at all, the drift would be 328.0 m (1,076 ft) (the decision). Only real flights can say which is right. The real flights so far compare heights, not drift.
- Airfoil fins. HPR Sim’s fins use the flat-plate lift slope. It can’t 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 (decision).
- Turbulence is an aircraft model, unvalidated for rockets, and no flight uses it yet (Turbulence) (evidence row G12).
- Wall and fin mass may follow different conventions from OpenRocket’s, which its documentation doesn’t state. Six are measured so far (Mass properties). OpenRocket’s nose cone walls are measured across each station, HPR Sim’s square to the surface: the same on a cone, HPR Sim’s up to 0.48% heavier on three blunt noses (Shapes).
HPR Sim
HPR Sim flies a hobby or high-power rocket’s design file from the rail to the ground and says how far to trust the numbers.
This is the first page of the simulator’s guide, for a flier, a team or a developer deciding whether HPR Sim fits their work. It says what HPR Sim is, who it’s for, how far its numbers have been from real flights, and how to install it. A tour of HPR Sim comes next and shows it working.
What it is
It’s a flight simulator for rockets on commercial solid motors. It reads an OpenRocket .ork
design file as it is and flies it in six degrees of freedom.
Those are the rocket’s position along three axes and its rotation about three. The mass and the balance
point move as the motor burns. It prints the apogee, the speeds, the stability margin and the
events from liftoff to landing. It also prints the known gaps in its models that bear on that
flight, each with the side it pushes the numbers to.
It comes three ways, all from one code base, and none needs a network to fly a rocket:
- The command line,
hpr, flies a file and scatters its inputs to show the spread (Monte Carlo dispersion). It also looks up and converts motors, reads an altimeter’s log and fetches a launch day’s weather (The command line). - The Python package flies the same flights from a script or a notebook (Python).
- The Rust library puts the simulator inside a program of your own (Getting started).
Every model cites a published source, and tests pin each one. The results against RocketPy, OpenRocket and real flights are committed to the repository (Accuracy). The first release is out, but HPR Sim isn’t ready to rely on yet. Start here lists what works today and what doesn’t yet.
Who it is for
I built HPR Sim for three kinds of user:
- A flier with a design file who wants a second opinion on a flight before it flies, with the known gaps stated rather than hidden.
- A team that needs a flight’s spread, not one number.
hpr mcflies the file many times with its inputs scattered. - A developer who wants a simulator inside a program, a test or a notebook. HPR Sim runs offline, and it gives the same numbers from the same inputs and seed on one machine.
It isn’t for a rocket on a hybrid, liquid or research motor yet, because it doesn’t fly those. It doesn’t draw a design either: it reads one made in OpenRocket. A design editor comes with the app.
Install it
- For the command line, download the archive for your system from
the releases page and put
hpron your path. With Rust installed, you can runcargo install fusionspace-hpr-cli --lockedinstead. - For Python, run
pip install fusionspace-hpr, then import it withfrom fusionspace import hpr. - For the library, run
cargo add fusionspace-hprin your own Rust project.
Install a release lists the systems each file serves, and what to do on macOS when it can’t check the program.
Next
- A tour of HPR Sim flies the guide rocket and reads what it prints. Then it scatters the inputs, flies the rocket again from Python, and shows how HPR Sim did on a public flight.
- Compared with other simulators says what HPR Sim, OpenRocket, RocketPy and RASAero II each do, and what’s been measured side by side. It also says where HPR Sim has less.
- The task pages are Fly your .ork, Pick a motor, Check stability for a certification flight, Monte Carlo dispersion and Reading a flight log.
- Before you rely on a number, read Trusting a simulation.
The trust note’s flights come from two places. The public flights are among those RocketPy’s documentation flies against their teams’ logs, but for one rocket’s two flights, which come from a public repository of designs and logs. University rocketry teams, rocketry courses and hobbyists published the logged flights. Those and RocketPy’s fly in ERA5 weather (the other rocket’s two fly in standard air): 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 logged flights’ report gives the full attribution and the ERA5 citations.
A tour of HPR Sim
Fly a design file from HPR Sim’s command line and Python, read the output, scatter the inputs, and see how it did on real flights.
This tour is for a flier who has HPR Sim installed, or is deciding whether to install it. They want to see in a few minutes what HPR Sim does with a design file. The tour shows what it prints, how to read it, how to fly it from Python, and how far it has been from real flights. It flies the small rocket the how-to guides use, then turns to a public flight that left a log. Each step links to the page that covers it in full.
HPR Sim says what the simulator is and how to install it.
Fly a design file
hpr sim flies a design file from the launch rail to the ground and prints what happened.
The tour’s rocket is
validation/fixtures/ork/guides/level-1.ork,
a small rocket saved by OpenRocket with two motors to choose from.
Run the commands from a copy of the repository
(git clone https://github.com/nrdptel/fusionspace-eridanus). Or download the file from its page,
and put its path in place of the one shown. Its motors are in the catalog built into HPR Sim, so
it flies with no network. The picture shows the run as a terminal shows it, with four parts
marked:
- A, the configuration. A design file can hold several motor configurations. With none
named,
hpr simflies the file’s default and says how to fly the others with--config. - B, the summary. It gives the static margin in calibers, the balance point (CG) and the center of pressure, and the apogee. Then come the speed off the rail, the motor’s delay against the time to apogee, and the descent rate. The line under the configuration says what the summary’s numbers are: a simulated flight, not a measurement.
- C, the warnings. Each names a known gap in HPR Sim’s models that bears on this flight. It also names the issue that tracks the gap, and which way the gap pushes the numbers. Here the drag may read high. If it does, the apogee reads low, the side that flatters a field’s ceiling (Trusting a simulation).
- D, the events. Liftoff, rail exit, burnout, apogee, the charge, the parachute’s deployment and the ground hit, each with its time, height and speed.
The lines between B and C say what was flown: the motor, the recovery, and the launch. With no site given, as here, that’s a default: sea level on the equator, a vertical rail and calm air.
The same run as text, to copy or search:
$ hpr sim validation/fixtures/ork/guides/level-1.ork
Level 1 guide rocket (level-1.ork)
configuration 1 of 2: [H170M-10]
help: --config flies the others, by number or name: 2 [I175WS-9]
a simulated flight, not a measurement
static margin 1.70 calibers off the rail; least 1.70 calibers, at 0.12 s, before apogee
CG and CP 0.811 m (31.9 in) and 0.923 m (36.3 in) aft of the nose tip, off the rail
apogee 1065.1 m (3494 ft) above the site at 11.62 s
rail exit speed 26.3 m/s (86 ft/s)
delay apogee 9.48 s after burnout, with the charges held; the motor's set delay: 10 s; its charge fires 0.52 s after apogee; the delay may fire 2.0 s short or long (NFPA 1125): climbing at 14.7 m/s (48 ft/s) to 2.52 s after apogee (no speed: falling with nothing open, a fall HPR Sim doesn't predict)
descent 4.4 m/s (15 ft/s) at landing under `Parachute`
motor: 1 × H170M (from the bundled catalog, as of 2026-10-28) in `Motor mount tube`, lit at launch
recovery: `Parachute` at the ejection charge, 0.520 m² of drag area, opened at 12.14 s
launched at 0.00000° N, 0.00000° E, 0 m (0 ft) above sea level, from 1.5 m (4.9 ft) of vertical rail above its aft end, in calm air
note: the file's 1 recovery device flies as OpenRocket flies it. Each opens fully at its event, with the file's drag coefficient or OpenRocket's own. Once one opens, the rocket descends as a point under the open devices' drag alone
warning: drag: issue #67: a cone-like nose's or shoulder's pressure drag reads high from Mach 0.8 (about twice a measured cone's at Mach 0.85, still +15% at 1.5). So the apogee, top speed and drift read low, and the flutter margin and largest dynamic pressure look better than they are. This flight reaches Mach 0.84 at 1.7 s
warning: drag: issue #68: base drag reads high from Mach 0.8 to 1.2 (0.225 against a measured 0.156 at Mach 0.9). So the apogee, top speed and drift read low, and the flutter margin and largest dynamic pressure look better than they are. This flight reaches Mach 0.84 at 1.7 s
warning: drag: issue #18: skin friction is taken as fully turbulent; on a smooth surface a laminar run near the nose lowers it, by 3.6% on RocketPy's Calisto at Mach 0.3. If this surface is that smooth, the apogee, top speed and drift read low, and the flutter margin and largest dynamic pressure look better than they are
warning: stability: issue #172: the static margin read up to 0.1108 calibers above OpenRocket's on four private designs, cause unknown; this flight's may read high by as much
warning: stability: issue #1290: on one of two wind-tunnel models, the center of pressure sat 0.11 to 0.92 calibers aft of the tunnel's at Mach 0.6 and 0.8, as the report's curve reads; fitted over −3° to 4°, about 0.08 at 0.8. So from Mach 0.6 the flight margin may read high. This flight reaches Mach 0.84 at 1.7 s
warning: stability: issue #1198: the center of pressure sat 0.67 to 1.35 calibers aft of a wind tunnel's on two models at Mach 0.9, so past Mach 0.8 the flight margin may read high. This flight reaches Mach 0.84 at 1.7 s
help: issues: https://github.com/nrdptel/fusionspace-eridanus/issues/<number>
event time height speed
liftoff 0.00 s 0.4 m (1 ft) 0.0 m/s (0 ft/s)
rail exit 0.12 s 1.9 m (6 ft) 26.3 m/s (86 ft/s)
burnout 2.14 s 406.4 m (1333 ft) 240.4 m/s (789 ft/s)
apogee 11.62 s 1065.1 m (3494 ft) 0.1 m/s (0 ft/s)
charge 12.14 s 1063.7 m (3490 ft) 5.1 m/s (17 ft/s)
deployment 12.14 s 1063.7 m (3490 ft) 5.1 m/s (17 ft/s), airspeed 5.1 m/s (17 ft/s)
ground hit 245.78 s 0.0 m (0 ft) 4.4 m/s (15 ft/s)
(heights are the center of gravity's above the site; speeds are over the ground, and a deployment's
airspeed through the air)
top speed 285.6 m/s (937 ft/s) at 1.73 s
top Mach number 0.842
landing 0.7 m (2 ft) from the pad at 245.78 s, at 4.4 m/s (15 ft/s)
How far to trust it. Simulated from the design file, not measured. Against 60 logged flights of
fliers' own designs, the simulated apogee averaged 8.0% above the logged one. HPR Sim flew each in
its day's air from ERA5, a weather reanalysis, and each logged apogee is the height climbed in it.
The simulated apogee was within 10% on 31 and read low on 15, by at most 20%. This flight was flown
in the standard atmosphere. On a day warmer than it at the site, the rocket can climb higher than
this apogee; --weather flies the day's air. Plan a waiver or a field's ceiling with room above this
apogee; the altimeter's reading is the one to log, and the RSO decides.
More: https://hpr.fusionspace.co/accuracy.html
Fly your .ork covers choosing the configuration, the site, the rail and the wind. It also covers saving the flight to plot or to open in a spreadsheet.
Scatter its inputs
hpr mc flies the same file many times (Monte Carlo), each flight’s inputs drawn afresh, and prints how far
the apogee and the landing spread. A design file’s masses, its drag and its motor are each a
little off from the real rocket’s. The command takes each scatter as one standard deviation, as a
share of the value. Here they’re --mass-sd 0.02 for the mass, --drag-sd 0.05 for the drag
and --impulse-sd 0.03 for the motor’s impulse. --seed 2026 makes the draws the same on every
run.
-
A, the apogee’s spread. The nominal flight, then the runs’ mean, their standard deviation, and their percentiles. Most runs fell between the
5%and95%columns. -
B, the landing ellipses. Each is drawn to hold its share of the landings if they scattered as a normal spread. The
flights insidecolumn counts how many did. The next-flight ellipse is the one to set against a field’s edges (landing ellipse).In calm air, as here, the landings bunch within about a meter of the pad, not as a normal spread. So the counts and the shares differ. A wind (
--wind) spreads them out. -
C, how far to trust it. The spread comes from the scatter the command was told to apply, not from errors in the models, which move every run together. This note gives the miss on real flights, which the spread leaves out.
The same run as text:
$ hpr mc validation/fixtures/ork/guides/level-1.ork --runs 200 --seed 2026 --mass-sd 0.02 --drag-sd 0.05 --impulse-sd 0.03
Level 1 guide rocket (level-1.ork)
configuration 1 of 2: [H170M-10]
help: --config flies the others, by number or name: 2 [I175WS-9]
200 simulated flights, seed 2026: 0 failed
nominal mean std dev 5% median 95%
apogee (m AGL) 1065.1 1072.4 41.5 1006.2 1072.8 1137.3
apogee (ft AGL) 3494 3519 136 3301 3520 3731
landing distance (m) 0.7 0.7 0.0 0.7 0.7 0.8
landing distance (ft) 2 2 0 2 2 3
opening shock (m/s²) 11.6 15.2 8.7 9.8 9.8 34.7
opening shock (g) 1.2 1.5 0.9 1.0 1.0 3.5
opening airspeed (m/s) 5.1 4.7 2.4 0.8 4.6 8.8
opening airspeed (ft/s) 17 15 8 3 15 29
200 of 200 flights landed, centered 0.7 m (2 ft) west and 0.0 m (0 ft) north of the pad
landing ellipse semi-major semi-minor heading flights inside
50% 0.0 m (0 ft) 0.0 m (0 ft) 090° T 74.5%
95% 0.1 m (0 ft) 0.0 m (0 ft) 090° T 98.0%
95%, the next flight 0.1 m (0 ft) 0.0 m (0 ft) 090° T 98.5%
motor: 1 × H170M (from the bundled catalog, as of 2026-10-28) in `Motor mount tube`, lit at launch
launched at 0.00000° N, 0.00000° E, 0 m (0 ft) above sea level, from 1.5 m (4.9 ft) of vertical rail above its aft end, in calm air
scattered, one standard deviation each: --mass-sd 0.02, --drag-sd 0.05, --impulse-sd 0.03
note: the file's 1 recovery device flies as OpenRocket flies it. Each opens fully at its event, with the file's drag coefficient or OpenRocket's own. Once one opens, the rocket descends as a point under the open devices' drag alone
warning: drag, the nominal flight: issue #67: a cone-like nose's or shoulder's pressure drag reads high from Mach 0.8 (about twice a measured cone's at Mach 0.85, still +15% at 1.5). So the apogee, top speed and drift read low, and the flutter margin and largest dynamic pressure look better than they are. This flight reaches Mach 0.84 at 1.7 s
warning: drag, the nominal flight: issue #68: base drag reads high from Mach 0.8 to 1.2 (0.225 against a measured 0.156 at Mach 0.9). So the apogee, top speed and drift read low, and the flutter margin and largest dynamic pressure look better than they are. This flight reaches Mach 0.84 at 1.7 s
warning: drag, the nominal flight: issue #18: skin friction is taken as fully turbulent; on a smooth surface a laminar run near the nose lowers it, by 3.6% on RocketPy's Calisto at Mach 0.3. If this surface is that smooth, the apogee, top speed and drift read low, and the flutter margin and largest dynamic pressure look better than they are
warning: stability, the nominal flight: issue #172: the static margin read up to 0.1108 calibers above OpenRocket's on four private designs, cause unknown; this flight's may read high by as much
warning: stability, the nominal flight: issue #1290: on one of two wind-tunnel models, the center of pressure sat 0.11 to 0.92 calibers aft of the tunnel's at Mach 0.6 and 0.8, as the report's curve reads; fitted over −3° to 4°, about 0.08 at 0.8. So from Mach 0.6 the flight margin may read high. This flight reaches Mach 0.84 at 1.7 s
warning: stability, the nominal flight: issue #1198: the center of pressure sat 0.67 to 1.35 calibers aft of a wind tunnel's on two models at Mach 0.9, so past Mach 0.8 the flight margin may read high. This flight reaches Mach 0.84 at 1.7 s
help: issues: https://github.com/nrdptel/fusionspace-eridanus/issues/<number>
How far to trust it. Simulated from the design file, not measured; the spread above comes from the
inputs' scatter alone, not from the model's error. Against 60 logged flights of fliers' own designs,
the simulated apogee averaged 8.0% above the logged one. HPR Sim flew each in its day's air from
ERA5, a weather reanalysis, and each logged apogee is the height climbed in it. The simulated apogee
was within 10% on 31 and read low on 15, by at most 20%. These flights were flown in the standard
atmosphere. On a day warmer than it at the site, the rocket can climb higher than this apogee;
--weather flies the day's air. Plan a waiver or a field's ceiling with room above this apogee; the
altimeter's reading is the one to log, and the RSO decides.
More: https://hpr.fusionspace.co/accuracy.html
Monte Carlo dispersion covers the other scatters, the wind among them, and what each column means.
The same flight from Python
The fusionspace-hpr package flies the same file from Python and hands the flight back as
numbers and NumPy arrays. Use them in a notebook, a plot or a script of
your own. pip install fusionspace-hpr installs it (Python covers the
rest).
This flies the guide rocket with its parachute, from the launch hpr sim used above. That’s sea
level on the equator, a vertical rail of the same length, and calm air. Save it as tour.py and
run python tour.py from the root of a copy of the repository. Or put the downloaded file’s path
in place of the one shown:
from fusionspace import hpr
rocket = hpr.Rocket.from_file("validation/fixtures/ork/guides/level-1.ork", recovery=True)
site = hpr.Environment(0.0, 0.0, 0.0)
flight = hpr.Flight(rocket, site, 1.5)
print(rocket.name)
print(f"apogee {flight.apogee_m:.1f} m at {flight.apogee_time_s:.2f} s")
print(f"rail exit speed {flight.rail_exit_speed_m_s:.1f} m/s")
print(f"top speed {flight.max_speed_m_s:.1f} m/s, Mach {flight.max_mach:.3f}")
landing = flight.landing
print(f"landing {landing['distance_m']:.1f} m from the pad at {landing['time_s']:.2f} s")
for warning in flight.issue_warnings:
print(f"warning: issue #{warning['issue']}, {warning['kind']}")
time = flight["time_s"]
fast = time[flight["mach"] > 0.8]
print(f"above Mach 0.8 from {fast[0]:.2f} s to {fast[-1]:.2f} s, in the recording")
Level 1 guide rocket
apogee 1065.1 m at 11.62 s
rail exit speed 26.3 m/s
top speed 285.6 m/s, Mach 0.842
landing 0.7 m from the pad at 245.78 s
warning: issue #67, drag
warning: issue #68, drag
warning: issue #18, drag
warning: issue #172, stability
warning: issue #1290, stability
warning: issue #1198, stability
above Mach 0.8 from 1.45 s to 1.89 s, in the recording
Rocket.from_filereads the design and its motor configuration, the file’s default ashpr simflies it with none named.recovery=Trueflies the file’s parachute; without it the rocket falls unslowed. This file reads cleanly, but many.orkconfigurations are refused for now (A design from a file).Environmenttakes the site’s latitude and longitude in degrees and its elevation in meters.Flighttakes the rocket, the site and the rail’s length in meters, vertical unless told otherwise. It flies as soon as it’s made.- The numbers are the ones
hpr simprinted above, from the same code. A test holds the apogee, the speeds, the landing and the warnings to that run. The warnings are its warnings as data: each a GitHub issue number, a kind, a message and a link. flight["mach"]and the rest are the recording: the flight’s values at each recorded time, one NumPy array per column. The last lines find when the rocket flew faster than the Mach number in the code. It’s the Mach number from which the warnings on the nose’s and the base’s drag say the drag reads high.
Python covers building a rocket part by part, Monte Carlo runs, and the recording’s columns.
A real flight
The guide rocket has no log, so its numbers can’t be checked against the sky. The public flights in the real-flights report can. Most are university teams’ rockets. HPR Sim flies each of those in a reanalysis of the weather, its own day’s for all but one, and sets it against the team’s altimeter.
The tour takes the middle one by a rule, not by choice. Of the 7 flights compared along their whole climb, the one whose miss, without its sign, is the median is Genesis, EuRoC 2023, the report’s case genesis. EuRoC is the European Rocketry Challenge. If a rerun of the report moves the middle, the tour moves to the new one.
Genesis’s altimeter read 2,916.7 m (9,569 ft) at the top, 23.3 s after the rocket passed 30 m (98 ft) on the way up. An altimeter riding HPR Sim’s flight of its design would have read 2,746.0 m (9,009 ft), at 22.4 s. That’s a miss of −5.85%, so HPR Sim read low. For a waiver or a field’s ceiling, a low reading is the side that flatters: the rocket climbs past the height that was planned for.
The report puts the miss down to HPR Sim’s drag: flown on the drag the team’s example gives, the apogee missed by −0.08% (report). The example records no fin edges or finish, so the design’s are placeholders.
One flight says little alone, so here it is beside the rest. On the 12 public flights HPR Sim’s apogee missed by −29.16% to +10.40% one by one. It missed by 8.88% on average without signs, and by −4.64% with them. The average without signs is outside the project’s own 5% target (Accuracy).
On these flights the misses go both ways and lean low, 7 of the 12 that way. On 60 logged flights of fliers’ own designs they lean high, averaging +8.01% above the logged ones: no side can be assumed. Trusting a simulation sets the two beside each other and says which miss to plan for.
Sources. The public flights are among those RocketPy’s documentation flies against their teams’ logs, but for one rocket’s two flights, which come from a public repository of designs and logs. The reanalysis 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 logged flights’ report gives the full attribution and the ERA5 citations.
Where next
- For your own rocket, start with Fly your .ork. Then read Check stability for a certification flight and Pick a motor.
- Every command and flag is in The command line.
- To work from Python or Rust, read Python and Getting started.
- Before you rely on a number, read Trusting a simulation and Accuracy.
- To see HPR Sim beside the other simulators, read Compared with other simulators.
Compared with other simulators
What HPR Sim can do beside OpenRocket, RocketPy and RASAero II, what has been measured side by side, and where HPR Sim has less.
This page is for a flier or a team choosing a simulator. It’s also for one who uses another simulator and wants to know what HPR Sim would add and what it would take away. The three are the free simulators that hobby and high-power fliers use most. Each one’s answers are read from its own documentation. It’s the last page of the simulator’s guide, after HPR Sim and A tour of HPR Sim.
HPR Sim gives ranges, not verdicts. The safety code and the range safety officer (the RSO) decide whether a rocket flies.
What each does
A yes links the page that shows it. A partly or a no links the page that shows what the tool does instead, and says it in words below the table. For HPR Sim, a yes links the page of this site that covers it, and a no links the roadmap entry that brings it.
A yes says nothing of accuracy, least of all past the speed of sound. HPR Sim’s own drag there is rough and can be off either way (Drag through the speed of sound). OpenRocket’s documentation aims only at low supersonic speeds. And no tool’s accuracy there has been set against a logged flight here.
The rows also leave out much that a tool may have, such as plots, parts catalogs and recovery design. Check a tool’s own pages before you switch.
| Capability | Each tool |
|---|---|
Opens an OpenRocket .ork design file | HPR Sim yes; OpenRocket yes; RocketPy no; RASAero II no |
Writes a design to an .ork file | HPR Sim yes; OpenRocket yes; RocketPy no; RASAero II no |
| Draws and edits a design in a window | HPR Sim no; OpenRocket yes; RocketPy no; RASAero II yes |
| Flies in six degrees of freedom | HPR Sim yes; OpenRocket yes; RocketPy yes; RASAero II no |
| Flies a rocket of more than one stage | HPR Sim yes; OpenRocket yes; RocketPy partly; RASAero II yes |
| Works out drag and stability past the speed of sound | HPR Sim yes; OpenRocket yes; RocketPy partly; RASAero II yes |
| Flies a design many times with its inputs scattered, for a landing spread | HPR Sim yes; OpenRocket no; RocketPy yes; RASAero II no |
| Fetches a launch day’s forecast, reanalysis or balloon sounding into the flight | HPR Sim yes; OpenRocket partly; RocketPy yes; RASAero II no |
| Flies a design file from a command line | HPR Sim yes; OpenRocket no; RocketPy no; RASAero II no |
| Flies a design from a Python script | HPR Sim yes; OpenRocket no; RocketPy yes; RASAero II no |
| Estimates the speed at which the fins flutter | HPR Sim partly; OpenRocket no; RocketPy yes; RASAero II no |
| Reads an altimeter’s flight log | HPR Sim yes; OpenRocket no; RocketPy yes; RASAero II no |
| Flies airbrakes driven by a control law | HPR Sim no; OpenRocket no; RocketPy yes; RASAero II no |
| Flies a hybrid or liquid motor with its tanks | HPR Sim no; OpenRocket no; RocketPy yes; RASAero II no |
| Warns when a flight leaves its models’ assumptions | HPR Sim yes; OpenRocket yes; RocketPy no; RASAero II no |
| Names the known gaps in its models that bear on each flight, and which way each pushes the numbers where that is known | HPR Sim yes; OpenRocket no; RocketPy no; RASAero II no |
What none of the others has. Of the capabilities above, as far as each tool’s documentation shows, HPR Sim alone flies a design file from a command line and names the known gaps in its models that bear on each flight, and which way each pushes the numbers where that is known: each of the others’ cells in those rows says no.
Where HPR Sim has less. Each row where another tool says yes and HPR Sim doesn’t, with the step of the roadmap that brings it:
- Draws and edits a design in a window: OpenRocket and RASAero II do. HPR Sim doesn’t yet; Desktop app shell on the roadmap brings it.
- Estimates the speed at which the fins flutter: RocketPy does. HPR Sim does in part; Submission packs on the roadmap brings it.
- Flies airbrakes driven by a control law: RocketPy does. HPR Sim doesn’t yet; Airbrakes on the roadmap brings it.
- Flies a hybrid or liquid motor with its tanks: RocketPy does. HPR Sim doesn’t yet; Certified hybrids on the roadmap brings it.
Each cell’s note. Every partly and no says what the page its cell links to shows instead; a yes may carry a limit its documentation states.
- Opens an OpenRocket
.orkdesign file:- RocketPy (no): it has no
.orkreader; a design is typed in as Python. - RASAero II (no): it opens its own files and imports RockSim’s; its manual names no OpenRocket format.
- RocketPy (no): it has no
- Writes a design to an
.orkfile:- RocketPy (no): nothing in its guide or reference writes a design file for another program.
- RASAero II (no): it saves its own format only.
- Draws and edits a design in a window:
- HPR Sim (no): no window yet; it flies a design drawn in OpenRocket.
- RocketPy (no): it is a Python library, with no window.
- Flies in six degrees of freedom:
- RASAero II (no): it flies two degrees of freedom in calm air and three with weathercocking when a wind is entered.
- Flies a rocket of more than one stage:
- RocketPy (partly): it has no stage object or separation event; a flight can start where another ended, with a rocket of its own for each stage.
- Works out drag and stability past the speed of sound:
- OpenRocket (yes): its technical documentation aims at reasonable estimates at transonic and low supersonic speeds.
- RocketPy (partly): its drag comes from curves the user supplies, and its center of pressure varies with Mach, but its reference names no method past the speed of sound.
- RASAero II (yes): its manual gives drag, normal force and center of pressure from Mach 0.01 to Mach 25.
- Flies a design many times with its inputs scattered, for a landing spread:
- OpenRocket (no): its newest release’s notes add none, its features page lists it as planned, and the landing-spread page in its guide is on the development branch only.
- RASAero II (no): neither its contents nor its flight chapter has a spread or a Monte Carlo.
- Fetches a launch day’s forecast, reanalysis or balloon sounding into the flight:
- OpenRocket (partly): its newest release adds wind by height, typed in or read from a file, but fetches nothing.
- RASAero II (no): the launch site takes a temperature, a pressure and one wind speed, on the standard atmosphere.
- Flies a design file from a command line:
- OpenRocket (no): its command-line arguments set options for the window; none flies a design.
- RocketPy (no): it is a Python library; the terminal only installs it.
- RASAero II (no): it runs from its window; its manual describes no command.
- Flies a design from a Python script:
- OpenRocket (no): its documentation covers a Java interface only; the separate orhelper package isn’t in it.
- RASAero II (no): its manual describes no scripting.
- Estimates the speed at which the fins flutter:
- HPR Sim (partly): in the Rust library; the command line and Python don’t print it yet, which the submission packs bring.
- OpenRocket (no): its features page lists fin flutter as planned.
- RocketPy (yes): an estimate from the same NACA criterion HPR Sim uses, which its documentation calls only an estimate.
- RASAero II (no): its manual never mentions flutter.
- Reads an altimeter’s flight log:
- OpenRocket (no): its features page lists importing altimeter data as planned.
- RocketPy (yes): its examples read a log saved as CSV and set it beside a flight.
- RASAero II (no): it suggests writing the altimeter’s readings into the design’s comments, to compare by hand.
- Flies airbrakes driven by a control law:
- HPR Sim (no): no airbrakes yet.
- OpenRocket (no): its example extensions control roll, not drag; airbrakes would need a Java extension of one’s own.
- RASAero II (no): its manual describes no airbrakes or control.
- Flies a hybrid or liquid motor with its tanks:
- HPR Sim (no): commercial solid motors only until its first full release.
- OpenRocket (no): a motor is a thrust-curve file; its features page lists hybrids as planned.
- RocketPy (yes): its tanks drain as the user prescribes; nothing predicts the flow.
- RASAero II (no): a motor is a thrust-curve file or one from its own list.
- Warns when a flight leaves its models’ assumptions:
- RocketPy (no): its flight warning says the rocket is unstable at motor ignition, which is about the rocket, not its models.
- RASAero II (no): its warnings, of a marginal and of an unstable rocket, are about the rocket, not its models.
- Names the known gaps in its models that bear on each flight, and which way each pushes the numbers where that is known:
- OpenRocket (no): its warnings, as its technical documentation and its newest release’s notes describe them, name a broken assumption and leave it to the user to judge whether the results still hold; none says which way they err.
- RocketPy (no): its warnings say nothing of its models’ errors.
- RASAero II (no): its tips give general settings for a conservative altitude, not a flight’s own gaps.
The pages read.
- HPR Sim: each cell links the page of this site that shows it, or the step of the roadmap that brings it.
- OpenRocket 24.12, released July 27, 2025, read on October 12, 2026. Its online guide is built from its development branch and describes features no release has yet, so what the release holds was read from its release notes. Its technical documentation is the edition its site still links; the page numbers in the titles are the printed ones, and the links open the file at them.
- OpenRocket 24.12’s release notes
- OpenRocket’s guide: Features
- OpenRocket’s guide: Features, planned future features
- OpenRocket’s guide: Getting Started
- OpenRocket’s guide: Getting Started, the user interface
- OpenRocket’s guide: Advanced Rocket Design, staging
- OpenRocket’s guide: Command Line Arguments
- OpenRocket’s guide: Using OpenRocket Core in External Applications
- OpenRocket’s guide: Simulation Extensions
- OpenRocket’s guide: Thrust Curves
- OpenRocket’s technical documentation, supersonic drag (page 48)
- OpenRocket’s technical documentation, warnings (page 78)
- RocketPy 1.13.0, released July 22, 2026, read on October 12, 2026.
- RocketPy’s documentation: home
- RocketPy’s guide: Flight Class Usage, initial conditions
- RocketPy’s reference: the Rocket class
- RocketPy’s guide: Monte Carlo class usage
- RocketPy’s guide: Forecasts
- RocketPy’s guide: Installation
- RocketPy’s guide: First Simulation
- RocketPy’s reference: fin flutter analysis
- RocketPy’s guide: Flight Comparator
- RocketPy’s guide: Air Brakes
- RocketPy’s guide: Tanks Usage
- RocketPy’s reference: Exceptions and Warnings
- RASAero II 1.0.2.0, released May 22, 2019, read on October 12, 2026. Its manual is for the same release; the page numbers below are the manual’s.
- RASAero II’s download page
- RASAero II’s manual, introduction (page 4)
- RASAero II’s manual, contents (page 2)
- RASAero II’s manual, files (page 8)
- RASAero II’s manual, stages (page 49)
- RASAero II’s manual, launch site (page 78)
- RASAero II’s manual, altimeter data (page 82)
- RASAero II’s manual, motors (page 93)
- RASAero II’s manual, warnings and tips (page 114)
Measured side by side
The scoreboard holds every comparison the project has measured, axis by axis, and a check that keeps HPR Sim’s numbers from getting worse. Of the table’s 16 capabilities, HPR Sim has 12 in full, OpenRocket 7 and RocketPy 8. I chose the rows, so the count leans toward what HPR Sim was built to do: read the rows, not the count.
On 60 logged flights of fliers’ own designs, flown from the same files, HPR Sim’s apogee missed by 12.09% on average without signs. OpenRocket’s missed by 11.26% on average without signs. With their signs, HPR Sim’s averaged +8.01% above the logged apogees and OpenRocket’s +6.72% above. OpenRocket is ahead on both: this is HPR Sim’s largest measured gap (report).
The flights are a private collection whose license allows only aggregates, so they can’t be rerun
from this repository. HPR Sim flew 68 of its 83 flights whose design is an OpenRocket file. The
comparison holds the flights both tools flew, less those the report leaves out with its reasons.
So a design HPR Sim can’t fly yet is in neither number. RocketPy hasn’t flown them, since it can’t
open their .ork files.
On the 12 public flights HPR Sim’s apogee missed by 8.88% on average without signs, outside the project’s own 5% target (report). They’re university rockets that RocketPy’s documentation flies against their teams’ logs, and one other rocket’s two flights, from its public design file and logs. OpenRocket and RocketPy haven’t flown them here yet (see the planned milestones an open benchmark and the other tools’ cells).
The steps to a first answer are counted from a design’s .ork file to its apogee and its landing
spread. HPR Sim takes 2 commands at a command line, or 10 lines of Python. OpenRocket flies it in
7 clicks in its window, but its newest release has no Monte Carlo for the spread. RocketPy’s
Python can’t open the file. Each step is listed on the scoreboard.
For a round trip through OpenRocket’s file, HPR Sim reads an .ork file and writes it back.
OpenRocket then flies the original and the copy. Of 151 configurations, 0 moved by more than 0.002%,
and the largest change was 0.000050%; 2 of 75 designs didn’t make the trip
(report).
What it means for you
- If you design in OpenRocket, keep designing there. HPR Sim flies the same file as it is. Beside OpenRocket’s numbers it sets a second flight, its spread from the command line or Python, and the known gaps that bear on that flight. Each gap comes with the side it pushes, where that’s known.
- If you fly past the speed of sound, treat every tool’s apogee there as rough. HPR Sim’s supersonic drag is known to be off, either way. Neither HPR Sim’s accuracy nor OpenRocket’s has been measured against a logged flight there yet (the planned milestone for published flights faster than sound).
- If you need airbrakes, a hybrid or liquid motor, or a window to draw in, HPR Sim doesn’t have them yet. The list above names the tools that do and the milestone that brings each.
Where next
- To see it work, take A tour of HPR Sim.
- Accuracy and Trusting a simulation say how close it has come to real flights.
- Decisions and roadmap says what comes next and when.
Sources. The logged flights are a private collection of designs and their logs, shared as aggregates only. They come from university rocketry teams, rocketry courses and hobbyists.
The public flights are among those RocketPy’s documentation flies against their teams’ logs, but for one rocket’s two flights, which come from a public repository of designs and logs. The logged flights and RocketPy’s fly in ERA5 weather (the other rocket’s two fly in standard air): 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 logged flights’ report gives the full attribution and the ERA5 citations.
Trusting a simulation
A simulated apogee is an estimate: this guide shows how far off it has been on real flights, and which way it errs.
This guide is for a flier who reads a simulated apogee to pick a motor, plan a waiver or a field’s ceiling, or set up a flight. It explains what a simulator can and can’t know about a flight, how big its misses have been, and which miss to plan for. It’s the first of the guides in Rocketry explained. They explain the physics behind the numbers HPR Sim prints.
Two ways a simulation is wrong
A simulation can be wrong in what it’s told and in how it works. The first is its inputs. They’re the design file’s masses and balance point, the finish of the paint, the motor’s real thrust, and the day’s wind and air. The second is its models: above all the drag, which a simulator estimates from the rocket’s shape instead of measuring it.
Scattering the inputs shows the first kind. HPR Sim’s Monte Carlo command, hpr mc, flies the
rocket many times, each with its inputs drawn afresh, and prints the spread
(Monte Carlo dispersion). It can’t show the second kind: a model that’s wrong
the same way on every run moves every run together.
Only flights that really flew show the second kind. The comparisons below fly each rocket’s design in the day’s weather and set its apogee against the altimeter’s. So they measure both kinds at once, and the altimeter’s own error with them. The weather is the day’s, but the masses and the finish are the design file’s, as most fliers’ files are. And an altimeter reads the air’s pressure, not the height (Reading a flight log).
How far off it has been
A miss is the simulated apogee less the logged one, as a share of the logged one. A positive miss means the simulator said higher than the rocket flew:
For example, the public flight of Cavour, Politecnico di Torino, EuRoC 2023 read 2,785 m (9,137 ft) on its altimeter at the top. An altimeter riding HPR Sim’s flight of its design would have read 2,946 m (9,665 ft). The miss is (2,946 − 2,785) / 2,785 = +5.78% (report). EuRoC is the European Rocketry Challenge. On the public flights, both sides of a miss are altimeter readings.
Across 60 logged flights of fliers’ own designs, HPR Sim’s apogee averaged +8.01% above the logged one (report). Each flight was flown as drawn in its day’s air. Each logged apogee there is the altimeter’s reading turned into the height climbed in that day’s air, so the comparison leans on that conversion too. Without their signs, the misses averaged 12.09%, and 31 were within 10% either way. The figure counts them by size.
The misses lean high: 45 of the 60 simulated apogees are above the logged one. And they spread wide: the lowest read between 15% and 20% low, the highest past +30% high.
OpenRocket, flying the same files in each day’s wind and the pad’s air, averaged +6.72% above and missed by 11.26% without signs (report). The two simulators agreed with each other within 5% on 59 of the 60 flights. So most of the miss is one they share, and where it comes from isn’t pinned down. It could be in what both are given (the design file, the motor’s curve, the logged apogee they’re scored against), or in models they have in common. A second simulator checks how the first is coded, not what the two share.
The 12 public flights are university teams’ rockets and one other rocket that flew twice (report), 10 of them flown in a reanalysis of their days’ weather, one of those in another year’s. That rocket’s two are flown as the simulations stored in its design file, in standard air. HPR Sim’s apogee missed them by 8.88% on average without signs, from −29.16% to +10.40% one by one. With signs the misses averaged −4.64%, low on 7 of the 12. The average without signs is still outside the project’s own 5% target (Accuracy). The note HPR Sim prints with every apogee quotes the 60, the larger set and the less flattering one (the trust note’s decision record).
Which miss flatters
A miss can flatter or warn, and which one depends on the plan. For a waiver or a field’s ceiling, a simulated apogee below the real one flatters: the rocket climbs past the height that was planned for. A simulated apogee above the real one mainly costs height. For a contest’s lowest altitude, or a motor picked to reach a height, the sides swap, and the high side flatters.
The figure marks the low side, and a test ties the mark to the sign of a miss. The figure’s code
marks the bins of negative misses. And
a_low_simulated_apogee_is_a_negative_miss holds that a simulated apogee below
the logged one makes a negative miss in the report’s rows. Of the 60 flights, 15 read low, the
lowest of them between 15% and 20% low (report). A sample isn’t a bound: a
rocket unlike these may miss by more.
HPR Sim flew those flights in each day’s air from ERA5, a reanalysis of
the weather. Without --weather, hpr sim and hpr mc fly
the standard atmosphere instead. A day warmer
than it at the site, or at lower pressure, has thinner air. The real rocket then meets less drag
than the simulated one and can climb higher than a standard-air run’s apogee: the side that
flatters a ceiling. The note under such a run says so. --weather flies the day’s air, from a
profile hpr weather writes. On a warm day a barometric altimeter also reads below
the height climbed, as the atmosphere page works
through.
Juno III, one of the public flights, shows what the low side looks like. An altimeter riding HPR Sim’s flight of Juno III, Projeto Jupiter, Spaceport America Cup 2023 would have read 2,950.2 m (9,679 ft) at the top. The team’s altimeter read 3,151.5 m (10,340 ft), a miss of −6.39% (report). The real altimeter read 201.3 m (660 ft) higher than the simulated one, and its log ends just short of the top. The report finds this miss consistent with the motor’s impulse, as the example sets it.
So plan a ceiling with room above the simulated apogee. How much room is the flier’s and the RSO’s call, and this guide has no number for it.
The spread from the inputs
The guide’s worked example is the small rocket the repository keeps for its how-to guides. It’s
flown many times over, with its mass, its drag and its motor’s impulse each scattered. The command
gives each scatter as one standard deviation, as a share of the value: --mass-sd 0.02 for the
mass. The drag’s scatter is a guessed spread around HPR Sim’s own drag. It widens the runs, but it
can’t show a drag that’s wrong the same way on every run.
$ hpr mc validation/fixtures/ork/guides/level-1.ork --runs 200 --seed 2026 --mass-sd 0.02 --drag-sd 0.05 --impulse-sd 0.03
Level 1 guide rocket (level-1.ork)
configuration 1 of 2: [H170M-10]
help: --config flies the others, by number or name: 2 [I175WS-9]
200 simulated flights, seed 2026: 0 failed
nominal mean std dev 5% median 95%
apogee (m AGL) 1065.1 1072.4 41.5 1006.2 1072.8 1137.3
apogee (ft AGL) 3494 3519 136 3301 3520 3731
landing distance (m) 0.7 0.7 0.0 0.7 0.7 0.8
landing distance (ft) 2 2 0 2 2 3
opening shock (m/s²) 11.6 15.2 8.7 9.8 9.8 34.7
opening shock (g) 1.2 1.5 0.9 1.0 1.0 3.5
opening airspeed (m/s) 5.1 4.7 2.4 0.8 4.6 8.8
opening airspeed (ft/s) 17 15 8 3 15 29
200 of 200 flights landed, centered 0.7 m (2 ft) west and 0.0 m (0 ft) north of the pad
landing ellipse semi-major semi-minor heading flights inside
50% 0.0 m (0 ft) 0.0 m (0 ft) 090° T 74.5%
95% 0.1 m (0 ft) 0.0 m (0 ft) 090° T 98.0%
95%, the next flight 0.1 m (0 ft) 0.0 m (0 ft) 090° T 98.5%
motor: 1 × H170M (from the bundled catalog, as of 2026-10-28) in `Motor mount tube`, lit at launch
launched at 0.00000° N, 0.00000° E, 0 m (0 ft) above sea level, from 1.5 m (4.9 ft) of vertical rail above its aft end, in calm air
scattered, one standard deviation each: --mass-sd 0.02, --drag-sd 0.05, --impulse-sd 0.03
note: the file's 1 recovery device flies as OpenRocket flies it. Each opens fully at its event, with the file's drag coefficient or OpenRocket's own. Once one opens, the rocket descends as a point under the open devices' drag alone
warning: drag, the nominal flight: issue #67: a cone-like nose's or shoulder's pressure drag reads high from Mach 0.8 (about twice a measured cone's at Mach 0.85, still +15% at 1.5). So the apogee, top speed and drift read low, and the flutter margin and largest dynamic pressure look better than they are. This flight reaches Mach 0.84 at 1.7 s
warning: drag, the nominal flight: issue #68: base drag reads high from Mach 0.8 to 1.2 (0.225 against a measured 0.156 at Mach 0.9). So the apogee, top speed and drift read low, and the flutter margin and largest dynamic pressure look better than they are. This flight reaches Mach 0.84 at 1.7 s
warning: drag, the nominal flight: issue #18: skin friction is taken as fully turbulent; on a smooth surface a laminar run near the nose lowers it, by 3.6% on RocketPy's Calisto at Mach 0.3. If this surface is that smooth, the apogee, top speed and drift read low, and the flutter margin and largest dynamic pressure look better than they are
warning: stability, the nominal flight: issue #172: the static margin read up to 0.1108 calibers above OpenRocket's on four private designs, cause unknown; this flight's may read high by as much
warning: stability, the nominal flight: issue #1290: on one of two wind-tunnel models, the center of pressure sat 0.11 to 0.92 calibers aft of the tunnel's at Mach 0.6 and 0.8, as the report's curve reads; fitted over −3° to 4°, about 0.08 at 0.8. So from Mach 0.6 the flight margin may read high. This flight reaches Mach 0.84 at 1.7 s
warning: stability, the nominal flight: issue #1198: the center of pressure sat 0.67 to 1.35 calibers aft of a wind tunnel's on two models at Mach 0.9, so past Mach 0.8 the flight margin may read high. This flight reaches Mach 0.84 at 1.7 s
help: issues: https://github.com/nrdptel/fusionspace-eridanus/issues/<number>
How far to trust it. Simulated from the design file, not measured; the spread above comes from the
inputs' scatter alone, not from the model's error. Against 60 logged flights of fliers' own designs,
the simulated apogee averaged 8.0% above the logged one. HPR Sim flew each in its day's air from
ERA5, a weather reanalysis, and each logged apogee is the height climbed in it. The simulated apogee
was within 10% on 31 and read low on 15, by at most 20%. These flights were flown in the standard
atmosphere. On a day warmer than it at the site, the rocket can climb higher than this apogee;
--weather flies the day's air. Plan a waiver or a field's ceiling with room above this apogee; the
altimeter's reading is the one to log, and the RSO decides.
More: https://hpr.fusionspace.co/accuracy.html
Read it in three parts. The table’s 5% and 95% columns are
percentiles: most runs fell between them, a few on either side. The
warnings name the known model gaps that bear on this flight, each with the side it pushes the
numbers to. Here the drag may read high. If it does, the apogee reads low, the side that flatters
a ceiling.
The note at the end is the miss on real flights from the sections above, which the spread leaves out. The rest is the flight’s setup and its landing (Monte Carlo dispersion).
The warnings don’t settle which way this rocket will miss. They push its apogee low, yet across the 60 flights the misses leaned high on average. So causes not yet found can outweigh the known ones. A warning says which way one known gap pushes, not which way the flight will miss.
The spread and the miss don’t add as one range. The spread is this rocket’s, from inputs the command was told to scatter. The miss is a record of other rockets, and it already holds their files’ own input errors. Read the spread as how far the flight moves if the model is right and the inputs are off by about the scatter given. Read the miss as how far files like this one have been from the sky.
What this guide leaves out
- It checks nothing but apogee against real flights. No comparison here checks a top speed, a descent, a drift or a landing place against one. Those are checked against other programs, which shows that HPR Sim computes what they compute, not that any of them matches the world (Accuracy).
- It doesn’t cover rockets unlike these. The flights are hobby and university rockets as their fliers drew them. A rocket much faster, much higher or of an odd shape sits outside them, and Accuracy lists what each comparison covers.
- It doesn’t give your own rocket’s miss. A weighed rocket, its mass and balance point put in the file, removes one input error the logged flights carry. Only flying it and reading the altimeter measures the rest. Reading a flight log shows how to compare.
Sources. The logged flights are published by university rocketry teams, rocketry courses and hobbyists.
The 12 public flights are those RocketPy’s documentation flies against their teams’
logs, and the two flights of the Macie XL design in the MIT-licensed rlhatcher/rocketry-files
repository. The reanalysis 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.
Stability in flight
How far a rocket’s center of pressure moves with speed and angle of attack, and which way HPR Sim’s estimate of it can be wrong.
This guide is for a flier who reads a stability margin and wants to know what it means once the rocket is flying. The margin can come from HPR Sim, another simulator or a hand calculation. The guide explains where the center of pressure comes from and why speed and the angle of attack move it. Then it shows how well HPR Sim’s follows a wind tunnel’s, and which error flatters a margin. It’s one of the guides in Rocketry explained, which explain the physics behind the numbers HPR Sim prints.
The guide gives ranges, not verdicts. The safety code and the range safety officer (the RSO) decide whether a rocket flies.
Where the air pushes
A rocket’s weight acts at its center of gravity (CG), the point it balances on. When a gust or a tilted rail turns it, the air meets it at an angle, the angle of attack. The air then pushes on its side. That push, the normal force, acts at the center of pressure (CP).
If the CP is behind the CG, the push turns the nose back into the oncoming air, as a weathervane turns. If it’s ahead, the push turns the rocket further off, and it tumbles.
The stability margin is the distance from the CG back to the CP, in body diameters, called calibers. Each part of the rocket pushes on its own: the nose near the front, the fins at the back. The CP is the average of the parts’ stations, each weighted by how hard that part pushes per unit of angle, its normal-force slope :
Here and are the rocket’s center of pressure and center of gravity. Each part’s own center of pressure is , and all three are measured back from the nose tip. The index runs over the parts, and is the body’s diameter. So anything that makes one part push harder than the others moves the CP toward that part. So does anything that moves a part’s own center of pressure.
The margin HPR Sim prints as static margin is the one this gives at low
speed, with the air straight along the rocket. It’s the number
Barrowman’s method gives by hand.
Check stability for a certification flight reads it.
Speed moves it
Below the speed of sound, air squeezes a little as it flows past, more the faster the rocket goes. In HPR Sim’s model, each fin pushes harder for the same angle as the speed rises. It does so through the Prandtl-Glauert factor, the classic correction for that squeezing. On fins as short as most rockets’, the gain is well below the factor itself.
The nose’s push, in the slender-body theory that sets it, doesn’t change with speed. So in the model, as a rocket with fins at its tail speeds up, the fins gain on the nose and the CP moves aft. In the model the margin grows. The wind tunnel below doesn’t bear this out on the rocket it tested.
Faster than sound, the air can’t move aside ahead of a fin. HPR Sim uses supersonic linear theory there. At those speeds a fin’s push falls as the speed climbs, while a smooth body’s push grows as shocks form along it.
No closed-form method covers the speeds between, so HPR Sim joins its subsonic and supersonic fin methods with a straight line. In this guide I call that stretch the join (Fins through the speed of sound). It starts just below the speed of sound. It ends where supersonic theory starts for the fins, which depends on their shape.
Across the join each fin’s own center of pressure also slides aft, from a quarter of the way along its chord toward the middle. Once supersonic theory takes over, the CP turns and moves forward: the margin shrinks.
The guides’ rocket shows it, as HPR Sim computes it. It’s a small rocket for a first certification flight that the repository keeps for its how-to guides (its design file). No measurement of this rocket exists.
Straight into the wind, its center of pressure sits 13.99 calibers behind its nose tip at low speed. By Mach 0.8 it has moved 0.19 calibers aft, and by Mach 1.2, 1.04 calibers aft. By Mach 3 it sits 1.88 calibers forward of where it started (report). Supersonic linear theory starts for this rocket’s fins at Mach 1.37, and the speeds just below that are in the join. In the join, the tunnel below finds HPR Sim’s center of pressure too far aft.
The CG doesn’t depend on speed. It moves only as the motor burns, which the flight margin follows. So each caliber the CP moves is a caliber of margin.
So the margin printed at low speed isn’t the margin the rocket has at its top speed. hpr sim --json also gives the flight margin, the small-angle margin at the flight’s own Mach number and CG
at each moment. It gives its least value from the rail to apogee too (min_flight_margin_cal,
Flight metrics).
Against a wind tunnel
NASA tested half-scale models of the Arcas Robin in wind tunnels from Mach 0.6 to 4.63 (comparison). The Arcas Robin is a sounding rocket with a long nose and swept fins. From Mach 0.6 to 0.8 the tunnel’s center of pressure moved forward by 0.69 calibers, while HPR Sim’s moved aft by 0.10 calibers. From there on, the tunnel’s took the shape the section above describes, larger. From Mach 0.8 to 1.2 the tunnel’s center of pressure moved aft by 2.60 calibers, then forward by 5.23 calibers by Mach 4.63.
The figure sets HPR Sim’s center of pressure against the tunnel’s. Its axis doesn’t start at the nose tip.
Each of the tunnel’s points was read off the reports’ plots to within 0.05 to 0.11 calibers either way, the band drawn around its dot. At Mach 0.6, HPR Sim’s sat 0.12 calibers aft of the tunnel’s, just outside that band. At Mach 0.8, still on its subsonic fin method, HPR Sim’s sat 0.91 calibers aft of the tunnel’s. In the join the tunnel’s center of pressure moved aft later and more steeply than the straight line between Mach 0.8 and 1.2 puts it. HPR Sim’s didn’t follow it there either: it sat up to 1.35 calibers aft, at Mach 0.9.
From Mach 1.2 up, HPR Sim’s stayed within 0.35 calibers of the tunnel’s. On the model drawn, 9 of the 12 speeds are within 0.50 calibers, the target the comparison set before measuring. On the longer model the tunnel also tested, it sat up to 2.37 calibers aft, at Mach 1. On that model, 5 of its 10 speeds are within the target (Aerodynamics has the tables and the slopes).
Which error flatters
A CP that reads aft of the true one makes the margin read high: the rocket is less stable than the number says. That’s the flattering side for stability, the side to leave extra margin on. A CP that reads forward costs margin: the rocket is more stable than the number says.
The figure marks the flattering side: the build marks each speed where HPR Sim’s error is
positive. The test a_cp_aft_of_the_reference_reads_a_higher_margin pins what
that sign means: a CP aft of the reference’s is a positive error. It also pins that HPR Sim’s own
margin calculation then reads higher by that much, at any CG. It pins the sign, not how often HPR
Sim errs aft. The marks show that.
At 7 of the 12 speeds HPR Sim’s center of pressure sat aft of the tunnel’s. The largest were from just below the speed of sound through the join. So for a rocket that flies there, read HPR Sim’s flight margin as possibly high. The printed static margin, taken at low speed, says nothing about those speeds. These are one rocket’s errors, not an upper limit: a rocket unlike the Arcas Robin may err by more.
Angle moves it
At an angle of attack the body itself pushes sideways too, as a cylinder does in a side wind. That push is the body lift. It grows with the square of the angle’s sine, so it’s small at small angles and large at large ones. It acts near the middle of the body’s outline seen from the side. On most rockets that point is ahead of the fins, so as the angle grows the CP moves forward, and the margin shrinks.
At Mach 0.3, the guides’ rocket’s center of pressure moves forward by 0.25 calibers at 2°, 0.57 calibers at 5°, 1.01 calibers at 10°, and 1.34 calibers at 15° (report). Each shift is from where it sits at the same speed, with the air straight along the rocket.
The printed margins, static and flight, are the small-angle ones, so they don’t show this. The simulated flight does. HPR Sim flies the body lift at each moment’s angle. So a rocket leaving the rail in a crosswind, or knocked by a gust, is turned back toward the wind by a smaller margin than the printed one.
HPR Sim’s body lift has been checked against wind-tunnel tests of bodies without fins (Body lift). But no measurement here checks a whole rocket’s center of pressure at a large angle, and no test pins which way it errs there. So this section marks no side.
What this guide leaves out
- The center of gravity’s own error. The margin is only as good as the CG. HPR Sim takes the masses from the design file. Weigh and balance the built rocket, motor in (Check stability for a certification flight).
- Dynamic stability: how quickly a disturbed rocket settles, which also depends on its mass, its length and the air’s damping, and coning or roll. HPR Sim flies these, but this guide covers only where the air’s push acts.
- Parts the tunnel comparison doesn’t cover. Tube fins, pods and freeform fins are checked only against OpenRocket. Compare the margin in both programs (Check stability for a certification flight).
- A rule for how much margin is enough. That’s the safety code’s, the RSO’s and the published guidance’s (Compare with published guidance), not this guide’s.
When fins flutter
What makes a fin flutter, how the criterion HPR Sim uses puts a speed on it, and which way that speed can be wrong.
This guide is for a flier choosing a fin’s material and thickness, or reading a flutter speed, who wants to know what it means. The speed can come from HPR Sim, a calculator or a spreadsheet. The guide explains what flutter is and what the criterion’s speed depends on. Then it shows what the criterion’s two readings say about the guides’ rocket, and which errors flatter it. It’s one of the guides in Rocketry explained, which explain the physics behind the numbers HPR Sim prints.
Martin wrote the criterion at NACA, NASA’s forerunner. The guide gives ranges, not verdicts. The safety code and the range safety officer (the RSO) decide whether a rocket flies.
What flutter is
Air pushing on a fin twists it a little. The twist changes the angle at which the air meets the fin, so the push changes, and the fin bends. Below some speed the fin’s stiffness damps each wobble out. Above it, each cycle feeds the next, and the wobble grows until the fin breaks, sometimes within a second. That speed is the flutter speed.
What resists it is the fin’s stiffness against twisting, which comes from its material’s shear modulus and, far more, from its thickness. A fin that feels stiff when you bend it by hand can still be soft in twist.
Martin’s criterion
Martin reduced the theory of a wing that bends and twists to a few numbers from the fin’s outline. He checked it against the flutter record of missiles and wind-tunnel models (The criterion). His flutter speed is
Here is the speed of sound and the fin’s shear modulus. The denominator holds the rest: the air’s pressure and the fin’s shape. Read in words:
- Thickness counts most. The flutter speed grows as the thickness ratio (thickness over root chord) to the power one and a half. So a fin twice as thick flutters at nearly three times the speed.
- Stiffness counts less. The flutter speed grows as the square root of the shear modulus: a material four times as stiff in shear doubles it.
- A fin with a longer span for its chord (a higher aspect ratio) flutters sooner. On a fin of one root chord, span and thickness, a narrower tip lowers the flutter speed too. It raises the aspect ratio by more than the narrower tip’s taper helps.
- Thinner air raises the flutter speed, so the same fin can fly faster higher up.
- The air’s push at the flutter speed, the dynamic pressure there, is the same at every height. So a flight comes closest to its fins’ flutter speed where its own dynamic pressure peaks, at max q.
Martin’s constant comes from the theory, not a fit to data: it assumes the fin’s mass sits at mid-chord. His data decide only where his line falls, below.
The guides’ rocket
The guides’ rocket is a small rocket for a first certification flight that the repository keeps for its how-to guides (its design file). It has 3 fins of birch plywood, 3 mm (0.12 in) thick. Each fin has a 130 mm (5.12 in) root chord, a 60 mm (2.36 in) tip chord and a 75 mm (2.95 in) span.
The design file’s plywood is OpenRocket’s, which HPR Sim doesn’t match to one of its materials. So in this guide I use HPR Sim’s built-in birch plywood. It has a cited shear modulus, 0.75 GPa, from a plywood maker’s handbook. In Martin’s terms the fins have an aspect ratio of 0.79, a taper ratio of 0.46 and a thickness ratio of 2.3%.
The criterion leaves out one more thing about them: their leading edges are swept back by 70 mm (2.76 in) over the span.
The criterion puts their flutter speed at 175 m/s (574 ft/s), Mach 0.51, in the launch site’s air: standard air at sea level. The rocket reaches 286 m/s (938 ft/s), Mach 0.84, on the faster of its motors. Max q comes 298 m (978 ft) above the pad, in air close to the launch site’s. At max q, 48.5 kPa, the flutter speed is 0.62 times the airspeed there: by this criterion, the fins fly faster than their flutter speed.
No measurement known to this project sizes the criterion’s error on fins like these. So this reading marks the fins for a closer look. It doesn’t say they will fail. For the flutter speed to reach the airspeed at max q, the plywood would have to be 4.2 mm (0.166 in) thick.
The hpr command doesn’t print these yet. In code, HPR Sim’s FlutterPanel
gives the flutter speed and the ratio at max q. A rocket’s fins has a
worked example that CI runs.
Two readings
The ratio is the first reading. The second is Martin’s own check: where the fin plots on his chart against the line his data draw.
His chart gives each wing one number, the denominator over its shear modulus . The higher it is, the less stiff the wing for the air it flies in. Wings that fluttered or failed lie above a band, and wings that flew to at least Mach 1.3 without known failure lie below it. The band runs at a ratio of 0.25 to 0.31, a flutter speed 1.8 to 2.0 times the speed of sound (The line in Martin’s data). So the band isn’t a speed to stay under: it’s how stiff Martin’s unfailed wings were, all of them faster than sound.
The guides’ rocket’s fins plot at 3.79, above the band. To plot below it with the same outline, they would have to be 7.5 mm (0.296 in) thick.
The figure in A flutter speed that reads high shows the same fact the other way up: the fins’ flutter speed sits below the band. That says less than it seems to. The rocket tops out at Mach 0.84, while Martin’s wings below the band flew past the speed of sound. His data show nothing about a fin above the band on a slower rocket: not that it’s safe, and not that it will flutter.
Of the two, Martin’s chart is the stricter, and it’s his own check. A fin below the band is among
wings that flew faster than sound unharmed. A ratio V_f / V above one says only that the rocket
stays below the criterion’s speed. No measurement known to this project sizes that speed’s error
on hobby fins. Neither is a line to fly by.
A flutter speed that reads high
A flutter speed that reads high flatters: it says a fin is stiffer, or the rocket further from flutter, than it is. The figure draws the guides’ rocket’s flutter speed by thickness, with the best-known such error above it.
Apogee Components’ Peak of Flight newsletter printed Martin’s formula in issues #291 and #411 with its constant halved. So its flutter speed reads 41% high. Issue #615 corrected it.
A calculator or a spreadsheet that copied the printed form gives the higher speed. Loft, HPR Sim’s predecessor, made the same mistake (a lesson from Loft). The halved constant puts the guides’ rocket’s flutter speed at 247 m/s (810 ft/s), and the ratio at max q at 0.88.
The figure marks the halved constant’s line in the caution color. The test
the_halved_constant_reads_a_higher_flutter_speed pins which way that error
goes, on three fins in two kinds of air. It pins the halved form’s flutter speed at the square
root of two times HPR Sim’s, never below it. It pins the halved form’s ratio V_f / V higher by
the same factor.
Only the constant differs, so the factor is the same on every fin in any air. The guide’s own test pins that the marked line is that speed.
Where Martin leaves a choice, HPR Sim takes the one that gives the lower flutter speed (Readings where the source leaves room):
- the thickness ratio at the root, the smallest on a fin of one thickness;
- a solid fin’s shear modulus as its material’s, not the flat plate’s reading, which is twice as stiff;
- Martin’s simpler taper factor, which lowers the speed for most tapers.
Two choices can go the other way. A fin with an airfoil section reads a few percent high. A booster’s fins are held to the whole flight’s max q, without a check of the booster’s own after it separates.
And the correction in #615 reads where the fin’s mass sits from the whole fin’s outline, not from Martin’s section. On a swept fin like the guides’ rocket’s, that puts the mass further aft and the flutter speed lower still. HPR Sim keeps Martin’s reading.
What the criterion leaves out may matter more than any of these. Martin’s wings were clamped at the root. A fin glued to a tube twists more there, so its real flutter speed can be lower, on the flattering side. Sweep, which the guides’ rocket’s fins have, is left out, and no test pins which way it moves the speed. So a flutter speed only a little above the top speed isn’t a margin anyone has measured.
What this guide leaves out
- Fiberglass and printed fins. G10, the commonest fiberglass fin sheet, has no cited shear modulus in HPR Sim, and nor do the common printing plastics. Pass your own from a measurement or your supplier (Shear moduli).
- How the fin is built and attached: fillets, tip-to-tip layups, through-the-wall tabs, and the body tube’s own bending.
- Speed effects near the speed of sound, where flutter speeds can dip, and stall flutter at large angles of attack.
- A rule for how much margin is enough. That’s the safety code’s, the RSO’s and the fin maker’s, not this guide’s.
Drag through the speed of sound
What a rocket’s drag is made of, how it climbs near the speed of sound, and which way HPR Sim’s drag can be wrong.
This guide is for a flier who reads a drag coefficient, from HPR Sim, another simulator or a hand calculation. They want to know why it changes with speed and how far to trust the drag a simulation flies. They also want to know why a faster motor doesn’t fly a rocket as much higher as its extra impulse suggests.
The guide explains the drag’s three parts, the rise near the speed of sound and what the finish changes. Then it shows how well HPR Sim’s drag follows a wind tunnel’s, and which error flatters. It’s one of the guides in Rocketry explained, which explain the physics behind the numbers HPR Sim prints.
The guide gives ranges, not verdicts. The safety code and the range safety officer (the RSO) decide whether a rocket flies.
What drag is made of
Drag is the air holding a rocket back along its path. It grows with the dynamic pressure . At low speed that’s the pressure the oncoming air would exert if it were brought to rest. The dynamic pressure grows with the air’s density and the square of the speed. A simulator turns it into the drag , a force, with the rocket’s drag coefficient and its reference area , the body’s cross-section:
Here is the air’s density and the airspeed. The drag coefficient is how draggy the shape is, whatever its size. It changes with speed, given here as a Mach number, the airspeed over the speed of sound. It’s the sum of three parts:
- Skin friction: the air rubbing along the surface, in the thin boundary layer it drags along. It acts over the whole outside of the rocket, so a longer rocket, or one with bigger fins, has more of it.
- Pressure drag: the air pushing back on every face that meets it: the nose, a shoulder, the fins’ front edges. A smooth, pointed nose has almost none below the speed of sound. A flat fin edge has some at any speed.
- Base drag: the low pressure behind the flat aft end, where the air can’t follow the body round its corner. It pulls back on the base like a suction cup.
HPR Sim builds the coefficient up part by part, following Niskanen’s thesis, which OpenRocket also follows (Aerodynamics).
The guides’ rocket shows the parts, as HPR Sim computes them. It’s a small rocket for a first certification flight that the repository keeps for its how-to guides (its design file). No measurement of this rocket’s drag exists. At Mach 0.3 in sea-level air its drag coefficient is 0.60: skin friction makes 59% of it, the base 22% and the fins’ square edges 19%. Its ogive nose, smooth into the body, adds next to nothing at that speed (report).
A worked example. At Mach 0.5 in sea-level air the guides’ rocket flies at 170 m/s (558 ft/s), so the dynamic pressure is 17.7 kPa. Its reference area is the body’s cross-section, 66 mm (2.60 in) across. Its drag coefficient there is 0.63, so the air holds it back with 38 N, the weight of 3.9 kg.
Through the speed of sound
Air flowing round a nose speeds up, so as a rocket nears the speed of sound the air beside its nose passes it first. Shocks form there, and the pressure pushing back on the nose climbs: the transonic drag rise. Past the speed of sound the nose pushes a shock wave ahead of it. Its pressure drag, now called wave drag, settles to a value set by the nose’s shape and how slender it is.
The base’s share of the coefficient grows with speed too, until the speed of sound, and then falls. The suction itself keeps growing, though more slowly. Skin friction’s falls with speed, by a step at the speed of sound in HPR Sim’s rule and faster past it (Aerodynamics has the formulas).
The guides’ rocket’s drag coefficient climbs to 0.69 by Mach 0.8 and 0.84 at Mach 1. It peaks at 0.88 at Mach 1.07, 45% above its value at Mach 0.3, and by Mach 2 it’s back down to 0.57 (report). The base’s part of the drag coefficient grows from 0.15 at Mach 0.5 to 0.25 at Mach 1, then falls (report). The nose’s pressure drag, next to nothing at Mach 0.5, reaches 0.19 at Mach 1.1 (report).
Drag grows with the square of the speed as well, so the two compound. Doubling the speed makes the dynamic pressure four times larger, and the coefficient is higher besides. So in the same air, at Mach 1 it meets 5.3 times the drag it meets at Mach 0.5.
That’s why a bigger motor buys less height near the speed of sound than its extra impulse suggests. More of the extra goes into pushing air. On the faster of its two motors the guides’ rocket reaches Mach 0.84, where the rise has begun. At Mach 0.85, just past that, its drag coefficient is 0.71, 17% above its value at Mach 0.3 (When fins flutter flies it).
Surface finish
Skin friction depends on how rough the surface is. On a smooth surface the friction falls slowly as the rocket gets faster or longer. On a rough one, above a speed that depends on how rough it is, the roughness alone sets it. HPR Sim takes the roughness from each part’s finish, a height in micrometers from Barrowman’s table of surfaces (Aerodynamics).
With every outside part given the same finish, the guides’ rocket’s drag coefficient at Mach 0.3 is: polished, 0.5 µm, 0.49; aircraft paint, 20 µm, HPR Sim’s default, 0.53; the design’s own 60 µm, 0.60; and badly sprayed paint, 200 µm, 0.70 (report). So at Mach 0.3 the drag coefficient is 43% higher with the badly sprayed paint than with the polished finish. The design’s finish is what OpenRocket calls regular paint. Which finish a built rocket has is a judgment: the table describes surfaces, not a hobby rocket’s paint, seams, fillets and decals.
Against a wind tunnel
NASA measured the drag of two half-scale models of the Arcas Robin. It’s a sounding rocket with a long nose, thin, sharp swept fins and a short boattail. The short model is the Arcas Robin itself, and the long one has a stretched body. They flew in two wind tunnels from Mach 0.6 to 4.63 (comparison).
The models sat on a sting, which disturbs the air behind the base. So the comparison is of the forebody: the drag less the base’s. With its fins on, the model’s measured forebody drag rose from 0.30 at Mach 0.6 to 0.69 at Mach 1. Then it fell to 0.18 by Mach 4.63: the same rise and fall, on another rocket. The figure sets HPR Sim’s forebody drag against the tunnel’s, on the short model.
Each of the tunnel’s points was read off the reports’ plots to within 0.002 to 0.008 in drag coefficient either way. That’s the band drawn round its dot, and most bands are smaller than the dot.
HPR Sim’s read +12.9% at Mach 0.6. It read +51.0% at Mach 0.9, the most of the readings below the speed of sound. It read +7.1% at Mach 1, the least. Then it read more at every faster speed, to +154.0% at Mach 4.63, and at the faster speeds most of that is the fins. HPR Sim gives a fin’s front edge the drag of a rounded edge, which grows with speed, where a thin, sharp fin’s falls.
With the fins off, HPR Sim’s read +12.0% to +44.6% high on the short model, and up to +54.2% on the long one. Most of that comes from the boattail, which HPR Sim’s rule over-predicts at these speeds.
The models’ finish wasn’t reported. The comparison takes it as polished, a guess, and a rougher one would read higher still. Only 2 of the 44 readings, both models’ with their fins on and off, are within 10%, the target the comparison set before measuring. Aerodynamics has the tables and the causes.
Which error flatters
A drag that reads high makes the simulated rocket fly lower and slower than the real one. The simulated apogee, top speed and max q, the peak dynamic pressure, all read low. For a flight near a waiver’s ceiling, the height a launch’s airspace permit allows, that’s the flattering side. The real rocket may climb higher than the number says. A max q that reads low flatters the fins and the airframe too (When fins flutter).
A drag that reads low errs the other way: the rocket flies lower than the number says. That’s the optimistic side for a flier aiming at a target altitude.
The figure marks the flattering side: its thick bars mark each speed where HPR Sim’s drag reads
above the tunnel’s. The test a_higher_drag_reads_a_lower_apogee pins what that
sign means, on a rocket that passes the speed of sound and on one that doesn’t. On both, the same
flight with its drag scaled up reaches a lower apogee, a lower top speed and a lower max q.
Scaled down, it reaches higher ones.
It pins the sign, not how often HPR Sim errs high. The marks show that. On the Arcas Robin, HPR Sim’s forebody drag read high at every speed. So for a rocket of that shape, with thin, sharp fins and a boattail, read its apogee as possibly low.
The tunnel’s rocket isn’t a hobby rocket, though. On the logged hobby flights of Trusting a simulation, HPR Sim’s apogee averaged +8.01% above the logged one on the 60 flights.
On those rockets something leans the other way. Drag that reads low is one candidate. The motor’s thrust and the rocket’s mass are others. No comparison yet sizes HPR Sim’s drag alone on a hobby rocket, so neither direction is a rule for yours.
What this guide leaves out
- The base while the motor burns. HPR Sim takes the burning motor’s cross-section off the base’s area, as Niskanen does. OpenRocket keeps the whole base. No measurement here checks either (power-on drag).
- Drag at an angle of attack. A rocket flying at an angle meets more drag. HPR Sim scales its drag coefficient by a factor of the angle, which no comparison here checks.
- Launch lugs, rail buttons and fillets. The guides’ rocket has none modeled. Each adds drag, and HPR Sim models lugs and buttons but not fillets (Aerodynamics).
- The other comparisons. HPR Sim’s drag is also compared with RASAero II’s curves and with a handbook’s worked calculation, neither a measurement (Aerodynamics).
Sources. The tunnel readings are NASA’s, works of the US Government. The logged flights’ 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.
Frames and sign conventions
This page defines the axes and signs all of HPR Sim shares, from the Earth-centered frame to the rocket’s body, attitude and launch angles.
In short
- What it models: the directions and signs the whole simulator shares. They define a frame fixed to the Earth at its center, the launch-site frame (east, north, up) and the rocket’s body frame. They also define its angle to the airflow, its attitude (which way it points) and its launch angles.
- Sources: the WGS 84 standard, NGA.STND.0036 (2014), as in Geodesy. J. Solà, Quaternion kinematics for the error-state Kalman filter (2017). RocketPy 1.13.0, for its launch-angle convention.
- How well it is validated: unit tests, and one check against another simulator. For 8 rail setups, launch angles give RocketPy’s starting attitude to 1e-12 rad. Over 1e6 integration steps, attitude stays within 1e-9 rad of the exact answer. Eight of NASA’s check cases fly through the launch frame against the codes NASA published, two of them shots that carry a body kilometers from the pad, which come out inside the codes’ spread (a free body against NASA’s check cases). No real-flight check.
- What it leaves out: heights are above the WGS 84 ellipsoid, not sea level. The two are up to about 100 m (328 ft) apart. The attitude equations leave out the Earth’s rotation rate, 7.3e-5 rad/s, which is tiny next to a rocket’s pitch rates (the rigid-body flight decision). On a tumbling brick, NASA’s check case 2, what that leaves out grows to 0.01633 deg/s within 30 s (a free body against NASA’s check cases, #1521).
Sources and units
Where the frames are defined in the code, and the units and rotation rules every frame uses.
Code and sources
This is the single definition of the frames, and every crate follows it. Code:
hpr_core::{geodesy, frames, attitude}. The frames and gravity decision records why
these choices were made.
Units and angles
- SI throughout: meters, seconds, kilograms, radians. Degrees exist only at I/O boundaries
(
Geodetic::from_degrees). - Every rotation is right-handed. , and turn vectors by about the named axis (active rotations).
The frames
The three frames: one fixed to the Earth, one at the launch site, and one fixed to the rocket.
Earth-centered Earth-fixed (ECEF)
The WGS 84 conventional terrestrial frame:
- origin at the Earth’s center of mass;
- along the rotation axis toward the north pole;
- through the prime meridian at the equator;
- completes the right-handed set (90° E).
A geodetic position gives the latitude (positive north, in ) and the longitude (positive east). The height is above the ellipsoid, along its normal.
is ellipsoidal height, not height above mean sea level. The two differ by the geoid undulation (, with up to about 100 m (328 ft)). Inputs quoted above sea level must be converted before use. HPR Sim has no geoid model, so a flight takes at the launch site as an input. Atmosphere shows where it is used.
Launch frame L (East-North-Up)
-
The origin is the launch site’s geodetic position , at the pad on the ground.
-
The axes are east, north, up along the ellipsoid normal at the origin.
-
To ECEF, . The columns of are, in ECEF components:
-
is Earth-fixed, so not inertial. It turns with the Earth at in components, with . The translational equations in add the Coriolis term . The centrifugal term is already inside normal gravity and must not be added again (Gravity).
-
is a tangent plane, so is not altitude. A point at at horizontal distance from the pad stands about higher above the ellipsoid than the pad. Here is the Earth’s radius of curvature at the pad, plus the pad’s height. At 10 km (6.2 mi) to the east, the rise is 7.8 m (26 ft). Height above the ellipsoid comes from
LaunchFrame::geodetic_from_enu. The flight engine detects apogee and ground contact with that height, not with (Rigid-body flight, Loft’s lesson on apogee height).
Body frame B
- The origin is the nose tip, on the axis (the design-tree decision). Positions in mass properties are measured from it.
- lies along the axis of symmetry, positive toward the nose. is the design’s zero radial direction, the angle from which fins, rail buttons and lugs are placed. .
- The thrust of a motor aligned with the axis acts along .
- Design stations are measured aft from the nose tip, as design files state them. They map to with , so and the whole rocket lies at (Design tree).
Angles and attitude
The rocket’s angles to the airflow, its attitude, and the launch angles used for input and output.
Aerodynamic angles
-
The angle of attack is the total angle between and the rocket’s velocity relative to the air, in .
-
The flow roll is the direction in which the air crosses the body, measured in the - plane from toward . Fin of a set sits at from the lateral airflow, with the set’s base angle.
-
There is no separate sideslip angle: says how far the air crosses the body and which way.
-
With the lateral air direction in , the normal and side forces are
is positive along , the way the crossing air pushes the body, and is across the flow’s plane (Aerodynamics). The axial force is . is positive when the flow meets the nose and drag pushes toward the tail. It is negative past , when the rocket moves tail first.
-
The rolling moment is about , right-handed, with the reference diameter. A positive one turns toward . A fin set’s positive cant turns the leading edge of fin 0 (the fin along ) toward . So it turns the rocket about , clockwise seen from ahead of the nose, and the roll rate settles negative (Roll: forcing and damping).
Attitude
The attitude is a unit Hamilton quaternion (glam DQuat, stored x, y, z, w) that maps
body components to launch-frame components (in glam, q.mul_vec3(v_B)):
- and are the same attitude.
- The body angular velocity is the rate of relative to , in components.
- The kinematics are (Solà 2017, eq. 200). The integrator renormalizes
after every step (
attitude::renormalize). - itself turns at (above), so differs from the inertial rate by , at most 7.3e-5 rad/s. The flight engine’s rotational equations leave that term out (the rigid-body flight decision).
Launch angles
Launch-rail-style angles describe the attitude for input and output (frames::LaunchAngles):
- the azimuth , the heading of the body axis, clockwise from true north ( is east), in ;
- the elevation , the angle of the body axis above the horizon ( is vertical), in ;
- the roll , the turn about , in .
-
At zero roll, is horizontal, to the right of the heading: in . is
-
Vertical is a singularity: at , and turn about the same axis.
LaunchAngles::from_quaternionthen reports and puts the whole turn into . This is for reporting only: the state is always the quaternion. -
These angles are RocketPy’s 3-1-3 convention:
- is the heading and the inclination.
- is the rail-button angular position for a
tail_to_noserocket, and minus it for anose_to_tailrocket. - RocketPy 1.13.0 sets precession , nutation and spin ,
then builds (
rocketpy/simulation/flight.py:1557-1579,rocketpy/tools.pyeuler313_to_quaternions). validation/oracles/rocketpy/attitude.pybuilds real RocketPy flights for 8 rail setups, with both orientations, and records the initiale0…e3.frames::tests::launch_angles_match_the_rocketpy_oraclechecks that (w, x, y, z) is the same attitude to 1e-12 rad.- RocketPy’s body also points toward the nose.
Tests that pin this
- In
hpr_core::geodesy::tests:- geodetic → ECEF → geodetic, from −10 km (−6.2 mi) to 1,000 km (621 mi);
- ECEF → geodetic → ECEF, from 6,250 km (3,884 mi) to 46,000 km (28,583 mi) from the center;
- axis points, the sphere limit, and the ENU rotation being proper with normal to the ellipsoid.
- In
hpr_core::frames::tests:- angles → quaternion → angles (off vertical), and quaternion → angles → quaternion (everywhere, exactly vertical included);
- ENU ↔ ECEF ↔ geodetic round trips for sites anywhere, within 2,000 km (1,243 mi) and up to 1,000 km (621 mi) high;
- named attitudes, and the tangent-plane rise due east, there being the radius Geodesy calls , plus the site’s height.
- In
hpr_core::attitude::tests: the kinematic equation checked against a closed-form coning motion, and norm drift ≤ 1e-12 over 1e6 RK4 steps with attitude error < 1e-9 rad. cargo xtask check-cases, held by the gate where the codes’ files are fetched: NASA’s check cases 1 to 3 and 6 to 10 flown in the launch frame, the positions of cases 6 to 10 turned into Earth-fixed axes and compared as distances (a free body against NASA’s check cases). Two things of this page are in them. The height above the ellipsoid is read back from the launch frame along a 4.4 km (2.7 mi) fall, down the site’s vertical on the equator, where the ellipsoid’s shape hardly enters. The Earth’s rate is turned from the launch frame into the body’s axes to give inertial rates. In cases 1 and 2, with the two named model differences taken off each kept code’s largest difference, at most 0.1364 mm (0.0054 in) of altitude and 0.001005 deg/s of body rate are left, both inside the codes’ spread; read at every sample, case 2’s rates are left just past it. Case 3’s rates and the sphere’s positions in cases 6 to 8 are traced to inside the spread, and cases 9 and 10 come out inside it as flown; the flight page’s table gives each. The attitude itself is not compared.
Geodesy: the ellipsoid, coordinates, distance and bearing
HPR Sim models the Earth as a flattened ellipsoid, and this page shows how it converts coordinates and measures distance and bearing between places.
In short
- What it models: the Earth’s shape, as the WGS 84 ellipsoid (a sphere slightly flattened at the poles). It converts between latitude, longitude and height and Earth-centered x, y, z. It gives the local east, north and up directions, and the distance and bearing between two places.
- Sources: the NGA’s WGS 84 standard, NGA.STND.0036 (2014). C. F. F. Karney, Geodesics on
an ellipsoid of revolution (2011), appendix B. Karney, Algorithms for geodesics (2013),
through the
geographiclib-rscrate. - How well it is validated: for the conversions, the derived ellipsoid values reproduce the standard’s Table 3.5 to its printed digits. Unit tests make random round trips from −10 km (−6.2 mi) to +1000 km (621 mi). They return latitude within 1e-14 rad and height within 2e-8 m. The conversions are not compared with another library, a simulator or a real flight. For distance and bearing, all 500,000 lines of Karney’s published test set match within 15 nanometers (nm, billionths of a meter). Distance is within 11.18 nm, the far point within 14.02 nm, and the bearings within 15 nm of sideways miss (below). CI checks every 500th line and the 21 mirror lines. The whole set is checked where it has been downloaded, and has been measured on macOS.
- What it leaves out: height above sea level, which needs the geoid, up to about 100 m (328 ft) from
the ellipsoid (Frames). HPR Sim has no geoid model.
A flight takes that difference at the site as an input. Nothing in a flight uses distance and
bearing yet. The landing distance
hprprints is measured on a flat map from the pad’s east and north offsets, and there is no command for geodesics.
Sources
Code: hpr_core::geodesy and hpr_core::geodesic. Conventions: Frames.
- [NGA] NGA.STND.0036_1.0.0_WGS84, Department of Defense World Geodetic System 1984, Its
Definition and Relationships with Local Geodetic Systems, July 8, 2014. Pinned as
wgs84-nga-stnd-0036. US government work. - [Karney] C. F. F. Karney, Geodesics on an ellipsoid of revolution, arXiv:1102.1215v1,
2011, appendix B. Pinned as
karney-2011-geodesics. - Karney2013 C. F. F. Karney, Algorithms for geodesics, J. Geodesy 87 (2013) 43–55,
arXiv:1109.4448v2. Pinned as
karney-2013-algorithms-for-geodesics. - GeodTest C. F. F. Karney, Test set for geodesics, doi:10.5281/zenodo.32156, CC0.
Pinned as
karney-geodtest.
Ellipsoid and coordinates
The ellipsoid, coordinate conversions and the local axes.
WGS 84 ellipsoid
-
The defining parameters ([NGA] Table 3.1) are and .
-
The derived values are , and .
-
These reproduce [NGA] Table 3.5 to its printed digits (
wgs84_derived_geometry_matches_table_3_5):quantity value (m, or ratio) 6,356,752.3142 m (20,855,486.595 ft) 6.694379990141e-3 5.2185400842339e5 m
Geodetic to ECEF ([NGA] eqs. 4-14, 4-15)
The code writes as .
ECEF to geodetic ([Karney] appendix B)
This is Vermeille’s closed form, which Karney extended to cover points near the Earth’s center.
Setup. Let , and . The geodetic latitude follows from the largest real root of (B1):
Solving for .
If , with the real cube root and given the sign of ( if ):
If :
Solving for . The last line is (B5). When , the code takes , which avoids cancellation.
Latitude, height and longitude. The first line is (B2); the next two are (B3).
is the argument, computed with atan2; on the axis.
The closed form fails only in the equatorial plane within (42.7 km (27 mi)) of the center. There
the paper needs its limiting forms (B6)–(B7). The code returns CoreError::Domain instead.
Measured accuracy (property tests, 256 cases each per run):
- geodetic → ECEF → geodetic: latitude within 1e-14 rad and height within 2e-8 m, from −10 km (−6.2 mi) to +1000 km (621 mi);
- ECEF → geodetic → ECEF: within 1e-7 m per 6,400 km (3,977 mi) of radius, out to 46,000 km (28,583 mi).
Local ENU axes
ecef_from_enu_rotation(φ, λ) has columns , and (Frames). A test checks that
equals the normalized gradient of at the foot point, i.e. the ellipsoid
normal.
Distance and bearing: geodesics
How far is the landing from the pad, and in which direction? On a flat map that is Pythagoras. On the Earth it is a geodesic, the shortest path over the ellipsoid’s surface. Its length is the distance, and its direction where it leaves is the bearing.
Geodesists call a bearing an azimuth. Here the two mean the
same. hpr_core::geodesic solves the two classic problems
(API reference):
- The inverse (
Ellipsoid::geodesic_inverse): from two places, the distance and the azimuths (leaving the first) and (arriving at the second). - The direct (
Ellipsoid::geodesic_direct): from a place, a bearing and a distance, the latitude and longitude you reach and the azimuth there.
Azimuths are clockwise from true north, in radians from to , so due west is . For the 0°
to 360° a compass uses, take .to_degrees().rem_euclid(360.0). is the direction of travel
on arrival, so the bearing back to the start is . Over a long path it differs from
because meridians converge. Heights are ignored: the path runs on the ellipsoid’s
surface, and the direct problem’s end has no height until you give it one.
Method. The code is Karney’s GeographicLib, as georust’s geographiclib-rs 0.2.7 (MIT) ports
it. The simulator uses the crate rather than a port of its own, so the code is Karney’s line for
line (the geodesics decision record). Karney2013 maps the ellipsoid onto an auxiliary sphere,
where a geodesic is a great circle (the sphere’s shortest path). Karney2013 corrects distance and
longitude with series in the flattening to sixth order (§2). The inverse finds by Newton’s
method (§4), from a starting guess (§5).
Karney states that round-off stays under 15 nm in both problems on WGS 84 (§7, page 10). He adds that up to a flattening of 1/150 the series’ truncation is smaller still (page 9). Past 1/150 the series lose accuracy, so the simulator refuses such an ellipsoid; WGS 84’s flattening is 1/298. The familiar haversine formula treats the Earth as a sphere, which the Earth is not. Vincenty’s ellipsoidal method is less accurate than Karney’s, and its inverse sometimes fails to converge (§7).
Worked example. A pad at 32.9904° N, 106.9750° W and a landing at 33.0000° N, 106.9680° W:
| quantity | value |
|---|---|
| distance | 1,249.614 m (4,099.78 ft) |
| bearing from the pad | 31.567° |
| azimuth on arrival | 31.571° |
At this range a flat map gives the same distance if it uses the ellipsoid’s curvature at the
middle latitude: 1,249.614 m (4,099.78 ft) again, to under a millimeter. The other way round,
2 km (1.2 mi) from the same pad on a bearing of 60° reaches 32.999415° N, 106.956466° W, heading
60.010°. The geodesic matters over long paths, where a flat map’s error grows. A unit test,
the_guides_worked_example, holds these numbers.
Validation. GeodTest is Karney’s set of 500,000 WGS 84 geodesics. They were worked separately from the code, with the series carried to thirtieth order and high-precision arithmetic. Each end is known to 1e-18°, so they check this code’s method and its rounding.
They come in nine kinds of 50,000 or 100,000 lines each, listed in the
geodesics report.
The kinds are random pairs, nearly antipodal pairs (almost opposite sides of the Earth), short
paths and paths near the poles. The rest run nearly along a meridian or the equator, or near a
vertex, the point where a geodesic runs due east or west. crates/hpr-core/tests/geodtest.rs
solves every line both ways and measures five errors, each held to Karney’s 15 nm on every line:
| error | what it is | largest |
|---|---|---|
| inverse distance | the computed against the set’s | 11.18 nm |
| inverse landing | solve the direct problem with the inverse’s own and , and measure how far it lands from the second place | 11.26 nm |
| inverse azimuths × | each azimuth’s error times the reduced length , how far the far end moves sideways per radian the start’s bearing turns: the sideways miss the error stands for | 8.49 nm |
| direct end point | the computed end against the set’s, in Earth-centered coordinates | 14.02 nm |
| direct heading × | the angle between the computed and the set’s direction of travel at the end, as directions in space, times the Earth’s radius | 13.99 nm |
The inverse’s azimuths can’t be checked on the 50,000 “between vertices” lines. There is at most 1e-13 m, so any azimuth error reads as no miss. Their distance and landing are checked.
Mirror lines: two paths of the same length. Suppose the second place’s latitude is exactly
the first’s negated () and the two azimuths differ (). Then two geodesics of the
same length join the places, one the mirror of the other. The second geodesic has and swapped
(GeographicLib’s GeodSolve manual, Multiple solutions). Either answer is right. Where
, as on the between-vertices lines, the geodesic is unique.
The set has 21 mirror lines once its numbers are read as f64 (the 64-bit floating-point numbers
the simulator computes in). They are all nearly antipodal, with under a centimeter, so their azimuths are nearly
undetermined. On these lines the test scores the simulator’s answer against whichever pair it is
nearer to. That error is within 15 nm on all 21. On 4 the nearer pair is the swapped one.
CI checks every 500th line (1,000 of them) and the 21 mirror lines, which are committed. The
whole set is checked where cargo xtask refs fetch has downloaded it, against the committed
report. The whole set has been measured only on macOS, by the debug build that wrote the report’s
table. A release build there moves three cells by up to 1.83 nm. On any other build the test
holds the 15 nm bound without comparing the table.
What it leaves out. Heights: two places at 3,000 m (9,843 ft) are as far apart as the same places at
sea level. Only WGS 84 is measured. On any other ellipsoid up to a flattening of 1/150, the
accuracy is Karney’s claim, not something this project has measured. A distance of many trips
round the Earth carries its own rounding: one step of f64 in the distance. That is at least
14.9 nm past 67,109 km (41,700 mi). Nothing in a flight uses geodesics yet, and hpr has no command for them.
Gravity and Earth rotation
This page covers the gravity a rocket feels, which changes with latitude and height, and the Coriolis push the spinning Earth gives it.
In short
- What it models: the pull a rocket feels. It is WGS 84 normal gravity, the gravity of a smooth, spinning model Earth, which changes with latitude and height. It also models the Coriolis effect, the sideways push on anything that moves over the spinning Earth.
- Sources: the NGA’s WGS 84 standard, NGA.STND.0036 (2014), chapter 4 and appendix B.
- How well it is validated: the derived constants reproduce the standard’s printed values to their last digit. At 11 points, both poles and heights up to 200 km (124 mi) included, gravity’s strength matches the published formulas within 2e-14 relative. A reference script evaluates the formulas in 40-digit arithmetic. HPR Sim’s copy of RocketPy’s formula matches RocketPy at 8 points, to under 1e-12 relative. On NASA’s check case 1, a sphere falling 30 s with no drag, HPR Sim ends 19.51 mm (0.77 in) below the codes NASA published, whose field stops at its second term: normal gravity’s further terms account for 19.50 mm (0.77 in) of that (a free body against NASA’s check cases). No real-flight check.
- What it leaves out: the real Earth’s gravity anomalies, typically within ±1e-4 relative. RocketPy’s formula, an option for like-for-like comparisons, differs from the exact field by 1.4e-5 relative at 100 km (62 mi).
Code and sources
Code: hpr_core::gravity and hpr_core::earth (what the flight engine
uses). Source: [NGA] NGA.STND.0036_1.0.0_WGS84 (2014), chapter 4 and appendix B, pinned as
wgs84-nga-stnd-0036.
Normal gravity
What normal gravity is, the WGS 84 parameters that define it, and the formulas that compute it.
What normal gravity is
Normal gravity is the gravity of the level ellipsoid: the attraction of the WGS 84 ellipsoid plus the centrifugal acceleration of the Earth’s rotation. It is what a body at rest on the rotating Earth feels.
- In the Earth-fixed launch frame, the only extra inertial term is Coriolis, . Adding a centrifugal term as well would count it twice.
- Normal gravity ignores the real Earth’s gravity anomalies, typically within ±1e-4 relative (±100 mGal). A geopotential model such as EGM2008 is a later option.
Defining parameters and derived constants
The four defining parameters ([NGA] Table 3.1) are:
- is
Everything else is derived from them ([NGA] appendix B). The lines below are, in order, the second eccentricity and eqs. B-18, B-19, B-20, B-24, B-25 and B-26:
Cancellation. The closed forms for and cancel about five digits at . A first version computed with a relative error of 2.6e-11, so it no longer rounded to Table 3.6. Below the code therefore uses the series from
Check. These reproduce the printed values to their last digit:
| quantity | value (m/s², or ratio) | printed in |
|---|---|---|
| 7.334625787083e-5 | eq. B-18 | |
| 2.688041300461e-3 | eq. B-19 | |
| 9.7803253359 m/s² | Table 3.6 | |
| 9.8321849379 m/s² | Table 3.6 | |
| 1.931852652458e-3 | Table 3.6 | |
| 3.449786506841e-3 | Table 3.6 |
Formulas
-
On the ellipsoid (Somigliana, eq. 4-1):
-
As a Taylor series in height (eq. 4-3):
RocketPy uses this form. The reference values in
validation/fixtures/earth/wgs84-normal-gravity.jsongive its error against the exact field. It is 1e-8 relative at 1.4 km (0.87 mi) and 3e-7 at 30 km (19 mi). At 100 km (62 mi) it is 1.4e-5, and at 200 km (124 mi) 1.1e-4. -
For the exact field (eqs. 4-5 to 4-13), ellipsoidal-harmonic coordinates give the components and . The code rotates them into ECEF with (eq. 4-18). Eq. 4-8 is used in the equivalent form
with , which never divides by .
- comes from
atan2, so every quadrant works. - The field is undefined on the focal disc (, the equatorial plane within 522 km (324 mi) of the center). The code returns an error there.
- comes from
-
The local components are in the ENU axes at the point. is the exact normal component (eq. 4-16), and is (eq. 4-23, positive north). The length is (eq. 4-4).
- Above the ellipsoid, the vector tilts slightly toward the equator: in the northern hemisphere, −8.1e-4 m/s² at 45° N and 100 km (62 mi).
- That sign is confirmed independently. The reference script differentiates the normal potential numerically, and its value on the ellipsoid matches Table 3.6’s .
In the flight engine
The gravity models a flight can use, and RocketPy’s formula for like-for-like comparisons.
Gravity models for the flight engine (earth::GravityModel)
| model | vector in | use |
|---|---|---|
constant { g_mps2 } | analytic tests; comparisons with tools that use 9.80665 | |
vertical_taylor | from eq. 4-3 at | like-for-like with RocketPy’s formula (see its flight quirks below) |
vertical | exact at | along the launch vertical |
ellipsoidal (default) | the full vector at the body’s position, rotated into | everything else |
The ellipsoidal model follows the vertical as it turns downrange: by about east-west and north-south, with the meridian radius,
A test checks both at 20 km (12 mi), to 1e-4 east and 1e-3 north (the curvature changes along a
meridian). Earth rotation (earth::EarthRotation) is coriolis by default, with
, or ignore.
STANDARD_GRAVITY_MPS2 = 9.80665 is the conventional (3rd CGPM, 1901; also used by the
U.S. Standard Atmosphere 1976). It is a unit convention, not a model of local gravity. Loft used it
as gravity, which put Loft 0.3% off RocketPy at the equator
(Loft’s lesson on constant gravity).
RocketPy 1.13.0, for like-for-like cases
Recorded by validation/oracles/rocketpy/gravity.py into
validation/fixtures/earth/rocketpy-gravity.json, for
the validation milestone’s RocketPy comparison.
- The formula is Somigliana (4-1) times the Taylor factor (4-3), with Table 3.6 constants
(
rocketpy/environment/environment.py,somigliana_gravity). It matchesNormalGravity::taylor_mps2to under 1e-12 relative. - A flight samples the formula at 100 points between 0 and
max_expected_height(80 km (50 mi) by default). It holds the last value above that. At 45° and 100 km (62 mi) a flight uses 9.563982 m/s², where the formula gives 9.504874. - RocketPy feeds it height above sea level, not above the ellipsoid.
- With no latitude given, the default of 0 gives equatorial gravity.
- Coriolis is included as with , in the 6-DOF and parachute equations but not in the rail phase.
Tests that pin this
gravity::tests::somigliana_matches_published_values(Loft’s lesson on constant gravity, and the done when of the core math, frames and Earth milestone):- Table 3.6 constants to their printed digits.
- At 11 latitude/longitude/height points, including the equator, both poles, launch sites and
heights up to 200 km (124 mi):
- surface (4-1), Taylor (4-3), (4-4) and (4-16) within 1e-6 relative, and in fact within 2e-14 relative;
- and the ECEF vector within 1e-12 m/s².
- The reference values come from
validation/oracles/wgs84/normal_gravity.py. It evaluates the published formulas in 40-digit arithmetic and checks the constants against the tables. It also checks the vector against the gradient of the normal potential.
taylor_series_matches_the_rocketpy_oracle: 8 points against RocketPy’s formula.exact_field_reduces_to_somigliana_on_the_ellipsoid: 37 latitudes, zero horizontal component.q_functions_match_appendix_b: the printed and , and continuity where the series hands over to the closed form.earth::tests: the models agree at the pad; the ellipsoidal model follows the vertical downrange; the Coriolis direction and magnitude.cargo xtask check-cases, held by the gate where the codes’ files are fetched: NASA’s check case 1 against five codes’ published histories of a 4.4 km (2.7 mi) fall, a sixth left out. HPR Sim’s altitude ends 19.51 mm (0.77 in) lower, 137 times the codes’ spread of 0.1424 mm (0.0056 in). The codes’ gravitation stops at , the term for the Earth’s bulge at the equator, and the terms normal gravity holds past it account for 19.50 mm (0.77 in), which leaves at most 0.1364 mm (0.0054 in) of a kept code’s largest difference, inside the spread (a free body against NASA’s check cases). The same terms are part of the traces of cases 6 to 8, the dragged sphere, with each code’s own air.hpr_sim::free_body::tests::the_coriolis_force_lifts_a_long_fall: a body dropped over the equator is carried east at and so ends higher than with the Earth’s rotation off, 7.0 mm (0.28 in) after 30 s; the flown fall matches both within 1%.
The magnetic field and declination
Use the World Magnetic Model’s declination to turn a compass reading at your launch site into the true heading you give HPR Sim.
In short
- What it models: the Earth’s main magnetic field at any place and time from 2025.0 to
2030.0, from the World Magnetic Model (WMM2025). Its most useful output is the
declination: the angle between true north and the north a compass shows. Nothing in HPR Sim
applies it for you. A rail’s heading (
hpr sim --heading, the builder’sheading_deg) is a true bearing. Add the declination to a compass reading first (A worked example shows how). - Sources: A. Chulliat, W. Brown, M. Nair and others, The US/UK World Magnetic Model for
2025–2030: Technical Report, NOAA NCEI (2025). With it, NCEI’s coefficient file
WMM2025.COF, which NCEI places in the public domain. - How well it is validated: the simulator reproduces all 12 of the report’s test points (its Table 6) to their last printed digit. Declination is held to 0.005°. NCEI’s file of 100 points is printed to 1e-6 nT and angles to 0.01°. It matches to its last digit in declination, inclination, the east component and four rates. Its north component differs at 97 points, by up to 7.18e-4 nT (2.11e-8 of the total field). The horizontal and total intensities differ with it. An independent check in the tests does not use HPR Sim’s derivative formula. It places that difference in NCEI’s file, not in HPR Sim (The test values). That shows the model is computed correctly. The model itself is only as good as the Earth allows. Its own error estimate for declination is 0.29° at best and 0.35° to 0.56° at the example’s sites, more near the magnetic poles. Each result carries that estimate.
- What it leaves out: local magnetic rocks, magnetic storms and the steel near a compass. Dates outside 2025.0 to 2030.0 are refused, and so are heights below −1 km (−0.62 mi) or above 850 km (528 mi) (Limits).
Sources
Code: hpr_core::magnetic. Conventions:
Frames and Geodesy. Each source below is pinned by its checksum in the
reference library (validation/refs.lock.toml),
under the name given. DLMF is a web reference.
- [WMM] A. Chulliat, W. Brown, M. Nair, N. Gomez Perez, L.-Y. Young, C. Watson, N. Boneh,
C. Beggan, B. Meyer and M. Paniccia. The US/UK World Magnetic Model for 2025–2030: Technical
Report. National Centers for Environmental Information, NOAA, 2025,
https://doi.org/10.25923/prbc-s316. Section 1.2 gives the equations, 1.4 the poles, 1.8 the
blackout zones, 3.4 the error model. Pinned as
wmm2025-report. - [COF] NCEI,
WMM2025COF.zip(December 17, 2024): the coefficient fileWMM2025.COFand the test valuesWMM2025_TestValues.txt, committed unchanged incrates/hpr-core/data/wmm2025/, with the report’s Table 6 asWMM2025_TEST_VALUES.txt. Pinned aswmm2025-coefficients, and Table 6 aswmm2025-test-values. - [DLMF] NIST Digital Library of Mathematical Functions, equation 14.10.3: the recurrence used for the Legendre functions.
Declination
What declination is, how the World Magnetic Model computes it, and a worked example.
What declination is
A compass needle lines up with the horizontal part of the Earth’s magnetic field. That points to magnetic north, which is not true north (the direction of the North Pole along the ground). The angle from true north to magnetic north is the declination . It is positive when magnetic north is east of true north.
So a bearing read off a compass becomes a true bearing by adding the declination:
At Spaceport America in mid-2026, is +7.75°: a rail aimed at a compass’s north points 7.75° east of true north. The simulator’s flight engine takes headings as true bearings, clockwise from true north (Frames). So a heading measured with a compass needs this correction first.
The field also dips into the ground. The field’s inclination (not the rail’s inclination) is that dip, positive downward. It is about 60° across the southern United States, and 90° at a magnetic pole, where a compass has nothing horizontal to follow.
Field strengths are in nanoteslas (nT). The Earth’s field is 20,000 to 70,000 nT at the surface.
The model
The WMM writes the field as a sum of spherical harmonics: patterns over the globe that get finer as their degree rises. The degree runs from 1 (one north and one south pole, like a bar magnet) to 12. Each degree is split into orders from 0 to . That makes 90 terms.
Each term has two Gauss coefficients, and in nT ( is zero where ), which set how strong the pattern is. Each coefficient changes linearly in time from its 2025.0 value, at the rate or ([WMM] eq. 9):
where is the decimal year (2026.5 is the middle of 2026). The simulator computes the field the way [WMM] section 1.2 sets out:
-
The site’s latitude , longitude and height above the WGS 84 ellipsoid become geocentric coordinates (eqs. 7, 8). They are a radius and a geocentric latitude , the angle seen from the Earth’s center.
-
There the field has three parts (eqs. 10 to 12): north , east and down . Each is a sum over degree and order , with :
are the Schmidt semi-normalized associated Legendre functions ([WMM] eq. 5).
-
The parts turn into the local frame (eq. 17) by the angle between the two latitudes. That gives , , in the site’s north, east and down directions.
-
The elements follow (eq. 19): horizontal intensity , total intensity , inclination and declination .
The same sums over the coefficients’ rates and give how fast each part changes per year
(eqs. 13 to 15, 18 and 20). Rates are written with a dot: , and so on (dD in the
example).
Two details differ from the report’s printed text, and NOAA’s test values settle both:
- Equation 11 and the derivative in equation 16 divide by , which is zero at a pole. The simulator writes each function as times a polynomial in , so the division cancels exactly. The field at a pole is the limit along the meridian given ([WMM] section 1.4). A test checks the report’s printed field over each pole.
- Equation 15 prints the rate of with . The potential gives , as in equation 12, and only reproduces NOAA’s rates.
Grid variation
Near the geographic poles, declination swings with every step east or west. So polar navigators
use grid variation instead ([WMM] eq. 1). It is the angle from a map grid’s north, that of the
polar stereographic grid (Table 6’s note), to magnetic north. It is north of 55° N, and
south of 55° S. Elsewhere the simulator gives none (None), as the test values print NaN.
How far a compass can be trusted
The report marks a blackout zone around each magnetic pole, where the horizontal intensity is under 2,000 nT. There declination can be wrong by up to 180°. Around it is a caution zone, under 6,000 nT, where declination errors exceed 1° ([WMM] section 1.8).
MagneticField::compass_zone says which applies: Reliable, Caution or Blackout. The report
draws the zones on the ground. The simulator uses the field at the height asked, which is a little
weaker higher up, so its zones there are a little wider.
The report’s error model ([WMM] eq. 43) gives the declination’s expected error, one standard deviation, in degrees, with in nT:
That is 0.29° where the horizontal field is strongest and grows without bound toward a magnetic
pole. MagneticField::declination_uncertainty_rad returns it. It covers the coefficients’
errors, the drift of the forecast to 2030, local rocks the model leaves out, and magnetic storms.
It does not cover a steel rail, a car or a motor case beside the compass.
A worked example
The example program
crates/hpr/examples/declination.rs
asks for the field at four launch sites on 20 June 2026. It turns the date into a decimal year
with decimal_year (the start of that day, 2026 + 170/365). Then it calls WMM2025.field with
each site’s latitude, longitude and height above the ellipsoid. Run it from a copy of the repository
with cargo run --example declination -p fusionspace-hpr. It prints:
WMM-2025 on 2026-06-20 (decimal year 2026.4658)
site D (°) ± (°) dD (°/yr) I (°) F (nT) GV (°) zone
Spaceport America, New Mexico 7.75 0.35 -0.076 59.89 46981 - Reliable
Black Rock Desert, Nevada 12.85 0.36 -0.096 64.24 49646 - Reliable
Lucerne Dry Lake, California 11.16 0.35 -0.079 59.38 46407 - Reliable
Andøya, Norway 9.41 0.56 0.268 78.16 53674 -6.61 Reliable
At Spaceport America, New Mexico, a rail aimed at magnetic north points 7.75° east of true north.
± is the model’s own error estimate, dD the declination’s drift per year, GV the grid
variation (only at Andøya, north of 55°). The drift is small: Spaceport America’s declination
falls by about 0.08° a year, so it moves well under a degree over the model’s five years.
Tests and limits
The model’s checks, and where it stops applying.
The test values
| check | points | what is compared | worst difference | held to |
|---|---|---|---|---|
| the coefficient table | 90 rows | every coefficient against WMM2025.COF | none | equal |
| the report’s Table 6 | 12 | , , , , , their rates; , , grid variation, their rates | half the last digit | 0.05 nT, 0.005° |
| the report’s Table 3b | 1 | , , the coefficients, , , , … , printed to 10 decimals | 5.0e-11 nT on | half the last digit, plus 8 units in the last place |
| the report’s poles (section 1.4) | 2 | , , over each pole at | inside 0.05 nT | 0.05 nT |
| NCEI’s high-precision file, printed to 1e-6 nT and angles to 0.01° | 100 | , , , and the rates of , , , | half the last digit | 5e-7 nT, 0.005° |
| the same file | 100 | , , | 7.18e-4 nT | 7.2e-4 nT, the measured worst |
| the same file | 100 | ; the rates of , , | 2.2e-6 nT; 1.5e-6 nT/yr | the measured worst |
| the potential, by differences | 100 | HPR Sim’s and | 1.3e-7 nT; within the rounding allowance (under 1e-9 nT/yr) | 1e-6 nT; 1e-6 nT/yr |
Rows are counted from 0. The north component in NCEI’s file differs from HPR Sim’s at 97 of its 100 points. The largest is 7.18e-4 nT (row 35: 2026.5, 12 km (7.5 mi), 33° N, 145° W). That is at most 2.11e-8 of the total field. It is 140 times smaller than the 0.1 nT the report allows for single precision (the note under its Table 6).
The tests show where the difference comes from:
- It lies in one quantity, the geocentric . If the file’s is off by an amount , its moves by and its by . Taking from each point’s and applying it to brings the file’s to within 4.9e-7 nT of HPR Sim’s, inside its printing.
- HPR Sim’s is right. The tests take the potential’s derivative in latitude by differences, independently of HPR Sim’s formula for it. HPR Sim’s matches that to 1.3e-7 nT at all 100 points. The report’s own ten-decimal (Table 3b) matches to 5e-11 nT.
- A second program agrees with HPR Sim: pygeomag 1.1.0 (MIT), a port of NOAA’s own
geomagprogram. Run once by hand on two of the points (rows 3 and 35, not in CI), it gives HPR Sim’s to 7e-7 nT. So it differs from the file by the same amount.
The rate of differs too, by up to 9.5e-7 nT a year at 24 points: a second, smaller residue whose cause is not known. HPR Sim’s passes the same derivative check. The rates of and follow from and its rate.
So the file’s , , and are held to the measured differences, not to the file’s printing. So are the rates of , and . The WMM2025 decision records the choice. For a flight the difference is immaterial: 7.18e-4 nT turns the declination by about a millionth of a degree.
Every comparison with Table 6 and NCEI’s file first allows 64 units in the last place of the point’s total field, about 7e-10 nT. The allowance covers the rounding in both programs’ sums and is about 700 times below half the finest printed digit.
A property test also checks, at random places and times, that , , and agree with , , by their definitions. At the same places and times it checks that lies between 20,000 and 70,000 nT. The report’s Table 1 rounds the surface range to 23,000 to 67,000 nT. But the model itself falls to about 21,900 nT over South America by 2030, which a test pins at 26° S, 61° W.
Limits
- WMM2025 covers only five years, 2025.0 to 2030.0. A flight log from 2024 needs WMM2020, which the simulator does not bundle. Such a date is refused, not extrapolated.
- The model is specified from −1 km (−0.62 mi) to 850 km (528 mi) above the WGS 84 ellipsoid ([WMM] section 3). Outside that, a height is refused.
- Heights are above the WGS 84 ellipsoid, as
Geodeticholds them. A site’s height above sea level (from a map, a GPS or an altimeter) differs by the geoid, up to about 100 m (328 ft). The report puts that effect at about 1 nT or less, far below the model’s error. So a height above sea level can be used as it is. - The WMM models the main field only. It leaves out the crust’s local fields, which can move a compass by degrees near iron ore or volcanic rock. It also leaves out the fields of magnetic storms. The error estimate allows for them as a worldwide average, but at any one site they can be larger.
- Nothing in a flight uses it yet. Converting a compass heading is the caller’s step, with
MagneticField::true_from_magnetic_rad.
Atmosphere
Learn how HPR Sim builds the air at each height from a standard atmosphere, field conditions or a sounding, and what an altimeter reads.
In short
- What it models: the air’s temperature, pressure, density, speed of sound and viscosity by height. It covers the 1976 U.S. Standard Atmosphere, optionally shifted to field conditions, humid air, and weather-balloon soundings or forecasts. It also gives the pressure altitude a barometric altimeter reads.
- Sources: the U.S. Standard Atmosphere, 1976; the WMO’s Guide to Instruments and Methods of Observation (WMO-No. 8, 2023); the CIPM-2007 moist-air density formula (Picard et al., 2008).
- How well it is validated: every value within 0.1% of the 1976 tables at 32 altitudes from −2 to 86 km (−1.2 to 53 mi). Humid density is within 0.047% of CIPM-2007 over 15–27 °C. Against RocketPy, its density agrees within 3.7e-4 over the 23 heights its parachute descents sample (Recovery). Its pressure altitude matches two flight logs’ own altimeter readings of their pressure, to 0.195 m (0.64 ft) and 1.321 m (4.33 ft) (report). The air itself has no real-flight check.
- What it leaves out: a real day’s changes aloft. A field-condition offset holds all the way up, so higher flights need a sounding. An offset of +20 K at a 1,400 m (4,593 ft) field puts density +30% off the standard’s at 30 km (19 mi). Viscosity ignores humidity, which lowers it 2.1% at 30 °C and saturation.
Code and sources
Code: hpr_atmos::ussa76 (the standard and its offsets), hpr_atmos::moist (humid air),
hpr_atmos::profile (soundings and forecasts), and the Atmosphere trait in hpr_atmos::air.
Sources:
- [USSA] U.S. Standard Atmosphere, 1976,
NOAA-S/T 76-1562, part 1, pinned asus-std-atmosphere-1976. Equation, table and page numbers below are its own. - [WMO] WMO-No. 8, Guide to Instruments and Methods of Observation, Vol. I (2023),
wmo-no8-vol1-2023. - [CIPM] A. Picard et al., “Revised formula for the density of moist air (CIPM-2007)”,
Metrologia 45 (2008) 149–155,
picard-2008-cipm-2007.
The standard atmosphere
The height datum, the 1976 standard, offsets for a site’s conditions, and pressure altitude.
Height datum
Every atmosphere is queried with geometric height above mean sea level (height_msl_m). The
core’s heights are ellipsoidal (Frames), so the flight engine subtracts the geoid undulation
first: . Samples carry an extrapolated flag, set whenever a model answers outside
the range it is defined or tabulated over.
The 1976 standard, −5 km (−3.1 mi) to 86 km (53 mi)
Seven layers in geopotential altitude , the last ending at 84.852 geopotential km (52.72 mi), each with a constant gradient of the molecular-scale temperature ([USSA] Table 4):
| base (km′) | gradient (K/km′) |
|---|---|
| 0 | −6.5 |
| 11 | 0 |
| 20 | +1.0 |
| 32 | +2.8 |
| 47 | 0 |
| 51 | −2.8 |
| 71 | −2.0 |
Eq. (18) gives the geopotential altitude from the geometric altitude , with the Earth’s effective radius (below). Eq. (23) gives the temperature from the layer’s base values and :
Pressure follows eq. (33a) where and eq. (33b) where , with the exponent :
Then eqs. (42), (22), (50), (51) and (52):
- The constants:
- is (p. 3), not CODATA’s . Table 2 misprints the exponent’s sign.
- , , .
- , , , .
- (p. 19). Table 2 and p. 4 print 110 K, but the tables use 110.4 K: sea-level is 1.7894e-5 Pa·s with it and 1.7912e-5 with 110.
- From 80 to 86 km (50 to 53 mi), comes from Table 8, interpolated linearly in . The printed tables leave it out below 86 km (53 mi) and print (p. 9). This model follows the equations, so its kinetic temperature there is up to 0.036%, and its viscosity up to 0.031%, below the print.
- Below −5 km (−3.1 mi) the first layer continues. Above 86 km (53 mi) the atmosphere is isothermal at 186.87 K. Both are flagged. The real standard is also isothermal from 86 to 91 km (53 to 57 mi), then warms. Its composition changes above 86 km (53 mi). Pressure and density there are rough, but tiny.
- Loft got this wrong (Loft lessons L2 to L4):
- It fed geometric altitude to geopotential formulas. At 11 km (6.8 mi) it gave 216.65 K and 22 632 Pa, against 216.774 K and 22 699.96 Pa.
- It had only four layers, so at 70 km (43 mi) it gave 335 K against 219.6 K.
- Its Sutherland constants gave a sea-level viscosity 1.3% high.
Offsets and launch-site conditions
Ussa76::with_offset(ΔT, P₀) adds to at every geopotential height and integrates eqs.
33a/33b from , so the atmosphere stays hydrostatic. Ussa76::anchored(Z, T, P) picks and
so the profile passes through a measured temperature and pressure, such as field conditions.
This is not the aviation convention (ESDU 77022), which offsets temperature at equal pressure
altitude. Both are hydrostatic, but they differ aloft. At with , the
aviation convention gives 289.95 K where this gives 288.65 K, and densities 0.38% apart
(validation/oracles/atmosphere/conventions.py). This choice keeps the lapse rate attached to
height, like a sounding; see the atmosphere decision.
An anchor’s offset holds all the way up, which a real hot or cold day doesn’t. Anchoring
+20 K at a 1,400 m (4,593 ft) field, at the standard’s pressure there, gives these densities against the
standard (conventions.py):
| height | density against the standard |
|---|---|
| 3 km (1.9 mi) | −5.7% |
| 20 km (12 mi) | +14% |
| 30 km (19 mi) | +30% |
Field conditions suit flights of a few kilometers; higher flights need a sounding.
Pressure altitude: what a barometric altimeter reads
A barometric altimeter measures pressure, not height. It
turns the pressure into the height at which the 1976 standard has that pressure, its pressure
altitude, and subtracts the pad’s. Ussa76::pressure_altitude_m(P) computes the same number,
so HPR Sim can read its own flight the way a logged flight was read
(Accuracy: real flights).
It inverts eqs. 33a and 33b in the layer whose base pressures bracket . The first line below is for , the second for , and is the exponent above:
In the standard’s troposphere this is the altimeter formula
The result is in geopotential meters, m′, as an altimeter’s is.
A worked example. An altimeter on a pad at 86,000 Pa reads 1,361.8 m (4,468 ft)′ there. At 58,000 Pa it reads 4,464.4 m (14,647 ft)′, so it logs a climb of 3,102.6 m (10,179 ft)′. Now make the day 20 K warmer than the standard all the way up, with the same sea-level pressure. The same two pressures then lie 3,318.0 m (10,886 ft)′ apart. The rocket climbed 6.9% more than its altimeter says, and the altimeter reads 6.5% less than the climb. Warm air is less dense, so pressure falls more slowly with height. In the troposphere, with the sea-level pressure unchanged, the ratio is exactly .
Where it is used. The simulator’s flights don’t use it: they fly in the air of the day. The
real-flight comparison reads the simulator’s height through it when the log is barometric
(hpr_validate::real_flight::Barometer). It takes the ERA5 pressure at the center of mass. Two logs
record their pressure, Prometheus’s and Juno III’s. Over the rows compared, their height column is
this reading less the first row’s, to 0.195 m (0.64 ft) and 1.321 m (4.33 ft)
(report).
Moist air and weather
Humid air, and profiles built from a sounding or a forecast.
Moist air
An ideal mixture of dry air (, ) and water vapor (, [CIPM] §2.1). The first line is [WMO] Annex 4.B, eq. 4.B.1, in hPa with in °C. The density’s second form is [WMO] eq. 12.18:
- Relative humidity is taken with respect to liquid water at every temperature, as radiosondes report it ([WMO] §12.1.2). No enhancement factor is applied. Near the surface it would raise by about 0.47%. That changes density by at most 0.013% (at 40 °C and saturation), and less in cooler or drier air.
- The moist-air model’s accuracy:
- Density agrees with CIPM-2007 (a real-gas equation) to 0.047% over its range: 15–27 °C, 600–1,100 hPa, dry to saturated. Ignoring humidity entirely is 0.4% off at 20 °C and 50% RH.
- Water vapor’s is taken as , and its real value near 300 K is about 1% higher. That moves by 0.009% at 30 °C and saturation.
- Viscosity stays dry air’s Sutherland value. By Wilke’s rule with IAPWS R12-08 vapor viscosity, saturation at 30 °C lowers it 2.1%, which moves turbulent skin friction about 0.4%.
- All these numbers come from
validation/oracles/atmosphere/moist_air.py.
Sounding and forecast profiles
SoundingProfile takes the site’s latitude and levels of geometric height, temperature, optional
pressure, optional relative humidity, and optional wind speed and direction. Humidity and wind
are given on every level or on none. A given pressure must be below the level beneath it, which
catches hPa entered as Pa.
- The profile works in WMO geopotential height ([WMO] eqs. 12.15–12.16). Its
gravity is the normal gravity at the site’s latitude.
- Surface gravity runs from 9.780 m/s² at the equator to 9.832 m/s² at the poles, ±0.27% around the standard’s .
- Over 2 km (1.2 mi) at 293 K the same sounding’s pressure falls 0.12% more at the pole than at the equator.
- A latitude-free geopotential would leave errors of that size.
- Between levels, interpolation runs in :
-
and are linear in .
-
Pressure uses
which is exact for a dry hydrostatic layer with linear in and passes through both levels’ pressures.
-
Levels sampled from the standard at its geopotential levels reproduce it between them to 1e-12, at any latitude.
-
- Missing pressures above the lowest level are filled hydrostatically, with virtual
temperature linear in ([WMO] eqs. 12.17–12.18).
- A dry fill agrees with direct integration under WGS 84 normal gravity to 2e-8. The limit is WMO’s rounded surface gravity constants, 3–5e-8 low.
- A humid fill agrees to 1.1e-5, because vapor pressure is exponential in and so not quite linear across the layer.
- Beyond the levels, the profile continues as the standard atmosphere anchored at the end
level, and flags the sample. It evaluates the standard at the same geopotential, so still with
the local gravity.
- Below, it holds relative humidity.
- Above, it holds the vapor mole fraction, capped at saturation, so a humid top doesn’t carry water into the cold stratosphere.
- The continued pressure is the dry standard’s. It is hydrostatic for dry air. In humid air it falls up to faster (1.6% of the gradient at 30 °C and saturation).
- Soundings (Wyoming’s
HGHT) and forecasts (Open-Meteo’sgeopotential_height) report geopotential meters above sea level. Convert them withgeometric_from_wmo_geopotential_m. At 30 km (19 mi) that is 29.932 km (18.60 mi) of geopotential at 80° N and 29.7785 km (18.504 mi) at the equator. The standard’s latitude-free formula is only for the standard itself. - From an ERA5 file,
hpr_io::era5builds this profile over a launch site at launch time from the day’s reanalysis; see ERA5 weather files. - From Open-Meteo,
hpr_net::open_meteobuilds it from a forecast, or an archived one, on pressure levels; see Launch-day weather. - From a weather balloon,
hpr_net::wyomingbuilds it from a radiosonde’s sounding in the University of Wyoming’s archive; see Weather-balloon soundings. - Loft’s “today’s conditions” kept the standard lapse from the field up, ignored humidity and never used sounding temperatures (Loft lesson L5).
Comparison and tests
Notes on RocketPy’s atmosphere for the code-to-code comparison, and the tests that pin this one.
RocketPy 1.13.0, for the code-to-code comparison
These are findings from reading refs/rocketpy for the RocketPy comparison of
the validation milestone, not yet pinned by fixtures:
- Its standard atmosphere has ISO 2533 layers from −2 to 80 km (−1.2 to 50 mi), with (the same as ). Temperature is linear in geometric height between converted layer boundaries. Pressure is sampled at 100 points and splined.
- In its custom profiles:
- Every quantity, pressure included, is linear in height above sea level, with constant extrapolation.
- Linear pressure is off hydrostatic by up to 0.06% between 1,000 and 925 hPa, and 1.15%
between 700 and 500 hPa (
conventions.py). Between 50 and 30 hPa it is up to 3.4% off (conventions.py). - Those comparisons need a RocketPy-compatible option or levels dense enough that this doesn’t matter.
- Humidity is not used anywhere.
- Wyoming heights are converted from geopotential with a radius only (no latitude).
- The helper’s default radius, 63,781,370 m (39,632 mi) in
rocketpy/tools.py:972, is ten times the Earth’s. - Check which callers rely on that default before those comparisons.
- The helper’s default radius, 63,781,370 m (39,632 mi) in
Tests that pin this
ussa76::tests::matches_the_1976_tables_at_32_altitudesis the done when of the atmosphere and wind milestone:- It covers , , , , , , and at 32 altitudes from −2 to 86 km (−1.2 to 53 mi).
- Every value is within 0.1%, and within one count of its last printed digit.
- The exceptions to the last-digit match are those above (80–85.5 km (50–53 mi), where the printed equals ). The 84 km (52 mi) density is another. It prints 9.6940E-6 where the equations give 9.69387e-6; the row’s own agrees with the equations.
- The fixture was transcribed from the page images and cross-checked by
validation/oracles/ussa76/tables.pyagainst mpmath andambiance.
- The Loft lessons:
geometric_11_km_matches_the_1976_tables(Loft lesson L2)fifty_km_is_270_65_k_and_79_779_pa(Loft lesson L3)sea_level_viscosity_is_1_7894e_5(Loft lesson L4)profile::tests::sounding_temperature_overrides_standard_lapse(Loft lesson L5)
- For pressure altitude:
pressure_altitude_inverts_the_1976_tables: each printed pressure’s altitude is the printed geopotential altitude at all 32 rows, to what the prints resolve.pressure_altitude_is_the_altimeter_formula_in_the_troposphere, and its refusals.pressure_altitude_inverts_the_pressure: a property test over offsets and heights, the extrapolated layers included.
- For the constants and the structure:
constants_match_the_transcriptionchecks the constants and Tables 4 and 8.- Hydrostatic balance is checked in every layer, and as a property test over offsets.
- Anchors reproduce their conditions, and layers join continuously.
moist::tests:- WMO 4.B.1 against the formula evaluated separately in mpmath (WMO prints no table of it).
- Dry air equals the standard.
- CIPM-2007 density to 0.05% at 36 points.
profile::tests:- Standard levels are reproduced at 0°, 45° and 80°.
- Dry fills at 0°, 33° and 90°, and a humid fill, match direct integration under WGS 84 normal gravity.
- Pressure falls faster at the pole.
- The continuation beyond the levels is hydrostatic when dry, with the humid shortfall pinned.
- WMO geopotential values.
- Errors (including rising pressures) and serde.
Wind
Set the steady wind a flight sees at each height: constant, grown from a single measured wind, or read from a forecast’s table of levels.
In short
- What it models: the steady wind’s speed and direction at each height. The wind can be constant, or grow with height from one measured wind (a power or log law). It can also come from a table of levels, such as a forecast.
- Sources: the US military flying-qualities specification MIL-F-8785C (1980), NASA’s climatic criteria for aerospace vehicles NASA/TM-2008-215633 (2008), and the World Meteorological Organization’s observing guide WMO-No. 8 (2023).
- How well it is validated: tests with exact answers pin each model. By default a table interpolates speed and direction separately. Halfway between 4 m/s (13 ft/s) from 350° and 12 m/s (39 ft/s) from 30°, it gives 8 m/s (26 ft/s) from 10°. In RocketPy’s parachute descents, HPR Sim’s wind is interpolated by components, as RocketPy does. It matches RocketPy’s samples to 1e-9 m/s (in scientific notation: a billionth of a meter per second). That includes the wind of NDRT 2020, one of the example rockets, which changes with height. In the four descents with wind, the total drift agrees within 0.28%, and each east or north part within 2.9% (Recovery). Ten real flights have been flown in ERA5 winds, nine of them in their own day’s. Only their heights are compared, not their drift (Accuracy: real flights).
- What it leaves out: wind varying in time or across the field, vertical wind, terrain, and gusts (no flight uses Turbulence). A flight takes one wind model, so a power or log law, which keeps growing with height, can’t hand over to winds aloft.
Sources and conventions
Where the code and its sources are, and the conventions every wind model follows.
Code and sources
Code: hpr_atmos::wind in the API reference. Random gusts on
top of the steady wind are in Turbulence. The example program under
An example of each builds every model.
Sources. Checking a claim explains how to fetch and check each one. Each is pinned under the id given, in the reference lock file, which records where to download it and its SHA-256 hash:
- [8785C] MIL-F-8785C, Flying Qualities of Piloted Airplanes (1980), §3.7.3.2, pinned as
mil-f-8785c. - [TM] NASA/TM-2008-215633, Terrestrial Environment (Climatic) Criteria Guidelines for Use
in Aerospace Vehicle Development (2008), §2.2.5.2 and Table 2-21,
nasa-tm-2008-215633. - [WMO] WMO-No. 8 (2023), Vol. I, chapter 5 and its annex,
wmo-no8-vol1-2023.
Conventions
- A wind model returns the velocity of the air, in m/s, along the east, north and up axes of the launch frame. The flight engine’s airspeed is the rocket’s velocity minus this. Mean wind (the steady wind, without gusts) is horizontal, so its up part is zero.
- The direction is meteorological: the direction the wind blows from, clockwise from true north, in radians. For a wind of speed from direction , the east and north parts are and . A wind from the west (, 270°) blows toward the east, . RocketPy’s heading is the direction the wind blows toward, .
- A flight asks every model for the wind at a height above mean sea level, as it asks the atmosphere. Some models are built from heights above the ground instead: Which height? says which.
- Each answer a wind model gives carries a flag, which is set when the height is outside what
the model covers. That is below a table’s lowest level or above its highest, or
below the ground for a power or log law.
- The model still answers: a table holds its end level’s wind, and a law gives calm below the ground. The flag says that the answer was filled in, not taken from the model’s data.
- In code it is the answer’s
extrapolatedfield:Nonenormally, andSome(Side::Below)orSome(Side::Above)when flagged. - The power and log laws are not flagged high above the ground, although they describe only the air near it.
- A flight doesn’t read the flag yet (issue #45). A rocket that climbs above a table’s top level flies on the held wind, and nothing in its result says so. Ask the model yourself before flying a table, as the example does: it marks each flagged answer with a star.
Wind models
The wind laws, which height each input is measured from, and an example program that builds each one.
Models
In the laws below, is the wind speed at height above the ground. is the speed measured at a reference height above the ground, such as the 10 m (33 ft) mast of a weather station. Each law blows from one direction at every height.
-
ConstantWind: one velocity at every height. -
PowerLawWind: the speed grows as a power of height, for , and is zero at and below the ground. A height below the ground is flagged.- is the exponent: the larger it is, the faster the wind grows with height.
- [TM] eq. 2.1 gives the law for peak winds below 150 m (492 ft), with . A peak wind is the strongest speed over a period, gusts included, not the steady mean wind the simulator flies.
- [TM] Table 2-1: for 7–22 m/s (23–72 ft/s) and 0.14 above 22 m/s (72 ft/s). Eq. 2.22 gives with for strong 10 m (33 ft) winds.
- Those exponents describe profiles of peak winds, and of strong 10 m (33 ft) winds. No single value fits mean winds everywhere, so treat any exponent as a starting point, not a measurement of your field.
- The example uses (about 0.14) with a 10 m (33 ft) reference height, the pairing of [TM] eq. 2.22. Its power law column shows what that does to a 5.0 m/s (16 ft/s) wind at 10 m (33 ft). The wind is 4.0 m/s (13 ft/s) at 2 m (6.6 ft) and 6.9 m/s (23 ft/s) at 100 m (328 ft). At 2,000 m (6,562 ft) it is 10.7 m/s (35 ft/s), and still growing.
- The law describes the surface layer, the air nearest the ground. There friction with the ground sets how fast the wind grows with height ([TM] fits it below 150 m (492 ft)). Above that layer the law keeps growing, so pair it with measured winds aloft.
-
LogLawWind: the speed grows with the logarithm of height,for , and is zero from the ground up to .
- is the roughness length: the height at which the law’s wind falls to zero. It is set by how rough the ground is (see the values below).
- This is the neutral surface-layer law ([WMO] ch. 5 annex; [TM] eq. 2.8 with ), written through a reference wind. There is the friction velocity, a speed that measures how hard the wind drags on the ground. The von Kármán constant is a fixed number of the theory. Writing the law through the wind measured at cancels both, so the simulator needs neither.
- in [TM] eq. 2.8 corrects for the air’s stability. Air warmed from below mixes more, and air cooled from below mixes less, which changes how the wind grows with height. is neutral air, where neither happens. The simulator has only the neutral law.
- [8785C] §3.7.3.2 uses it with .
- [WMO] gives a roughness length of 0.03 m (0.098 ft) for open flat terrain with grass. That is class 3 of the Davenport-Wieringa classification there, which gives a roughness length for each kind of terrain. [TM] Table 2-21 gives 0.001–0.01 m (0.0033–0.033 ft) for mown grass and 0.01–0.04 m (0.033–0.13 ft) for low grass or steppe.
-
LayeredWind: speed and direction tabulated at heights, as from a sounding or a forecast. Between levels it interpolates in one of two ways, set byWindInterpolation.SpeedDirection(the default) interpolates speed linearly and turns the direction along the shorter arc. Between exactly opposite directions it turns clockwise with height. A turning wind keeps its speed.- With
SpeedDirection, a calm level (speed 0) takes the other level’s direction, because reports give calm as “0 from 0°”. Without that rule a wind growing out of calm would swing through a meaningless direction and create a crosswind neither level has. - A near-calm level that isn’t exactly 0 still turns the direction (issue #8). Take 0.1 m/s (0.33 ft/s) from 0° under 10 m/s (33 ft/s) from 270°. At the midpoint that gives (3.57, −3.57) m/s: 3.57 m/s (11.7 ft/s) blowing south. The levels blow 0.1 m/s (0.33 ft/s) and nothing that way. Where the other levels share one direction the swing likely shortens the drift. Where they turn it can lengthen it. A flight through such a span warns of it (the flight-path warnings). The warning is for a level at or below 1.5 m/s (4.9 ft/s) turning by any angle against its neighbor. 1.5 m/s (4.9 ft/s) is the top of Beaufort force 1, light air. Force 1 spans 0.3 to 1.5 m/s (0.98 to 4.9 ft/s) in MeteoSwiss’s Beaufort table, and 1 to 3 knots in the Met Office’s scale. Light air’s direction is “shown by smoke drift, but not by wind vanes” in the Hong Kong Observatory’s land criteria.
Componentsinterpolates the east and north parts linearly, as RocketPy does. Between levels 90° apart the speed dips by up to 29%.- Beyond the end levels the end wind is held and the sample is flagged.
- Put the surface wind (for example the 10 m (33 ft) observation) in as the lowest level, so the profile blends up from it.
-
WindModel: any one of the four, as a flight or a file takes it. In JSON itsmodelfield names which one (In JSON).
Loft, the project before FusionSpace HPR, got this wrong (Loft lesson L6). Its design-file runs used one wind vector, and its forecast profiles stepped at the lowest level instead of blending from the surface.
Which height?
A flight asks the wind model for the wind at the rocket’s
height above mean sea level. The laws are written in
height above the ground, so they take the ground’s height above sea level as well. Each input’s
name says which height it is: _msl_ is above mean sea level, and _agl_ is above the ground
(AGL).
| Model | Heights you give it | Measured from |
|---|---|---|
ConstantWind | none: the same wind at every height | n/a |
PowerLawWind | the reference height, reference_height_agl_m | the ground |
the ground’s height, ground_msl_m | sea level | |
LogLawWind | the reference height, reference_height_agl_m, and the roughness length, roughness_length_m | the ground |
the ground’s height, ground_msl_m | sea level | |
LayeredWind | each level’s height_msl_m | sea level |
A sounding’s wind (SoundingProfile) | each level’s height_msl_m | sea level |
So a table’s levels, from a forecast or a sounding, are above sea level. At a site 1,400 m (4,593 ft) above sea level, a forecast’s 10 m (33 ft) wind goes in at 1,410 m (4,626 ft). Entered at 10 m (33 ft) instead, the whole profile sits 1,400 m (4,593 ft) too low. The example’s last column shows what the flight would then see. Near the pad it sees 11.6 m/s (38 ft/s) from 298° instead of 5.0 m/s (16 ft/s) from 270°. From 100 m (328 ft) up it sees the top level’s 12.0 m/s (39 ft/s) from 300°. Above that, every sample is flagged as beyond the table, which is the sign to look for.
What to enter for your field’s elevation. The launch site’s height is the third number in
Geodetic::from_degrees(latitude, longitude, height). It is an
ellipsoidal height: height above the
WGS 84 ellipsoid, the smooth shape the simulator gives the Earth. A field’s
elevation, as a map gives it, is height above sea level instead. The two differ by the geoid
undulation , the height of sea level above the ellipsoid at that place. can be up to
about 100 m (328 ft). The simulator has no map of , so there are two ways to set up a site:
- The simple way, which the examples take. Enter your field’s elevation above sea level as
the site’s height, and leave at 0, as
Environment::standardsets it. The air and the wind are then looked up at the right heights above sea level. What is off is the height above the ellipsoid, by your field’s . A flight uses that only to work out gravity, which changes by about 0.003% over 100 m (328 ft) of height. - The exact way, if you know at your field. Enter the elevation plus as the site’s
height, and give the environment with
with_geoid_undulation_m(Environment).
Either way, the ground is the site’s height_m less the environment’s geoid_undulation_m above
sea level, which is how the example works it out. A power or log law needs that number as its
ground_msl_m, and doesn’t take it from the site by itself. If its ground_msl_m is wrong, its
whole profile is shifted up or down by the error.
Three more things to watch:
- Soundings and forecasts often give heights in geopotential meters above sea level, not
geometric meters (the meters a tape measure would give).
- A geopotential meter measures height by the work done lifting a mass against gravity. It is the climb that takes as much work as one meter does where gravity is 9.80665 m/s².
- Gravity varies with height and latitude, so the two differ by an amount that depends on both. 30 km (19 mi) above sea level is 29.7785 km (18.504 mi) of geopotential at the equator and 29.932 km (18.60 mi) at 80° N.
- Convert them first with
geometric_from_wmo_geopotential_m(Atmosphere explains).
- A sounding’s wind is a
LayeredWind(SoundingProfile::wind). A flight flies it only if you also pass it towith_wind: the atmosphere and the wind are separate parts ofEnvironment. - A table flags a height below or above its levels, and a law flags one below the ground. Conventions says how to read a flag. A flight doesn’t report flags yet (issue #45), so ask the model yourself before flying a table, as the example does.
An example of each
The example program
wind_profiles.rs
builds each model for the launch site of Getting started, 1,400 m (4,593 ft) above
sea level. It prints the wind each one gives at a few heights above the ground, and flies nothing.
Run it from anywhere in the repository:
cargo run --example wind_profiles -p fusionspace-hpr-sim
It prints this:
Wind at a site 1400 m above sea level: speed in m/s, from a direction in °
above ground (m) constant power law log law layered wrong datum
2 5.0 from 270 4.0 from 270 3.6 from 270 5.0 from 270* 11.6 from 298
10 5.0 from 270 5.0 from 270 5.0 from 270 5.0 from 270 11.6 from 298
50 5.0 from 270 6.3 from 270 6.4 from 270 5.2 from 271 11.8 from 299
100 5.0 from 270 6.9 from 270 7.0 from 270 5.6 from 272 12.0 from 300
500 5.0 from 270 8.7 from 270 8.4 from 270 8.0 from 280 12.0 from 300*
1000 5.0 from 270 9.7 from 270 9.0 from 270 10.0 from 290 12.0 from 300*
2000 5.0 from 270 10.7 from 270 9.6 from 270 12.0 from 300* 12.0 from 300*
* beyond the table's levels: the end level's wind, held, and the sample flagged
{
"model": "layered",
"levels": [
{
"height_msl_m": 1410.0,
"speed_m_s": 5.0,
"direction_from_rad": 4.71238898038469
},
{
"height_msl_m": 1900.0,
"speed_m_s": 8.0,
"direction_from_rad": 4.886921905584122
},
{
"height_msl_m": 2900.0,
"speed_m_s": 12.0,
"direction_from_rad": 5.235987755982989
}
],
"interpolation": "speed_direction"
}
Reading it:
- Each law passes through its reference wind, 5.0 m/s (16 ft/s) at 10 m (33 ft), and blows from 270° at every height.
- The power and log laws agree near their reference height and part away from it. At 2 m (6.6 ft) they give 4.0 against 3.6 m/s (12 ft/s). At 2,000 m (6,562 ft) they give 10.7 against 9.6 m/s (31 ft/s). Both keep growing far above the surface layer they describe, which is why winds aloft should come from a table.
- The layered wind blends up from 5.0 m/s (16 ft/s) from 270° at 10 m (33 ft), turning with height. At 500 m (1,640 ft) it reaches 8.0 m/s (26 ft/s) from 280°. At 2 m (6.6 ft), below its lowest level, it holds the 10 m (33 ft) wind. At 2,000 m (6,562 ft), above its top level, it holds 12.0 m/s (39 ft/s) from 300°. The star marks both as flagged.
- The wrong datum column is the same table with its heights entered above the ground by mistake (Which height?).
- The JSON at the end is the layered wind as a file holds it (In JSON).
To fly one of them, give it to the flight’s environment, as the program does for each column:
Environment::standard(site)?.with_wind(wind). Then build the Simulation from that environment,
as Getting started does with its constant wind.
The program, which CI compiles and runs on macOS, Windows and Linux:
//! Wind profiles: each kind of steady wind hpr can fly, built for a launch site 1,400 m above sea
//! level, with the wind each one gives at a few heights above the ground, and how a flight takes
//! one. Nothing is flown.
//!
//! Run it from anywhere in the repository:
//!
//! ```text
//! cargo run --example wind_profiles -p fusionspace-hpr-sim
//! ```
//!
//! The documentation site's *Wind* page (`docs/physics/wind.md`) walks through it. What it prints
//! is kept next to it in `wind_profiles.output.txt`, and CI checks that the two still agree
//! (`cargo xtask examples --check`).
#![allow(
clippy::print_stdout,
reason = "the project's lints forbid printing in library code, and this program exists to print"
)]
use std::error::Error;
use hpr_atmos::{
ConstantWind, LayeredWind, LogLawWind, PowerLawWind, WindInterpolation, WindLevel, WindModel,
};
use hpr_core::DVec3;
use hpr_core::geodesy::Geodetic;
use hpr_sim::Environment;
fn main() -> Result<(), Box<dyn Error>> {
// The launch site of Getting started: New Mexico, 1,400 m up.
let site = Geodetic::from_degrees(32.99, -106.97, 1400.0)?;
let calm = Environment::standard(site)?; // no wind until it is given one
// A flight asks for the wind at its height above mean sea level: its height above the WGS 84
// ellipsoid, which is how hpr takes the site's height too, less the geoid undulation N (0
// unless you set it). So the ground is this high above sea level:
let ground_msl_m = site.height_m - calm.geoid_undulation_m;
let from_west = 270_f64.to_radians();
// 1. The same wind at every height: 5 m/s from the west. It takes no height.
let constant = ConstantWind::new(5.0, from_west)?;
// 2. A power law through 5 m/s at 10 m above the ground, with exponent α = 1/7. The
// reference height is above the ground; the ground's height is above sea level.
let power_law = PowerLawWind::new(5.0, 10.0, 1.0 / 7.0, from_west, ground_msl_m)?;
// 3. A log law through the same 5 m/s at 10 m, over grass: roughness length z₀ = 0.03 m.
let log_law = LogLawWind::new(5.0, 10.0, 0.03, from_west, ground_msl_m)?;
// 4. A table of levels, as from a forecast. Its heights are above sea level, so a level given
// above the ground goes in at the ground's height plus its own. The 10 m wind is the
// lowest level, so the profile blends up from it.
let level = |height_agl_m: f64, speed_m_s: f64, from_deg: f64| WindLevel {
height_msl_m: ground_msl_m + height_agl_m,
speed_m_s,
direction_from_rad: from_deg.to_radians(),
};
let forecast = vec![
level(10.0, 5.0, 270.0),
level(500.0, 8.0, 280.0),
level(1500.0, 12.0, 300.0),
];
let layered = LayeredWind::new(forecast.clone(), WindInterpolation::SpeedDirection)?;
// The same table with its heights entered above the ground by mistake: 1,400 m too low.
let wrong_levels = forecast
.iter()
.map(|level| WindLevel {
height_msl_m: level.height_msl_m - ground_msl_m,
..*level
})
.collect();
let wrong_datum = LayeredWind::new(wrong_levels, WindInterpolation::SpeedDirection)?;
// Any of them goes to a flight the same way, through the flight's environment. Each
// environment here is the one a `Simulation` from this site would fly in.
let columns = [
("constant", WindModel::Constant(constant)),
("power law", WindModel::PowerLaw(power_law)),
("log law", WindModel::LogLaw(log_law)),
("layered", WindModel::Layered(layered.clone())),
("wrong datum", WindModel::Layered(wrong_datum)),
];
let mut environments = Vec::new();
for (_, wind) in &columns {
environments.push(Environment::standard(site)?.with_wind(wind.clone()));
}
println!(
"Wind at a site {ground_msl_m:.0} m above sea level: speed in m/s, from a direction in °"
);
println!();
let mut header = "above ground (m)".to_owned();
for (name, _) in &columns {
header += &format!("{name:>14} ");
}
println!("{}", header.trim_end());
for height_agl_m in [2.0, 10.0, 50.0, 100.0, 500.0, 1000.0, 2000.0_f64] {
let mut row = format!("{height_agl_m:>16.0}");
for environment in &environments {
// What the flight engine asks for: the wind at a height above sea level.
let sample = environment.wind.wind(ground_msl_m + height_agl_m)?;
let (speed_m_s, from_deg) = speed_and_direction_from(sample.velocity_enu_m_s);
let cell = format!("{speed_m_s:.1} from {from_deg:.0}");
// A star marks a height beyond a table's levels, where the model holds the end
// level's wind and flags the sample.
let flag = if sample.extrapolated.is_some() {
"*"
} else {
" "
};
row += &format!("{cell:>14}{flag}");
}
println!("{}", row.trim_end());
}
println!();
println!("* beyond the table's levels: the end level's wind, held, and the sample flagged");
println!();
// The table as JSON, tagged by `model`. Directions are in radians.
println!(
"{}",
serde_json::to_string_pretty(&WindModel::Layered(layered))?
);
Ok(())
}
/// The speed of a wind velocity (east, north, up), m/s, and the direction it blows from,
/// clockwise from north, rounded to a whole degree in `[0, 360)`.
fn speed_and_direction_from(velocity_enu_m_s: DVec3) -> (f64, f64) {
let (east, north) = (velocity_enu_m_s.x, velocity_enu_m_s.y);
let from_deg = (-east).atan2(-north).to_degrees().rem_euclid(360.0);
// `% 360.0` turns a 359.6° into 0°, and `+ 0.0` turns a -0 into 0.
(east.hypot(north), from_deg.round() % 360.0 + 0.0)
}
Input and limits
How a wind model is written in JSON, and what is not modeled yet.
In JSON
WindModel reads and writes JSON as one object. Its model field names the kind of wind, and the
other fields are that model’s inputs:
model | Other fields |
|---|---|
constant | speed_m_s, direction_from_rad |
power_law | reference_speed_m_s, reference_height_agl_m, exponent, direction_from_rad, ground_msl_m |
log_law | reference_speed_m_s, reference_height_agl_m, roughness_length_m, direction_from_rad, ground_msl_m |
layered | levels, each with height_msl_m, speed_m_s and direction_from_rad; and interpolation, speed_direction (the default if left out) or components |
- Directions are in radians, the direction the wind blows from: 270° is 4.71238898038469, as the example’s JSON shows.
- Reading a file checks it as the model’s constructor does: a negative speed, or a field the model doesn’t have, is an error.
Not yet modeled
- Wind that changes with time, or across the field.
- Vertical mean wind.
- Terrain effects.
- A blend below the lowest tabulated level (the table holds the lowest level’s wind).
- Reporting during a flight that the wind was held beyond a table’s levels.
A flight takes one wind model, so it can’t join a power or log law near the ground to a table of levels aloft. How to join them isn’t decided yet (issue #890).
Tests that pin this
wind::tests::layered_wind_interpolates_speed_and_heading(Loft lesson L6, the forecast profile that stepped at its lowest level):- Halfway between 4 m/s (13 ft/s) from 350° and 12 m/s (39 ft/s) from 30°, the wind is 8 m/s (26 ft/s) from 10°. It turns through north.
- There is no step just above the surface level.
components_interpolation_averages_the_vectors,opposite_directions_turn_clockwiseandwind_grows_out_of_calm_without_turning.layered_wind_holds_and_flags_beyond_its_levels.meteorological_direction_convention, plus the power and log laws through their references, below ground, and at .invalid_inputs_are_rejected, andwind_models_round_trip_through_json: each model written to JSON and read back gives the same wind.- Against RocketPy, in the recovery test
descent_matches_rocketpy_examples(Recovery):- At every height its parachute descents sample, HPR Sim’s wind matches RocketPy’s within 1e-9 m/s in its east and north parts.
- Four of the five descents fly in wind: Calisto, NDRT 2020, Prometheus and Juno III. Their total drift agrees within 0.28%, and each east or north part within 2.9%. The largest gap is the north part of NDRT 2020’s drift, +2.865% (the validation report).
- The example above, which CI runs and compares with its committed output.
Turbulence
This page describes the random gusts HPR Sim generates from the Dryden model, repeatable from a seed, and why no flight uses them.
In short
- What it models: random gusts from the Dryden model. The gust pattern has a published spectrum (how gust strength spreads over wavelength). It is sized by height and the wind at 20 ft, and repeatable from a seed.
- Sources: MIL-F-8785C, the US military flying-qualities specification (1980), noting where MIL-HDBK-1797 (1997) differs. Random numbers come from xoshiro256++ (Blackman and Vigna, 2021) and Marsaglia and Bray’s polar method (1964).
- How well it is validated: analytic and unit tests only. Over 2²⁰ samples, each component’s spectrum is within 4 standard errors of theory in every octave band (±1–3% in the wide bands). Not compared with another simulator or a real flight.
- What it leaves out: Dryden is an aircraft model, unvalidated for rockets (evidence row G12). Its frozen gust pattern needs airspeed well above the gusts, which fails on the rail and near apogee. No flight uses it, and none is planned (issue #39). Above 2,000 ft the caller supplies the intensity.
Code and sources
Code: hpr_atmos::dryden, using the seeded generator in hpr_core::random.
Sources:
- [8785C] MIL-F-8785C, Military Specification: Flying Qualities of Piloted Airplanes
(5 November 1980), §3.7 and the definitions in §6.2.7, pinned as
mil-f-8785c. - [1797] MIL-HDBK-1797 (1997), Appendix A §4.9, for its differences only. It is not pinned: no stable public copy was found.
- [BV] D. Blackman and S. Vigna, “Scrambled linear pseudorandom number generators”, ACM TOMS 47(4) (2021): xoshiro256++ with SplitMix64 seeding.
- [MB] G. Marsaglia and T. A. Bray, “A convenient method for generating normal variables”, SIAM Review 6(3) (1964): the polar method.
The Dryden model
The Dryden spectra, the parameters that size them, and the generator that turns them into gusts.
Dryden spectra
Turbulence is a frozen random field that the vehicle moves through, so its spectra are functions of spatial frequency (rad/m, [8785C] §6.2.7). They are one-sided, with ([8785C] §3.7.1.2), and is like :
Each spectrum and autocorrelation is a Fourier pair,
and a test checks this numerically.
The factor-of-two trap. [1797] writes the transverse spectra with and over , and halves the lengths (). The spectra are identical, but mixing one document’s lengths with the other’s formula puts the transverse scales off by two. This code uses [8785C]’s form and lengths throughout.
Parameters
-
The low-altitude model is in [8785C] §3.7.3.4 and Figs. 10–11. With the height above terrain in ft, the lengths in ft, the mean wind at 20 ft, and :
- The formulas hold from 10 to 1,000 ft. Below 10 ft this code uses the 10 ft values. From 1,000 to 2,000 ft the figures give and equal intensities.
- The model covers only up to about 2,000 ft (§3.8.1), so above that the constructor returns an error instead of quietly holding values.
- Fig. 9 marks = 15, 30 and 45 kt for light, moderate and severe turbulence.
- For aircraft at low altitude, lies along the horizontal relative mean wind and is vertical ([8785C] p. 60).
-
The medium/high-altitude model ([8785C] §3.7.2, above about 2,000 ft) is isotropic, with .
- The intensity against altitude and exceedance probability is only a graph (Fig. 7), so the caller supplies it.
- Neither military document says how to blend 1,000–2,000 ft. MATLAB’s documentation interpolates linearly, but that is its own choice.
-
In the gust field’s axes, is the longitudinal component and , the transverse ones.
- The longitudinal spectrum belongs to the component along the path through the frozen field. For a climbing rocket that is nearly vertical. The flight engine doesn’t use turbulence, and no milestone plans it yet (issue #39). Whoever adds it must align with the path.
- Getting that wrong changes the statistics. A horizontal gust given the longitudinal spectrum has twice the transverse power at low frequency, and 2/3 of it at high frequency.
- The axes’ signs don’t matter.
Generator
Exact discretization, so step length never changes the statistics.
-
is a first-order Gauss-Markov state. Over a step , with : .
-
and each use two normalized states, driven as and , with output
-
The stationary covariance is the same for every :
-
The output’s autocorrelation is exactly . Algebra: is with .
-
Over , the transition is , plus Gaussian noise of covariance :
-
Written with the regularized incomplete gamma function, keeps full relative precision for tiny steps, where the closed form cancels to nothing. The noise is drawn through ’s Cholesky factor.
-
-
The state is normalized, so intensities and lengths can change from one step to the next (with altitude, say) without breaking stationarity.
-
Draws come in a fixed order (, two for , two for ) from a seeded xoshiro256++. So the same seed and steps give bit-identical gusts on one platform.
- The integer stream is identical everywhere.
- Normals and gusts go through the math library’s
lnandexp, which may differ in the last bit between platforms.
-
The generator serializes, so a run can be checkpointed and resumed.
GustField precomputes a realization at a fixed spacing and interpolates it linearly. That makes
the gust a pure function of the path coordinate, which an adaptive integrator can evaluate
repeatedly and on rejected steps.
- Linear interpolation smooths wavelengths near the spacing, so keep the spacing at or below a tenth of the smallest scale length.
- A field holds at most samples.
Limits for rockets
- Dryden is scaled for aircraft: its lengths and intensities describe aircraft flying roughly level. A rocket climbs through the low-altitude model’s height dependence in seconds. The frozen-field assumption holds when airspeed is well above the gust velocities. That is false on the rail and near apogee, where the gust field barely moves past the vehicle.
- Whoever adds turbulence to a flight picks the path coordinate, what to key the field on: distance flown through the air, or altitude. They also decide how to fade gusts in on the rail. This module does neither.
Tests that pin this
dryden::tests::dryden_spectrum_matches_theoryis the done when of the atmosphere and wind milestone:-
Setup: 2²⁰ samples at 1 m (3.3 ft), with m/s and m.
-
Estimate: 256 Hann-windowed segments of 4,096 samples, averaged (Bartlett’s method).
-
In every octave band from bin 1 to Nyquist, each component’s mean ratio to theory is within 4 standard errors.
-
The variance of a band’s mean ratio is
for bins and segments, with the Hann window’s neighboring-bin correlations and . The bracket tends to 1.94.
-
The one- and two-bin bands at the bottom are loose (±25%, ±21%); the wide bands (±1–3%) pin the spectrum.
-
Theory is the continuous spectrum sampled at 1 m (3.3 ft), in closed form. Below a tenth of Nyquist it is checked against [8785C]’s formula to 1%.
-
The variance of the record is within 5% of .
-
- The exactness tests:
-
transition_preserves_the_stationary_covariance: to for steps from to scale lengths. -
two_steps_compose_into_one, to 1e-12 relative, down to :with .
-
transverse_output_has_the_dryden_autocorrelation. -
regularized_gamma_matches_independent_references.
-
- The stepping loop:
quarter_meter_steps_give_the_one_meter_correlation, to 2e-3.- The sampling error is about 4e-4, so this catches a scale length 10% off.
- It can’t tell an exact step from an Euler step (8e-5 apart), which is why the exactness tests above exist.
- The spectra:
spectra_integrate_to_the_variancespectra_are_the_cosine_transforms_of_the_autocorrelations
- The parameters:
low_altitude_parameters_follow_the_specification, at 100 ft moderate: and . It also checks the 10 ft floor, the 1,000–2,000 ft hold, and the refusal above 2,000 ft. - Determinism: the same seed gives bit-identical fields, and a serialized generator resumes the stream.
hpr_core::random::tests:- Bit-identical to
rand_xoshiroover draws for 5 seeds. - The normal sampler’s moments and CDF at , within 5 standard errors.
- Bit-identical to
The design tree, configurations and checks
See how HPR Sim assembles a rocket from its parts, sizes parts from their neighbors, applies measured overrides, mounts motors and flags impossible designs.
In short
- What it models: how parts become a rocket. It covers where each part sits, automatic radii (taken from the neighboring parts), overrides, the reference diameter and the motor in its mount. Overrides are measured values that replace computed masses, centers and inertias. It gives the rocket’s mass, center of mass and inertia (its resistance to turning) through the burn. It flags designs that can’t exist, such as a motor wider than its mount. Most of it is convention, not physics.
- Sources: RocketPy 1.13.0’s
Rocketcode, and Meriam and Kraige’s Engineering Mechanics: Dynamics for the parallel-axis theorem. - How well it is validated: by analytic tests and
code-to-code comparison, the first and third of four
kinds of evidence. A hand-worked rocket agrees to 1e-12 through the burn. Thirteen cases
of RocketPy’s example rockets are
compared, each a given structure with its motor placed. At the times RocketPy computed, mass,
center and inertia agree within 8.0e-10 (relative). Between those times, mass agrees within
1.4e-5 and inertia within 2.6e-5. The propellant grains’ mass agrees within 2.5e-9 at those times and 6.4e-5 between them, of
its initial value. Placement, automatic radii and overrides are checked by hand. On 71 designs
compared with OpenRocket, the whole structure is within 1% in mass on 70 and in center of mass
on 70 (mass properties). Body radii are checked against
OpenRocket in the
.orkimport (.orkdesign files). A cluster’s tubes sit where OpenRocket puts them, to 1e-15 m. A motor out turns the rocket as the hand calculation says, to 3.7e-7 (below). A pod’s mass, center and inertia match the hand-worked parallel-axis sum to 1e-15 (Pods). They match OpenRocket’s on eighteen probe designs (.ork: Pods). On whole flights, six probe designs, five with pods of bodies, fins and motors, are within 0.92% of OpenRocket’s apogee. Their launch masses are within 0.0001% (aerodynamics: Pods). OpenRocket’s cluster example flies within 5% of OpenRocket’s apogee and largest speed. Its parachute opened before apogee, so three of its apogees are compared with OpenRocket’s flight with no parachute (the two-stage and cluster comparison; results). Not compared with a real flight. - What it leaves out: each motor lights at its own
ignition, at launch unless told otherwise. So a two-stage design whose file says nothing flies with every motor lit at once, and nothing warns. A staged flight gives the sustainer its ignition (Staging). A cluster’s motors light together, or not at all: no spread in ignition and no thrust misalignment. Fins on a nose cone or a transition sit there only as a freeform outline with no tab or fillet, its root along the surface. Pods fly with each pod’s parts’ own normal force and drag, without the flow between the pods and the body (aerodynamics: Pods). The mass conventions the OpenRocket comparison found in OpenRocket are on the mass page.
Code and sources
Code: hpr_design::tree (the tree, placement, automatic
radii, overrides, reference diameter), hpr_design::config
(motor mounts, configurations, assembly) and hpr_design::checks.
Decisions: ADR-007 (stations, placement, automatic radii, overrides,
motors and checks). Part geometry and mass are in Mass properties and
Shapes.
Sources:
- [RP] RocketPy v1.13.0 (MIT),
rocketpy/rocket/rocket.py: how a rocket’s mass, center of mass and inertia combine with a placed motor.docs/research/rocketpy-rocket-mass.mdhas the formulas with line numbers. - [MK] Meriam and Kraige, Engineering Mechanics: Dynamics, appendix B: the parallel-axis theorem (Mass properties).
- [AT] AeroTech, RMS-18/20, RMS-24/40, RMS-29/40-120 and HP RMS-29/120 Motor Dimensional Drawing (2003–2004), archived by the Internet Archive in 2005. They give case outside diameters and the ±0.005 in drawing tolerance (a nominal motor in its matching tube). The 29 mm motor drawing; the others are in the same folder’s archive.
- [ISO 2768] ISO 2768-1:1989, General tolerances, part 1: tolerances for linear and angular dimensions without individual tolerance indications, table 1, class c. It gives the fit tolerance (wider than its parent).
OpenRocket has its own conventions for positions, automatic radii and overrides. This project
never reads OpenRocket’s source code, whose license (GPL) is incompatible with this project’s (the
clean-room rule). So
the OpenRocket import, which reads .ork files, and
the OpenRocket comparison mapped most of them by running
OpenRocket itself. Some readings aren’t measured yet, such as which way OpenRocket turns a roll
angle (readings that are not settled).
Building the tree
How parts are placed in the tree, sized from their neighbors, overridden and measured.
Stations and the body origin
- A station is a distance aft of the nose tip, the way design files give positions.
- The body frame’s origin is the nose tip, on the axis: in Frames. Its axis points along the rocket toward the nose, so station is body , and the rocket lies at .
- A part’s own frame has its origin at its forward end (Mass properties). A part placed at station is translated by . Radial offsets and roll angles stay as the part states them, always measured from the body axis.
The tree
A Rocket has stages: sections of the stack, forward
to aft. A separation splits the rocket at a boundary between two
stages, so a rocket that stays in one piece needs only one.
Each Stage lists body components, and each
Component holds a
Part and its children.
| role | parts | where |
|---|---|---|
| body | nose cone, body tube, transition | a stage’s list; they stack |
| external | fin set, tube fin set, launch lug, rail button, pod set | children of a body tube; they take its outer radius |
| a pod’s body | nose cone, body tube, transition | children of a pod set; they stack along the pod (Pods) |
| internal | inner tube, centering ring, mass component, parachute, streamer, shock cord | children of a body component or an inner tube |
- Body components start at and follow one another through every stage, forward to aft. Each one’s extent is its length without shoulders (the sleeves of a nose or transition that slide into the next tube).
- An attached part’s axial extent is:
- a fin set’s root chord;
- a row of lugs or buttons from the first one’s forward end to the last one’s aft end, (for a button, its diameter);
- a packed part’s packed length;
- a pod set’s pod, its body components’ lengths added;
- otherwise the part’s length.
- A tree is refused (
DesignError::Tree) for:- no stages, or an empty stage;
- a part in the wrong role;
- an attached part without a position, or a body component with one;
- children under anything but a body component, inner tube or pod set;
- anything but body components in a pod set;
- motor mounts on anything but a body tube or inner tube;
- an empty or repeated id (
DesignError::DuplicateIdinstead).
- A fin set may sit on a nose cone or a transition when its root follows the surface
(ADR-166).
The root is a freeform outline’s
root_mpoints and its ends. Each must be within a micron of the surface (FinSet::ROOT_ON_SURFACE_M). With the body’s radius along it and the root’s leading edge, a point is on the surface when . The straight pieces between the points may cut off or add at most 0.1% of the fin’s area (FinSet::ROOT_SLIVER_SHARE). The set must stay on the body’s length and carry no tab or fillet. Its body radius is . Anything else there isDesignError::Geometry, and on a body tube a fin’s root must be level. Lugs, buttons and tube fins still attach to a body tube only. - A fin set has 1 to 64 fins and a tube fin set 1 to 64 tubes. A pod set has 1 to 64 pods, and a
row of launch lugs or rail buttons 1 to 64 copies. A count outside that is refused
(
DesignError::Domain, “fin count (1 to 64)”, or “instance count (1 to 64)” for lugs and buttons). Each fin, tube, pod, lug or button is weighed one by one. So the bound stops a file’s mistyped count from asking for billions of them. It is far above any real rocket. The most fins in one set among the.orkdesigns the project’s checks read is 8. That is a one-off count over 78 designs, not a committed survey. The.orkreader leaves out a part counted more than 64 times. The aerodynamics take 1 to 8 fins in a set (aerodynamics: fin count), so 9 to 64 fins are weighed but don’t fly.
Positions
An attached part of extent in a parent spanning stations , with offset (positive aft):
from | forward end at |
|---|---|
top | |
middle | |
bottom | |
after | the previous sibling’s aft end , or for the first child |
absolute | station_m |
Automatic dimensions
An auto list names dimensions that the tree resolves. The part’s stored value for them is ignored.
-
Body radii follow neighbors through every stage, stage boundaries included:
- a nose cone’s base, and a transition’s aft radius, take the next component’s forward radius;
- a body tube, and a transition’s forward radius, take the previous component’s aft radius.
-
The tree follows these sources until nothing changes. A body tube still unresolved then takes the next component’s forward radius instead: only the first such tube, and then the sweep repeats. So a fixed radius forward of a tube wins over one aft of it. A radius with no fixed radius to reach is refused.
Rocket::unresolvable_body_radiilists exactly those radii. The.orkimporter gives them OpenRocket’s own default of 25 mm (0.98 in) before laying the design out. See when an automatic radius has nothing to take. The tree itself never invents a radius. -
Shoulders take the inner radius (, outer radius less wall thickness) of the adjoining body tube. That tube is behind a nose; ahead of a transition for its forward shoulder, behind it for its aft one.
-
Centering rings: the outer radius is the parent’s inner radius. The inner radius is the widest outer radius among on-axis sibling inner tubes that overlap it along the axis (by a positive length). With none, it is zero: a bulkhead.
-
Packed parts (mass components and recovery parts) take the parent tube’s inner radius, less the distance from the parent’s axis to the part’s axis. An offset outside the bore is refused.
-
Tube fin sets: the outer radius is the one at which the tubes close a ring around their body tube, of radius . Each tube touches the body and its two neighbors. For tubes,
one or two tubes take the body’s radius. Six tubes on a 50 mm (2.0 in) body are 50 mm (2.0 in); four are 120.7 mm (4.8 in). A wall thicker than is cut to it. This is the radius OpenRocket 24.12 gives, measured on probes (
.orkdesign files).
Overrides
Overrides replace computed mass properties with
measured ones: the mass , the center of mass and the inertia tensor . The
tensor is the 3×3 table of moments and products of inertia (Mass properties). Primes
mark the new values. They apply in this order:
- A mass scales the tensor, , and keeps the center. The body keeps its shape. A
body with becomes a point mass at . A packed part (a mass component,
parachute, streamer or shock cord) with instead becomes a solid cylinder of filling
its packing. OpenRocket’s does the same (Packed parts).
This is a stage’s
rescaledrule; A stage’s rule, below, gives the other. - A center (
cg_aft_m) sets , where is the station of the component’s own forward end, whether or not the children are covered. For a stage it is the stage’s forward end, and it is never a shoulder’s.cg_xy_msets and ; without it they are kept. The tensor about the center is unchanged. - An inertia replaces the tensor about the center.
InertiaOverridegives its six entries with the sign convention of Mass properties (). The off-diagonal ones default to zero.
The result must pass MassProperties::validate, which also refuses inertia on a body with no mass.
Errors inside a stage or component name it (DesignError::InComponent).
- A component’s overrides cover the component alone. With
overrides_include_children, they cover the component and everything attached to it. A stage’s overrides cover the whole stage, measured from its forward end. Motors are never covered. - A
.orkstage’s mass override whose flag says it doesn’t cover the stage’s parts, or that writes no flag, is not one of these. OpenRocket adds it to the parts’ mass, and the design holds it as the stage’s added mass (below). - A component or stage can also state a drag coefficient (
drag_override, with its owninclude_children). It plays no part in mass or inertia; the aerodynamics read it (A part’s stated drag coefficient). - Deeper overrides apply first. A child’s override is inside its parent’s subtree total, and the stage override applies last.
- Scaling the tensor with the mass keeps the radii of gyration (: how far out, on average, the mass sits). That is the natural reading of “this part weighs more than its geometry says”.
- OpenRocket differs in two ways, which HPR Sim keeps as measured departures for a part’s overrides. It scales only the overriding part’s own inertia. And when a mass override covers the parts inside and gives no center, it puts the center at the overriding part’s own. The two agree on which override wins, and where a center override is measured from (Loft lesson L51). Probe designs measured all of this in M2.2b1 (Mass properties). A stage’s overrides can follow OpenRocket instead (next).
A stage’s rule. A stage’s overrides say what it weighs and where it balances. They don’t say
where the mass its parts miss sits, so a stage carries a rule for that
(StageOverrideRule, the override_rule
key):
rescaled, the default, is the rule above: the stage is one body, scaled by a mass override and moved whole by a center override.parts_in_placeleaves every part where the design puts it, as OpenRocket 24.12 weighs a single stage. The mass and the center are the overrides’, as before. The inertia is the parts’ about the stage’s center, and the mass an override adds or takes away sits at that center, adding none. The.orkreader gives this rule to every stage whose override covers its parts, on the axis or a parallel stage (A stage’s override).
Under parts_in_place, with the parts’ mass , center and inertia across the axis
about that center, and the stage’s center , the
parallel-axis theorem gives the inertia across the axis
whatever the mass override. The inertia about the axis is the parts’, unless the center moves off the axis. An added mass with no station sits at too.
A worked example. A stage’s parts weigh 0.3996 kg, centered 0.4701 m (1.542 ft) aft of the tip, with 0.015838 kg·m² across the axis. Its center override is 0.4 m (1.3 ft).
parts_in_place: 0.015838 kg·m² plus 0.3996 kg × (0.0701 m)² is 0.017802 kg·m², OpenRocket 24.12’s 0.017803 kg·m² (the hand sum rounds the distance). A 2 kg mass override beside it leaves the inertia there.rescaled: the parts move whole, so the inertia stays 0.015838 kg·m², 11.04% under. With the 2 kg mass override it scales by 2/0.3996 to 0.0793 kg·m², 345% over.
Neither rule is measured on a flying rocket. If the mass the parts miss is spread along the stage
as the parts are, rescaled is right and parts_in_place reads low, by the mass ratio under a
mass override (5.0 times about the axis on the probe above, 4.5 times across it, where the
center override also moves the parts’ center); if that mass sits farther out, by more. Under a center override, parts_in_place gives the
least inertia about the stage’s stated center that any stage keeping its parts in place can
have: the parts’ own about that center. The decision record
weighs the two, and the probes where OpenRocket’s own figure is below even that.
A stage’s added mass
This is how HPR Sim reads an OpenRocket stage whose mass override doesn’t cover its parts. On 19 probe designs the mass, center and inertia match OpenRocket 24.12’s (the whole rocket’s, on the five probes of a rocket of two). Where one of the stage’s two overrides covers the parts, they match too on one stage. On an airframe with a motor aboard the mass, the center and the inertia the override adds to the structure match; with the motor counted, under a center that covers the parts beside an added mass, and on the lower of two stages, the inertia across the axis doesn’t (below). On a parallel stage, 25 more probes match for the stage alone. Where its override covers the boosters, the override adds less to the whole rocket’s inertia across the axis than it does in OpenRocket, by up to 4.673% of OpenRocket’s inertia for that rocket.
A finished rocket weighs more than its parts: glue, paint, wiring. A stage can carry that as an
AddedMass: a point mass added to the
stage’s parts, before the stage’s overrides apply. Motors are not among the parts. Write the
parts’ mass as and the station of their center as . The
inertia across the axis is the one that resists pitch and yaw; the inertia about the axis, roll.
-
With no station, the point sits at the parts’ center. The stage weighs . Its center, and its inertia about that center, are the parts’.
-
With a station (
cg_aft_m), the point sits that far aft of the stage’s forward end , at , as far off the axis as the parts’ center is: on it when that center is, as on any rocket that is the same all the way round, and when the parts weigh nothing. The stage weighs , and its center is atIts inertia across the axis is the parts’ and the point’s about that center, by the parallel-axis theorem:
The inertia about the axis is the parts’ when their center is on it. Off the axis the code sums both in three dimensions, as it does any two masses.
The stage’s overrides then apply to the parts and the added mass together; a mass override is
the mass of both. Under the default rule a center override moves both. Under parts_in_place
(A stage’s rule) the parts stay, and an added mass with no station sits at the
stage’s center.
A worked example. A stage’s parts weigh 0.3996 kg, centered 0.4701 m (1.542 ft) aft of the tip, with an inertia across the axis of 0.015838 kg·m². The stage starts at the tip, so .
- Add 2 kg with no station. The stage weighs 2.3996 kg. Its center stays where the parts’ is, and its inertia at 0.015838 kg·m².
- Add 2 kg at a station of 0.4 m (1.3 ft). The stage weighs 2.3996 kg. Its center is at (1.351 ft). Its inertia across the axis is
Both are OpenRocket 24.12’s numbers for the same stage (2.3996 kg at 0.4117 m (1.351 ft), 0.017476 kg·m²; the hand sum above rounds its distances).
On a parallel stage the added mass is one point for the whole set of boosters, not one for each. With no station it sits at the boosters’ center. A station is measured from the parallel stage’s forward end, and the mass sits there as far off the axis as the boosters’ center is. On the axis that is the same rule as above, with the boosters as the parts. The boosters carry the mass away when they drop.
For example, three boosters weigh 0.0605 kg together, centered 0.6199 m (2.034 ft) aft of the tip and on the axis, with an inertia across the axis of 0.000487 kg·m². Their forward end is 0.45 m (1.48 ft) aft of the tip. Add 2 kg at a station of 0.1 m (0.33 ft), so at 0.55 m (1.80 ft). The parallel stage weighs 2.0605 kg. Its center is at (1.811 ft). The boosters’ center is (2.67 in) from it, and the added mass (0.083 in). Its inertia across the axis is OpenRocket 24.12 gives 2.0605 kg at 0.5521 m (1.811 ft) and 0.000774 kg·m² for those boosters alone.
On the stage a parallel stage hangs on, an added mass at a station is a point among that stage’s own parts, the boosters not counted. Two cases there are refused, in What it leaves out.
Where the rule comes from. It is how OpenRocket 24.12 weighs a stage’s mass override that
doesn’t cover the stage’s parts. Its user guide says such a value “is added to the calculated
value” (Overrides and Surface Finish). Where the mass goes is measured on
probe designs, and the .ork reader turns each pairing of the
stage’s flags into an added mass, a whole-stage override, both, or nothing
(A stage’s override,
the decision record).
How well it is validated. By code-to-code comparison with OpenRocket 24.12, and by hand.
- On 19 probe designs with no override that covers the parts, HPR Sim’s structure matches
OpenRocket’s (the whole rocket’s, on the five probes of a rocket of two) within the test’s
bounds: 5 parts in 10 million of the mass, 0.2 µm of the center
and 3 parts in a million of each inertia. The probes cover one stage and a rocket of two, a
flag that says
false, a flag not written and the older single flag, and a part with an override of its own. - Ten more probes are on an airframe with a motor aboard, and four of them ask whether the motor moves the added mass. OpenRocket’s rocket at launch and at burnout is that motor added to the same structure, so in OpenRocket the added mass doesn’t follow the motor. HPR Sim is compared on the structure: its layout holds no motor, and motors are added to it afterward. On each, the inertia the override adds to that airframe’s is within 1e-9 kg·m² of what it adds in OpenRocket (0.00059 kg·m² across the axis for the mass at a station, and 0.00070 kg·m² for the mass beside a center that covers the parts).
- The other six carry pods. With three pods round the tube, the parts’ center is 3.7 cm (1.5 in) aft of the airframe’s with none, and OpenRocket’s added mass leaves it there: a stage’s pods are among its parts. With one pod, the parts’ center is 2.7 mm (0.11 in) off the axis, and OpenRocket’s center stays that far off it under each of the three overrides probed (the mass alone, the mass at a station, and the mass beside a center that covers the parts): a station moves the added mass along the axis only. HPR Sim’s mass and center match on all six within the bounds above, the distance off the axis and the inertia the override adds too.
- 49 more probes put the override on a parallel stage, on the stage one hangs on, or on parts that weigh nothing, four of them with no override as baselines: 40 with three boosters beside the core or with one, and 9 of two stages on the axis, one or both weighing nothing (the decision record). HPR Sim lays out 27 and refuses 22 by name. On the 25 laid out that carry boosters, the parallel stage alone matches OpenRocket’s within the bounds above, and the whole rocket matches in mass and center. The rocket’s inertias are held by what the override adds to them: within 5 parts in 10 million of what it adds in OpenRocket, or within 1e-9 kg·m² where it adds less than 0.002 kg·m². That holds where no override covers the boosters. Where one does, the rocket’s inertia falls short (below). A 2 kg mass at a station beside one booster sits 52 mm (2.0 in) off the axis in both. OpenRocket gives one inertia across the axis, the one about its y axis, and one booster hangs off the axis along that axis, so how far off it is adds nothing to OpenRocket’s figure. With one booster HPR Sim’s is compared about the body axis the booster lies along, which has no such term either. With a motor in the airframe, OpenRocket’s rocket at launch and at burnout has the mass and center of that motor added to the same structure, as on a stage on the axis.
tree::tests::a_parallel_stages_added_mass_sits_among_its_podsworks a parallel stage’s added mass by hand with one, two and three boosters: the mass and the center to 1e-15 (kg, m), the inertia to 1e-12 kg·m².tree::tests::a_stages_added_mass_is_a_point_among_its_partsworks both forms by hand on a lower stage: the mass and the center to 1e-15 (kg, m), the inertia across the axis to 1e-12 kg·m².a_stages_overrides_leave_its_parts_in_place_by_its_ruledoes the same for each override underparts_in_place.
- Where one of the stage’s two overrides covers the parts, OpenRocket’s inertia is not always
the parts’ about the stage’s center, which HPR Sim’s rule gives (the decision record).
- On the lower of two stages (two probes, each with a 2 kg override). OpenRocket sums every
part about the rocket’s center at its own place, and the override’s 2 kg as a point at the stage’s center. Under a mass that covers
the parts, that counts the lower tube twice. Under a center beside an added mass, the stage’s
own inertia would have to be less than its tube’s. On both, it is less than the tube alone
has about the stage’s center, so no stage that keeps its parts in place gives it. The rocket’s inertia across the axis is
4.95% over OpenRocket’s (the center beside an added mass) and 3.33% over (a mass that covers
the parts, beside a center that doesn’t). About the axis the two agree. This difference
stands: HPR Sim won’t close it, and a test pins both figures
(
a_stage_override_covering_its_parts_beside_one_that_does_not; the decision that it stands). - With a motor aboard. OpenRocket sums the same way about the rocket’s center with the motor.
On the motor’s airframe, under an added mass beside a center that covers the parts, taking
the parts’ inertia about the stage’s center, as HPR Sim does, gives an inertia across the axis 1.6% under OpenRocket’s
at launch and 1.1% under at burnout. That is worked from OpenRocket’s own records, the
motor’s term the same in both (
openrockets_inertia_with_a_motor_aboard_is_the_same_sum). Closing it is open work: M2.3d9, the inertia with a motor aboard. - Where a parallel stage’s override covers the boosters (ten probes). OpenRocket sums each
booster from where the design puts it, with its own mass, and adds a point at the parallel
stage’s center, the stated one where the override states one. That point is the whole stated mass under a mass that covers the boosters,
so their own mass is counted beside it. Otherwise it is what the stage weighs more than
they do. The rocket’s center is taken from the stage as overridden. A stage weighed as
one body can’t give that sum and OpenRocket’s inertia for the stage alone
(
openrockets_sum_with_a_parallel_stages_covering_center_is_no_bodysworks the sum from OpenRocket’s records on all ten). With an added mass beside a center that covers the boosters, the override adds 0.63% of OpenRocket’s inertia across the axis less with three boosters, and 0.22% less with one. With a center that doesn’t cover the boosters beside a mass that does, it adds 0.79% and 0.27% less. Closing those is open work: M2.3d14, the rocket’s inertia beside a parallel stage’s covering override. Where every override covers the boosters (a mass, a center, or both), it adds 0.070% to 4.673% less. No increment is planned for this yet; #1432 records it. About the axis the two agree, but for one booster under a covering mass, where HPR Sim’s is 0.103% under. The parallel stage alone matches on each.
- On the lower of two stages (two probes, each with a 2 kg override). OpenRocket sums every
part about the rocket’s center at its own place, and the override’s 2 kg as a point at the stage’s center. Under a mass that covers
the parts, that counts the lower tube twice. Under a center beside an added mass, the stage’s
own inertia would have to be less than its tube’s. On both, it is less than the tube alone
has about the stage’s center, so no stage that keeps its parts in place gives it. The rocket’s inertia across the axis is
4.95% over OpenRocket’s (the center beside an added mass) and 3.33% over (a mass that covers
the parts, beside a center that doesn’t). About the axis the two agree. This difference
stands: HPR Sim won’t close it, and a test pins both figures
(
- The stage a parallel stage hangs on can’t carry an added mass above zero with no station. Where the parallel stage is one booster off the axis, it can’t carry one at a station either. The layout refuses both. OpenRocket weighs that stage with its boosters while they hang there. With a mass and no center stated, and no override on the parallel stage, OpenRocket puts the added mass at the center of the stage and boosters together. That is 39 mm (1.5 in) aft of the stage’s own center with three boosters, and 14.4 mm (0.57 in) aft with one. At a station beside one booster, the added mass sits as far off the axis as that center, 2.7 mm (0.11 in), and on the axis once the booster is gone. Either way it moves when they drop. HPR Sim’s stage is one body that keeps its center. That is open work: M2.3d11, the stage a parallel stage hangs on. With two or more boosters, a mass at a station sits as far off the axis as that stage’s own parts’ center. No probe has a part off the axis on that stage (a launch lug, say), so whether OpenRocket’s point follows the boosters there too is unmeasured (#1429 records it).
- An added mass above zero with no station, on parts that weigh nothing, has no center to sit at, and the layout refuses it. On the six probes of it with no center stated, OpenRocket puts it at the rocket’s tip, even for a lower stage that starts 0.8 m (2.6 ft) aft of the tip and for boosters 0.45 m (1.48 ft) aft. The tip is as far forward as a mass can sit, so no placement reads the stability margin higher, and it isn’t taken silently. On the two with a center that covers the parts beside the mass, OpenRocket puts it at that center. M2.3d12, an added mass on parts that weigh nothing settles both.
- Off the axis, two designs are all there is: one pod, where the stage’s parts’ center is 2.7 mm (0.11 in) off, and one booster, whose own center is 52 mm (2.0 in) off.
- A flight refuses a mass that moves, a mass that is released, or a parting through a stage, where that stage carries an added mass (M2.3d13, flights that move, release or part).
Reference diameter
maximum(the default): twice the largest outer radius of any body component in any stage, including a bulged ogive’s peak (Profile::max_radius_m). Internal parts, shoulders, fins, tube fins, lugs and rail buttons never count. In Loft, the project before FusionSpace HPR, an internal part could set it (Loft lesson L47).nose_base: the first nose cone’s base diameter.custom: a given diameter.
The reference area is .
Motors, pods and stages
How motors, clusters, pods and parallel stages join the rocket.
Motors and configurations
- A
MotorMounton a body tube or inner tube holds a motor. Itsoverhang_mis how far the nozzle exit sits aft of the mount’s aft end. A mount that is a cluster of tubes holds the motor in every tube (below). - A
Configurationputs at most oneMountedMotorin each mount. A mounted motor is aSolidMotorwith its case diameter and length (for the checks). It can have an ejection delay, the time from burnout to its ejection charge, which doesn’t delay ignition. It also has itsignition: at launch unless told otherwise (Staging). - The motor’s axis runs forward from the nozzle exit (Solid motors). With the station of the mount’s aft end, the nozzle exit is at station , on the mount’s axis. For an inner tube offset from the body axis at angle (from toward ), that is at . Otherwise it is on the body axis. A motor element at along the motor’s own axis is at body .
- At time ,
Assembly::mass_properties(t)combines the structure with each motor’sSolidMotor::state(t).total([MK]), every motor lit at .Assembly::mass_properties_littakes each motor’s own ignition time: a motor burns on its own clock, , and one not yet lit is loaded. The dry assembly uses each motor’s dry element. - In a flight, each burning motor’s thrust points along the rocket’s axis () and acts at its
own nozzle exit. The thrusts and their moments are summed
(Rigid-body flight):
- A cluster is flown, whether its motors share one mount (below) or each has its own. A motor off the body axis adds a turning moment.
- A two-stage design fires in sequence when its motors are given their ignitions, and drops its booster at a separation (Staging). Its design file alone lights every motor at launch, booster and sustainer together, unless it says otherwise.
- RocketPy’s
total_mass(t)andcenter_of_mass(t)[RP] are this same combination. RocketPy names the moment of inertia in pitch and yawI_11and the one in rollI_33. ItsI_11(t)is taken about the center of dry mass (the rocket without propellant), so HPR Sim’s tensor is moved there before comparing.I_33sums the axial moments (every element is on the axis).
Clusters
A cluster is several like motors side by side. In HPR Sim it is one inner tube repeated. The tube’s
cluster_m lists each
tube’s axis, [x, y] in meters in body axes. Each is measured from the point the
tube’s radial_offset_m and angle_rad set (the body’s axis when both are 0). An empty list is
one tube.
Motors of different kinds need one mount per kind. The decision record is ADR-075.
In a JSON design, the inner tube and the mounted motor are written as usual. A mount of three tubes 25 mm (0.98 in) from the axis, with the first tube’s motor out, adds these two fields:
"cluster_m": [[0.025, 0.0], [-0.0125, 0.021650635], [-0.0125, -0.021650635]]
"failed_tubes": [0]
- The tube weighs all its copies, each with its own parallel-axis term . Whatever the tube holds (an engine block, a mass) is repeated in every tube the same way. A mass override on the cluster sets the whole cluster’s mass. One on a part inside it (its mass, center or inertia) sets each copy’s, as OpenRocket does for the mass.
- The configuration names one motor for the mount. Placing it gives one motor per tube, one after another in the order of the tubes, each nozzle on its tube’s axis. Their thrusts, masses and moments add up like any other motors’.
- A mounted motor’s
failed_tubesnames tubes whose motor never lights (a motor out), counted from 0 in the order ofcluster_m. That motor stays loaded and pushes nothing, which is how a cluster most often fails. The lit motors then push off-center, and the rocket turns toward the motor that is out. - Every tube’s motor counts as a motor, so a cluster of three before another mount moves that mount’s motor from index 1 to 3. An ignition on the cluster’s burnout takes its first motor that lights. A recovery trigger or separation on one motor’s burnout or delay (recovery) waits on that motor alone. Point it at a tube that lights, or with that motor out your parachute never opens.
- The
.orkreader turns OpenRocket’s named pattern into the list (.orkdesign files).
Worked example. The tests’ single-stage rocket
(synthetic-54mm-three-fin)
has its mount made a ring of three tubes, with a Cesaroni 411I175-14A in each. The tubes sit
from the axis, at 0°, 120° and 240°. The angles are measured from the body’s
axis toward its axis, as in frames. It is an equation check, not a buildable
rocket. Three 38 mm motors don’t fit a 54 mm (2.1 in) body, and the design checks say so. It is
held at rest in a vacuum, so no air and no motion add anything to the motors’ push. With the motor at 0° out, 1 s into the burn:
| quantity | value |
|---|---|
| each lit motor’s thrust , in a vacuum | 193.98 N |
| the loaded motor, and each lit one at 1 s | 0.4375 kg, 0.3332 kg |
| the rocket’s mass | 1.584 kg |
| center of mass across the axis, (the loaded motor pulls it toward itself) | 1.33 mm (0.052 in) |
| pitch moment about the center of mass | 4.396 N m |
| pitch inertia about the center of mass | 0.1052 kg m² |
| pitch acceleration , at rest | 41.80 rad/s² |
The center of mass moves toward the loaded motor:
is 1.32 mm (0.052 in). The structure’s own center, 0.10 mm (0.0039 in) off the axis from its rail
buttons, adds the rest. The two lit motors sit at each, so about the center of mass
their thrust has the lever twice. The flight’s equations give the same angular
acceleration to 3.7e-7. There the full inertia tensor, not only , turns the moment into a turn. The 3.7e-7 difference is the
mass-flow terms: the center of mass moving as two motors burn and one doesn’t, and the jets. With
all three lit, the thrusts balance. The rocket then turns 225 times slower (0.186 rad/s²), from
its center of mass sitting 0.033 mm (0.0013 in) off the axis. The numbers are pinned by the test
cluster_motor_out_produces_pitch_moment in fusionspace-hpr-sim.
Pods
A pod is a body beside the airframe: a side pod, or an outboard motor pod. In HPR Sim a
PodSet is attached to a body tube like a fin set,
with a position along it. Its children are the pod’s own body components (a nose cone, body tubes,
a transition). They stack aft from that position along the pod’s axis, and take their automatic
radii from one another as a stage’s do. Parts go on and inside them as on the airframe: fins on a
pod’s tube, a mass or a motor mount inside it. A design with pods flies
(aerodynamics: Pods; pods fly). The decision records are ADR-089 for
the layout and weight, and ADR-092 for the aerodynamics.
-
A pod set holds
countpods, 1 to 64, spaced evenly around the body’s axis atradial_offset_mfrom it. The first is atangle_radfrom the body’s axis toward its axis (frames). Pod is at , with . -
Each pod is the first one turned. The pod written in the tree is one pod on the body’s axis. Pod is that pod turned by about the body’s axis, then moved out, as a fin set’s fins are. So whatever it holds keeps its place relative to the airframe. A fin that points away from the airframe on one pod points away on every pod. A symmetric pod set keeps its center of mass on the axis.
-
Each copy is weighed where it sits, with its own parallel-axis term, and everything the pod holds is repeated with it. The pod set itself weighs nothing.
-
A pod’s body tube may have length 0, and then it weighs nothing. OpenRocket draws winglets this way: a pod of one such tube, with no radius, which it calls a “phantom body” (
.ork: Pods). Parts on the tube sit at its radius, as on any tube. That radius is usually 0, so the parts sit on the pod’s own axis. Fin roots sit there, and a lug’s axis its own radius out from it.- A worked example: two pods 50 mm (2.0 in) from the body’s axis each hold a launch lug turned
180°, inward. Each lug is 4 mm (0.16 in) in radius, and its axis is 46 mm (1.8 in) from the
body’s. The test
a_pod_of_no_length_holds_its_parts_at_the_pod_s_axisworks the pair’s inertia out by hand. - Three or more fins whose roots meet on the axis overlap there. Each fin is weighed as a whole plate, so the overlap counts more than once, as it does in OpenRocket. The overlap is about a fin’s thickness across, so it grows with thickness over span. For three fins 3 mm (0.12 in) thick and 20 mm (0.79 in) tall it is a few per cent of their mass. That is an estimate, not a measurement.
- A body tube of no length is allowed only in a pod; a stage refuses one. A pod refuses a nose cone or a transition of no length. A pod mixing a tube of no length with other parts lays out, but no probe has checked it against OpenRocket.
- A worked example: two pods 50 mm (2.0 in) from the body’s axis each hold a launch lug turned
180°, inward. Each lug is 4 mm (0.16 in) in radius, and its axis is 46 mm (1.8 in) from the
body’s. The test
-
An empty pod set holds nothing, lays out, and weighs nothing.
-
A mass override on the pod set is the total for all its pods. It must be set with
overrides_include_children. An override on the pod set alone is refused, since the set has nothing of its own. An override on a part inside a pod is that part’s in each pod. A center overridecg_xy_minside a pod is measured in the pod as written, on the body’s axis, and turns with each pod. So does an inertia override’s tensor. The testwhat_a_pod_holds_turns_with_it_and_overrides_keep_their_scopepins all three. -
A motor mount inside a pod gives one motor per pod, each nozzle on its pod’s axis. The configuration names the mount by its id: the pod tube’s, for a pod that is its own motor tube. A mounted motor’s
failed_tubescounts the pods, in order from the first. -
A pod may run past the end of the tube it hangs from, or past the rocket’s end, without a warning. A pod is held by a pylon, and an outboard booster often extends past the tube it hangs from. A pod set that doesn’t touch its tube at all is still an error. A pod set in a pod is refused.
-
In flight, a pod’s parts add their normal force and drag once per pod, on the rocket’s axis at their stations (aerodynamics: Pods). Canted fins on a pod and a pod’s tube of no length with a radius are refused. The tumble model counts each pod’s tubes and fins as the airframe’s (recovery). An empty pod set adds no force and no drag area. Motor mounts may sit in up to four pod sets. Each set’s burning motors come off its own pods’ bases (aerodynamics: Pods). A rocket with motor mounts in more is refused. Until M4.5i, motor mounts in a second pod set were refused.
-
What it can’t do yet:
- Move or release a part inside several pods. A moving or released part must be one part, so it can be inside a pod only when there is one pod.
- Part at a pod. A pod’s body component is neither a joint nor an ejected payload. It stays with the tube its pod set hangs from.
- Check a pod’s geometry. Nothing warns when pods overlap the airframe or each other, or when a pod’s radius steps (#206).
The refusals are pinned by tests in
hpr-aero(unsupported_inputs_are_refused) andfusionspace-hpr-sim(a_pod_s_parts_are_located_as_the_airframe_s_are,partings_the_design_cant_make_are_refused).
In a JSON design, this component goes in a body tube’s children list (angle_rad is optional
and 0 by default). It holds two pods 50 mm (2.0 in) from the axis. Each is a 0.3 m (0.98 ft) tube,
0.1 m (0.33 ft) aft of the top of the body tube:
{
"id": "pods",
"part": { "pod_set": { "count": 2, "radial_offset_m": 0.05, "angle_rad": 0.0 } },
"position": { "from": "top", "aft_offset_m": 0.1 },
"children": [
{
"id": "pod-tube",
"part": {
"body_tube": {
"length_m": 0.3,
"outer_radius_m": 0.012,
"thickness_m": 0.001,
"material": { "name": "cardboard", "density": { "kind": "bulk", "kg_m3": 790.0 } }
}
}
}
]
}
Worked example. The same two pods sit at 0° and 180°. Each is a cardboard tube (790 kg/m³, radius 12 mm (0.47 in), wall 1 mm (0.039 in), 0.3 m (0.98 ft) long). A 50 g mass is added inside each, a solid cylinder 0.1 m (0.33 ft) long and 8 mm (0.31 in) in radius. Its top is 0.02 m (0.066 ft) below the pod’s. The pods hang on the tests’ 54 mm (2.1 in) airframe, 27 mm (1.1 in) in radius. So each stands 11 mm (0.43 in) clear of it. They hang from a body tube whose top is 0.2 m (0.66 ft) aft of the nose tip. The pod starts 0.3 m (0.98 ft) aft of the nose tip (at station 0.3 m (0.98 ft)). Each pod, about its own axis and center:
| quantity | value |
|---|---|
| the tube’s mass | 17.125 g |
| one pod’s mass (tube and mass) | 67.125 g |
| its center, from the tube’s at station 0.45 m (1.5 ft) and the mass’s at 0.37 m (1.2 ft) | station 0.39041 m (1.2809 ft) |
| its roll inertia, the two cylinders’ and added | 3.869e-6 kg m² |
| its pitch inertia, each cylinder’s and its own | 2.53675e-4 kg m² |
Each pod’s axis is off the body’s. A pod’s parallel-axis term about a line through the body’s axis is times the square of the pod’s distance from that line. Both pods lie on the axis, so they add nothing about it. About the and axes they add = 1.6781e-4 kg m² each:
| quantity (the two pods about their joint center, on the axis) | value, g or kg m² |
|---|---|
| mass | 134.25 g |
| : no | 2 × 2.53675e-4 ≈ 5.0735e-4 kg m² |
| 2 × (2.53675e-4 + 1.6781e-4) ≈ 8.4298e-4 kg m² | |
| (roll) | 2 × (3.869e-6 + 1.6781e-4) ≈ 3.4336e-4 kg m² |
The pods’ roll inertia is 44 times what it would be with both on the axis: nearly all of it is the
parallel-axis term. The test a_pod_is_its_stack_repeated_with_its_parallel_axis_term in
hpr-design pins these to 1e-15. It also pins a single pod at 90° (), with its center at
. About the nose tip, the pod’s
product of inertia is = 0.067125 × 0.05 ×
0.39041 = 1.3103e-3 kg m².
Parallel stages
A parallel stage is a stage strapped beside the airframe instead of stacked behind it. It is a set
of boosters around a sustainer, burning beside it and dropping at a separation of their own. In
HPR Sim it is a Stage whose parallel field is set
(a ParallelStage). That field gives the id
of the body tube it hangs on, in an axial stage before it, and where along that tube. It gives the
copies as a pod set’s count, distance from the axis and angle. Its own components are
each copy’s body: a stack of nose cones, body tubes and transitions. They carry parts on and
inside them, as a pod’s do. The decision record is ADR-171, and
M4.5m shipped it.
- The layout hangs the stage on its tube as a pod set, so everything in Pods holds. A parallel stage doesn’t stack: the rocket’s length is the axial stages’.
- Its parts carry its stage’s index, and its mass and ends count to that stage, not to the tube’s.
PlacedStage::hung_onnames the stage it hangs on. The rocket’s mass, center and inertia are the same as with the same pods hung on the tube. - A separation after stage drops every stage after , so the stages it drops must hang
together. Each one’s carrier, its
hung_onstage or the axial stage before it, is among them, or it is the first dropped. A parallel stage hung on a stage the nose keeps can’t go with an axial booster behind it. Drop the booster first, then the parallel stage (Staging: Boosters beside the core). - A parallel stage placed
aftera sibling is refused (it sits along its tube). So is one that hangs on no body tube of an earlier axial stage, and, as for any pod set, one inside a pod. So is a mass override that covers what its tube holds, or the whole stage the tube is in. So is a drag override on a parallel stage or covering the stage it hangs on. None of these overrides says whether it covers the parallel stage. OpenRocket 24.12 takes a stage’s covering mass or center as the rocket’s while the boosters hang there and as the stage’s once they are gone, which one body for each stage can’t give. Its six probes are recorded in #1429, beside the work of M2.3d11, the stage a parallel stage hangs on, which doesn’t include them. No probe has measured how it reads a tube’s covering override there, or a drag override. - A mass override on the parallel stage itself is its total, every copy’s, and its added mass is one point for the set (A stage’s added mass). Both are measured against OpenRocket 24.12, with three boosters and with one.
Worked example. Make the two pods of Pods’ worked example a parallel stage instead
(134.25 g, at 0° and 180°, 50 mm (2.0 in) from the axis). The stage weighs 134.25 g. The airframe
tube’s mass with its children is 134.25 g less than with the pods hung on it. The rocket’s mass,
center and inertia are the pod set’s to 1e-15. The test
a_parallel_stage_lays_out_as_a_pod_set_of_its_own_stage pins this for one, two and three
copies, and a_parallel_stage_hangs_on_a_body_tube_of_an_earlier_axial_stage pins the refusals.
In a JSON design, the stage goes in the rocket’s stages list after the stage it hangs on. It is
flown as any stage is: a motor in a mount inside it, and a separation after the stage it hangs
on. Staging: Using it today has a whole two-stage design to start
from. This one is the worked example’s, empty but for each copy’s tube. It hangs 0.1 m (0.33 ft)
aft of the top of the body tube airframe:
{
"id": "pods",
"components": [
{
"id": "pod-tube",
"part": {
"body_tube": {
"length_m": 0.3,
"outer_radius_m": 0.012,
"thickness_m": 0.001,
"material": { "name": "cardboard", "density": { "kind": "bulk", "kg_m3": 790.0 } }
}
}
}
],
"parallel": {
"on": "airframe",
"position": { "from": "top", "aft_offset_m": 0.1 },
"pods": { "count": 2, "radial_offset_m": 0.05, "angle_rad": 0.0 }
}
}
Checks and verification
What a design is checked for before it flies, and the tests that pin the tree.
Checks
checks::check resolves a design and returns typed
Findings. Each is an error (impossible as
described, so a simulation would be wrong) or a warning (unusual, but it can be built and flown).
Lengths compare with 1 nm of slack (LENGTH_TOLERANCE_M), so round-off never
raises one.
| finding | severity | when |
|---|---|---|
motor_wider_than_mount | error | case diameter > mount inner diameter, past the slack a nominal size has (Loft lesson L50) |
motor_outside_mount | error | the case doesn’t overlap its mount along the axis at all (an overhang typed in mm as m) |
attachment_off_body | error | an external part’s extent (a fin root) doesn’t overlap its body tube at all (Loft lesson L50) |
part_outside_rocket | error | an internal part lies wholly forward of the nose tip or aft of the rocket’s end, and touches none of the parts it hangs from |
internal_part_wider_than_parent | error | an internal part reaches farther from its parent’s axis than the parent’s bore (in a nose cone or transition, the most room along the part) by more than the fit tolerance for the bore’s size, and is no cap at its parent’s end, nor a packed part whose center is in the bore. A ring around its tube is measured in the part around it |
center_outside_rocket | error | a stage with an axial center-of-mass override (cg_aft_m, its own or a component’s) has its center off the rocket although its parts aren’t |
motor_tight_in_mount | warning | the motor’s nominal diameter is wider than the mount’s bore, but its real case fits: a 29 mm motor in a 1.140 in tube |
motor_past_mount_top | warning | the case’s forward end is forward of the mount’s |
motor_into_block | warning | the case reaches more than 1 mm (0.039 in), BLOCK_OVERLAP_TOLERANCE_M (the step most of the catalog’s case lengths are stated to), past the aft face of a part attached to its mount whose bore is narrower than the case, with that face forward of the nozzle: an engine block, forward thrust ring or bulkhead. The real case stops at the aftmost such face, the one named |
attachment_past_body_end | warning | an external part runs past an end of its body tube |
internal_part_past_parent_end | warning | an internal part runs past an end of its parent |
internal_part_tight_in_parent | warning | an internal part other than a packed part reaches past its parent’s bore by no more than the fit tolerance: a fit to sand |
internal_part_wedged_in_parent | warning | an internal part other than a packed part fits a nose cone or transition where it is widest along the part, but runs into its wall where it narrows, past the fit tolerance |
packed_part_wider_than_parent | warning | a packed part (a mass component, parachute, streamer or shock cord) reaches past its parent’s bore, by any amount, with its center inside the bore |
ring_against_parent_end | warning | a centering ring or bulkhead too wide for its parent’s bore sits at the parent’s end face and fits what holds the parent: a cap glued against the end |
cluster_tubes_overlap | warning | two tubes of a cluster are closer than a tube’s diameter, so they cross and that mass counts twice |
ring_overlaps_inner_tube | warning | a centering ring crosses an inner tube beside it (a cluster’s off-axis tubes), counting that mass twice |
radius_step | warning | adjacent body components’ radii differ where they meet |
no_nose_cone | warning | the first body component isn’t a nose cone |
- A part’s radial reach is measured about the parent’s own axis: the distance between the part’s axis and the parent’s, plus the part’s radius. A part inside a clustered tube is measured in that tube, and copied to each of the cluster’s places. A block centered in an off-axis pod fits; a part on the body axis inside that pod doesn’t. Centering rings have no offset, so they sit on the body axis.
- Parts wholly outside the rocket report only
part_outside_rocket, and a stage holding one is sparedcenter_outside_rocket. A single check covers each fault. - A retainer on a motor mount that sticks out past the airframe touches its mount. So it is on the
rocket, even flush against the mount’s end. Only the mount gets a warning. Touching an end face
counts as touching, within
LENGTH_TOLERANCE_M, for every part. - Fins may sweep past the rocket’s end, and a heavy part may run past its tube’s. So a stage’s
center can leave the rocket without an override. Neither a mass override nor a sideways center
override (
cg_xy_m) can move a center past its parts. It is an error only when an axial center override (cg_aft_m) is involved. No component-level center is checked.
Wider than its parent
A part drawn a little wider than the bore it sits in is a fit the builder sands. The simulator flies
it and warns, internal_part_tight_in_parent, and the mass where the part crosses its parent’s wall
counts twice. How much wider is the fit tolerance
(fit_tolerance_m): the general tolerance
ISO 2768-1 sets for a dimension of the bore’s diameter, in its coarse class:
- ±0.5 mm (0.020 in) for 6 to 30 mm (0.24 to 1.2 in);
- ±0.8 mm (0.031 in) for 30 to 120 mm (1.2 to 4.7 in);
- ±1.2 mm (0.047 in) for 120 to 400 mm (4.7 to 16 in).
A bore made at its upper limit and a part made at its lower one close a radial overlap of that
much. The standard is for machined parts. No standard covers hobby airframes, so the simulator
borrows its coarse class (the decision on which fits warn). Past the tolerance, the
part can’t be where it is drawn: an error, internal_part_wider_than_parent, unless it is a
packed part. Fix it by typing the part’s diameter to fit
the bore, or by choosing a part that fits. An outside diameter typed for an inside one is the
usual slip.
- OpenRocket’s 3D printable nose cone and fins has a coupler 24.10 mm (0.95 in) across. It sits 11.4 mm (0.45 in) deep in a printed fin can with a 23.19 mm (0.91 in) bore. The coupler’s wall reaches 0.46 mm (0.018 in) past the bore. That’s within the 0.5 mm (0.020 in) of a 23 mm (0.91 in) bore, so it warns. The ring of PETG where they cross is 0.46 mm (0.018 in) thick and 11.4 mm (0.45 in) long. It’s 0.39 cm³, 0.48 g at the file’s 1,250 kg/m³, counted twice.
- A cap is a centering ring or bulkhead on its parent’s axis that covers one of its parent’s
end faces, not both. It can sit inside or outside the end. It can be glued against the end, so
it needs room in what holds its parent instead: that holder’s bore, with the same tolerance. It
warns,
ring_against_parent_end. OpenRocket’s Two stage high power rocket draws its bulkheads this way. They are sized to the airframe’s 49.53 mm (1.9 in) bore, on the ends of couplers whose bore is 48.44 mm (1.9 in). The same bulkhead away from the coupler’s ends would be an error, and so would a tube, which can’t be a cap. So would a ring at the end of a clustered or off-axis tube, which sits beside the tube, not around it. - A ring around its tube is a centering ring written as a child of an inner tube, on the tube’s axis. Its bore is at least the tube’s outside diameter. It wraps the tube rather than sitting in its bore, as OpenRocket’s two pods examples draw the rings on their motor mounts. So it needs room in the part around the tube, at the ring’s own station. That’s the first part out from the tube with room for parts whose length overlaps the ring’s. That part must hold the whole ring, with the same tolerance. The findings name that part, and the ring is checked against the other tubes in it for overlap. Pods--airframes and winglets draws rings 32.54 mm (1.3 in) across with an 18.75 mm (0.74 in) bore. They sit on an 18.69 mm (0.74 in) motor mount, inside an airframe with a 32.59 mm (1.3 in) bore, and they fit. Read as inside the mount, whose bore is 18.03 mm (0.71 in), they would be an error.
- A ring that isn’t around its tube is measured as a part in the tube’s bore. For a ring this
wide, that is an error. Such rings are:
- one whose bore is even 1 µm smaller than the tube’s outside;
- one on a tube that is off the axis or a cluster;
- one with no part around it at its station that holds it whole. An example is a ring on a motor tube where it sticks out past the airframe’s end (a ring around its tube).
In a nose cone or transition
A nose cone or transition narrows along its length, so the room a part has depends on where it sits. This is a design convention, checked by unit tests and by counting findings over real designs. It isn’t compared with a built rocket or with OpenRocket. The simulator measures the room from the profile: the part’s outline, its radius against distance from the forward end. The room is the outer radius less the wall (none when the part is filled), over the part’s own length. It takes two numbers from it, the least room along the part and the most (#313, a part measured against the cone’s widest radius). Before that fix, the simulator used the largest outer radius anywhere on the part. So a bulkhead 20 mm (0.79 in) in radius passed at the tip of a cone 27 mm (1.1 in) in radius at its base. The cone has no room for it there. Drawn there, a part sits forward of where it can, which moves the center of gravity forward and raises the stability margin.
- Too wide where it is widest: a part past the fit tolerance of the
most room along it is
internal_part_wider_than_parent. That’s an error, as in a tube. - Wedged: a part fits where the profile is widest along it, but runs into the wall where it
narrows. Past the tolerance of the least room, that’s
internal_part_wedged_in_parent, a warning. It can’t slide that far in as drawn, and the simulator flies it where it is drawn. The usual case is a coupler (a short inner tube that joins two sections) drawn reaching into a nose cone from its base. - Packed parts are measured against the least room, with the packed-part rule. It’s a warning while the part’s center is in that room, and an error once it is out. A mass on the axis at a cone’s tip warns, since the room closes to nothing there and the mass’s center is on the axis. Off the axis it is an error.
- The wall is the thickness the design states, normal to the surface. So the outer radius less the wall overstates the room on a slope by . That’s 1% of the wall at 8°, and 0.1 mm (0.0039 in) of a 3 mm (0.12 in) wall at 15°. An automatic radius in a profile is already its room at the part’s narrower end, so it fits (automatic radii in a profile).
- Every profile the simulator draws is concave: its radius never dips between two stations. So the least room along a part is at one of its ends. The check samples 31 stations between the ends as well.
- A part running past the profile’s end is measured over the length inside it. One wholly past an
end, or touching it only, is measured against the largest outer radius, as before.
internal_part_past_parent_endalready names it.
A worked example. Take a conical nose 200 mm (7.9 in) long and 27 mm (1.1 in) in radius at its base. Its wall is 2 mm (0.079 in). It has of room at m from its tip. A tube 24.5 mm (0.96 in) in radius runs through its aft 100 mm (3.9 in). It has 25.0 mm (0.98 in) of room at the base and 11.5 mm (0.45 in) at its forward end. That’s 13 mm (0.51 in) too little. It’s wedged, a warning, far past the 0.5 mm (0.020 in) tolerance of the 23 mm (0.91 in) bore at its forward end. At 26.5 mm (1.0 in) the same tube is 1.5 mm (0.059 in) too wide even at the base. That’s past the 0.8 mm (0.031 in) tolerance of a 50 mm (2.0 in) bore, so it’s an error. The 25.0 mm (0.98 in) of room there is 50 mm (2.0 in) across.
On real designs. cargo xtask design-checks, a developer command in this repository, counts
the findings over the reference library (the release 0.1 decision has the table of
counts). Its default set is the repository’s gitignored folder of reference designs and
OpenRocket’s examples (72 designs that open). There this rule adds no error, only 3 more
tight-fit warnings, 1 wedged and 8 more packed-part warnings. On the private flight collection
(560 files that open, many of them versions of one design), it adds 16 errors in 11 files newly
refused. All are tubes too wide even at the profile’s widest. It also adds 14 tight-fit, 33
wedged and 240 packed-part warnings.
A packed part wider than its bore
A packed part drawn wider than its bore warns and flies as drawn. Its width changes only its own inertia. On the one OpenRocket example that has one, that moves the apogee by 12 µm at most.
A mass component, parachute, streamer or shock cord is a packed part (Packed parts). The simulator takes its mass as stated. Its packed length and station say where that mass sits. Its packed radius enters the flight in one place: the part’s own moment of inertia, that of a solid cylinder. That’s about its axis and across it, about its center.
- A packed part that reaches past its parent’s bore is
packed_part_wider_than_parent, by any amount, while its center is inside the bore. Its center is inside while its radial offset from the parent’s axis is no more than the bore’s radius. It can’t go in as drawn, and HPR Sim flies it as drawn, as OpenRocket does. Packed into the room it has, radius , at the same mass, length and station, it would change only the rocket’s moments of inertia. They would change by about its axis and across it. - The warning has no upper limit. A part can be typed far too wide, such as ballast 400 mm (16 in) across in a 54 mm (2.1 in) nose cone. It then adds inertia that packing it would not, and that changes how the rocket turns. Read the warning, and fix the part’s diameter if it is a slip.
- A packed part whose center is past the bore is an error,
internal_part_wider_than_parent, however little it reaches past. Its mass would sit where no part can be, moving the rocket’s center of gravity sideways. - A packed part’s mass doesn’t count twice where it crosses a wall, so it gets no fit tolerance (the decision on packed parts).
A worked example. OpenRocket’s Deployable payload packs its payload, 14.2 g, and its parachute 25 mm (0.98 in) across into a 21 mm (0.83 in) bore. Each reaches 12.5 mm (0.49 in) from the axis, with 10.5 mm (0.41 in) of room. Packing the payload into its room would take = 1.6e-7 kg m² off the rocket’s inertia across its axis. The parachute adds a term of its own. The file was flown both ways, with both parts narrowed in a copy. The five configurations’ apogees differ by 12 µm at most, 7.5e-8 of the apogee. Their landing times agree to 1 ms (the packed-part decision’s table).
A nominal motor in its matching tube
A motor’s diameter in the simulator is its nominal size, as ThrustCurve.org and RASP files give
it. So every 29 mm motor is flown as a 29 mm case. The cases are not all that wide. AeroTech’s RMS
dimensional drawings give the case’s outside to ±0.005 in. It’s 0.698 in for 18 mm motors,
0.938 in for 24 mm motors and 1.125 in for 29 mm motors. So a “29 mm” case is at most 1.130 in
(28.702 mm) across. A size whose case is narrower than its name gets that difference as slack
(motor_fit_slack_m). That’s 0.144 mm
(0.0057 in) for an 18 mm motor and 0.048 mm (0.0019 in) for a 24 mm motor. For a 29 mm motor it’s
0.298 mm (0.012 in). Within it, the check warns (motor_tight_in_mount). Past it, the real case
can’t go in and it is an error.
- LOC Precision’s 1.140 in (28.956 mm) motor tube bore is 0.044 mm (0.0017 in) under the 29 mm motor size. The largest case leaves it 0.254 mm (0.010 in) of clearance, so a 29 mm motor in it warns (OpenRocket’s Chute release). Issue #280 reported that such a motor was refused.
- The Loft demo’s 28.0 mm (1.10 in) bore is 1 mm (0.039 in) under the 29 mm motor size. It’s 0.70 mm (0.028 in) under the largest case: an error.
- The same drawings give 38, 54, 75 and 98 mm cases as 1.500, 2.125, 2.965 and 3.870 in. So at the +0.005 in limit each is at least as wide as its name. Those sizes get no slack. So a 38 mm motor in a 37.9 mm (1.49 in) bore is an error, as its 38.10 mm (1.500 in) case would be. Fix it with a wider mount or a smaller motor. The simulator doesn’t yet warn when a nominal size fits the bore but its wider case wouldn’t (#312). An example is a 38 mm motor in a 38.1 mm (1.500 in) bore.
- These are one maker’s cases, drawn in 2003 and 2004 and archived from its site in 2005 ([AT], under Code and sources). No published standard gives a diameter tolerance: the NAR’s motor testing manual lists the sizes only. A Cesaroni or other maker’s case may differ, and a diameter that isn’t a nominal size gets no slack.
Errors mark designs that can’t exist as described. A simulation of one would be wrong, usually
on the flattering side: Loft flew a 54 mm motor in a 38 mm mount 69% high. The flight engine
refuses them with SimError::DesignChecks
unless the caller sets
FlightSettings::accept_design_errors.
Verification
-
Placement and resolution, in
tree::tests:- each position rule at stations worked by hand;
- body components stacking through two stages;
- automatic radii across a stage boundary, the fallback, precedence and the unresolvable case;
- ring, shoulder and packed radii;
- every refused tree;
- a JSON round trip that refuses unknown fields.
-
Composition by hand:
tree_structure_matches_parts_placed_by_hand: the sample rocket’s structure equals its eight parts placed at hand-worked stations and combined, to 1e-13.config::tests: the placed motor’s nozzle station, and an off-axis mount’s . They also check the rocket’s mass, center and inertia at loaded, burning and burnt out, by the parallel-axis theorem, to 1e-12.
-
Clusters by hand:
parts::tests::a_cluster_is_its_tubes_each_with_its_parallel_axis_term: four tubes’ mass, center and roll inertia about the body’s axis, to 1e-15.tree::tests::a_cluster_repeats_what_it_holds_in_every_tube: an engine block in every tube of a 3-ring, the structure gaining two tubes and two blocks, and the checks’ warnings.config::tests: a motor in a 3-ring is three motors at their tubes, the rocket’s roll inertia gaining each one’s . A failed tube stays loaded and unlit, and a tube the mount lacks is refused. A sustainer lit by a clustered booster’s burnout lights with one booster motor out.hpr_sim::staging::tests: three motors’ thrust and mass summed, and the motor out above (cluster_motor_out_produces_pitch_moment, Loft lesson L31). It also checks a clustered sustainer lit after a powered separation.
-
Pods by hand, in
tree::tests:a_pod_is_its_stack_repeated_with_its_parallel_axis_term: two pods’ mass, center and inertia, and one pod off the axis with its product of inertia. They match the textbook cylinders’ sum above, to 1e-15.what_a_pod_holds_turns_with_it_and_overrides_keep_their_scope: a mass off a pod’s axis turning with its pod, a center override in the pod as written, and the two override scopes.pods_stack_hold_motors_and_refuse_the_wrong_trees: a pod’s nose taking its tube’s radius, its parts repeated in each of three pods, and a motor per pod. It also covers pods past the rocket’s end (no warning), this page’s JSON, and each refused tree.a_pod_s_nose_is_not_the_reference_nose: a pod’s nose is never the reference nose.
The aerodynamics refuses canted fins on a pod and a pod’s tube of no length with a radius. A mass shift and an ejection each refuse a part inside several pods, and a pod’s body component is never a joint or an ejected payload (above).
-
Overrides, in
overrides_rescale_move_and_replaceandnested_overrides_apply_deepest_first: each step, the scopes, a stage override and deeper overrides first. They also check the massless case, and refusal of non-finite and unphysical results. -
A proptest checks a rule on many random inputs. Randomly placed masses sum to the structure’s mass and center. Sliding every part moves the center rigidly without changing the tensor.
-
checks::testschecks each finding and its severity. A cluster pod’s block fits and an on-axis part in the pod doesn’t. Motors miss their mounts in both directions. Parts and a stage center lie off the rocket. A layout with a corrupt parent index is skipped, not a panic. A bulkhead 0.8 mm (0.031 in) wider than a 49 mm (1.9 in) bore warns, and 0.1 µm more errs. At the coupler’s end it is a cap up to the airframe’s bore plus its tolerance. Inside the coupler or as a tube it’s an error (a_part_wider_than_its_parent_warns_only_as_a_fit_or_a_cap). Each band edge of the coarse tolerance is pinned (the_fit_tolerance_is_the_coarse_general_tolerance_of_the_bore). A 29 mm motor warns in a 28.956 mm (1.14 in) bore and errs 1 µm past its slack. So do 24, 38 and 54 mm motors and a size that isn’t nominal (a_nominal_motor_in_its_matching_tube_only_warns). Mutation probes make these tests fail. They give the slack to every diameter, or double the tolerance. Or they allow a cap anywhere along its parent, off its parent’s axis, or over both ends. -
A 38 mm (1.5 in) case that reaches 10 mm (0.39 in) past the aft face of a block of 28 mm (1.1 in) bore at the mount’s top warns, with 10 mm (0.39 in) to move. So does a bulkhead 0.8 mm (0.031 in) thick that the case passes wholly, 90.8 mm (3.57 in) past it. Of two blocks the aftmost is named. A case that ends at the block’s face, reaches 1 mm (0.039 in) past it or passes its bore doesn’t warn, nor does a ring across the nozzle’s station (
a_motor_into_an_engine_block_is_found). Mutation probes that drop the bore comparison, the nozzle condition or the tolerance’s measure make it fail. -
Against RocketPy 1.13.0, in
config::tests::matches_rocketpy_example_rockets:-
Thirteen cases of the fixture
validation/fixtures/design/rocketpy-rocket-mass.json, from twelve example rockets (Calisto at two motor positions). Prometheus flies aGenericMotor, RocketPy’s motor described by its masses alone. Cavour, Genesis, Lince, Astra, Andromeda and Erebus 11 have no motor dry mass. Their designs give it 1e-15 kg, since HPR Sim needs a positive one.docs/research/rocketpy-rocket-mass.mdgives the curve substitution and the examples left out. -
The test derives the stage override, nozzle station and motor inputs from the fixture itself, not the design generator.
-
The rockets are compared at 103 even times through the burn and after it, and at up to 60 of RocketPy’s LSODA knots. The knots are the times at which its ODE solver, LSODA, computed the grain geometry. Errors are relative: to the value itself, or to what a row names in brackets (the rocket’s length for a center).
-
Worst measured, rounded up, with the test’s tolerance:
quantity worst tolerance, ratio dry mass, center, I_11,I_33; initial and column propellant mass3.5e-16 1e-12 products of inertia (of I_11)0 1e-15 at LSODA knots: total mass, center (of length), I_11,I_338.0e-10 1e-8 at LSODA knots: grain propellant mass (of initial) 2.5e-9 1e-8 even grid: total mass 1.4e-5 (Lince) 5e-5 even grid: center of mass (of the rocket’s length) 4.0e-6 (Erebus 11) 2e-5 even grid: I_11about the dry center and about the center of mass2.6e-5 1e-4 even grid: I_331.5e-5 1e-4 even grid: grain propellant mass (of initial) 6.4e-5 (Erebus 11) 2.5e-4 -
At RocketPy’s knots, agreement is the ODE solver’s own accuracy (rtol 1e-11).
-
Between knots, the residual is RocketPy’s resampling: it interpolates grain volumes linearly between LSODA knots and samples
GenericMotorinertias at thrust knots. HPR Sim’s values are exact for a piecewise-linear curve. -
The comparison sets mass, center and inertia together. So the override steps (rescaling the tensor with mass, moving the center) are checked by hand-worked tests, not against RocketPy.
-
-
The public designs are in
validation/designs/, written bycargo xtask designs, which a test keeps in sync. Seven RocketPy cases (not Cavour, Genesis, Lince, Astra, Andromeda or Erebus 11) and two synthetic rockets are tested. Each resolves with no findings and assembles into a valid body at ignition, mid-burn and burnout. -
Lessons: Loft lesson L47
tests::reference_diameter_ignores_internal_components; Loft lesson L50checks::tests::motor_wider_than_mount_is_rejectedandchecks::tests::fin_root_must_touch_body.
Nose cones, transitions and solids of revolution
See the nose cone and transition shapes HPR Sim supports, and how it finds each one’s volume, center of mass, inertia and surface area.
In short
- What it models: the outer shape of nose cones and transitions (conical, ogive, elliptical, power, parabolic and Haack series). For each, the volume, center of mass, inertia and surface areas, solid or as a shell of given wall thickness.
- Sources: G. A. Crowell Sr., The Descriptive Geometry of Nose Cones (1996), and appendix A of the published OpenRocket technical documentation v13.05 (2013).
- How well it is validated: by analytic tests, the first of four kinds of evidence, and against another code. Filled shapes match closed forms to 1e-10 (relative). They match independent high-precision integrals to 1e-12 on 22 noses and transitions, and 20 walls match to 1e-10. HPR Sim weighs three walled probe parts within 3.93e-5 (relative) of OpenRocket’s mass (the probes); the ogive’s, the largest, has no traced cause. The parts catalog’s noses and transitions are compared too (the masses against OpenRocket). Not compared with weighed parts or a real flight.
- What it leaves out: OpenRocket measures a wall across each station, not square to the surface. The two agree on a cone; on three blunt elliptical catalog noses this model weighs up to 0.48% more. HPR Sim also does not cut a steep end square to the axis, as OpenRocket cuts its probe transition. A square cut would add 1.28% and 2.29% of the wall in this page’s examples (Solids of revolution).
Code and sources
Code: hpr_design::shapes (profiles) and hpr_design::solids (volume, centroid, moments, areas).
Sources:
- [CR] G. A. Crowell Sr., The Descriptive Geometry of Nose Cones (1996), pp. 1–6 and 12–14. Cited, not pinned: the only copy found is on a plain-http university mirror, and the reference library pins over https. [TD] gives the same curves.
- [TD] S. Niskanen, OpenRocket technical documentation v13.05 (2013), appendix A, pp. 102–106,
pinned as
openrocket-techdoc-13.05. This is the published document, not the program’s source.
Profiles
A profile gives the outer radius at distance aft of its forward end, . Each shape is a normalized curve with at the tip and at the base:
| shape | or | parameter | source |
|---|---|---|---|
| conical | none | [CR] p. 1; [TD] A.1 | |
| ogive | , below | [CR] p. 4 | |
| elliptical | none | [TD] A.6 | |
| power series | [CR] p. 2; [TD] A.8 | ||
| parabolic series | [CR] p. 5; [TD] A.7 | ||
| Haack series | , below | [CR] p. 6; [TD] A.9–A.10 |
The ogive’s height and the Haack series are:
-
Ogive. The shape is Crowell’s secant ogive, an arc of radius through the tip and the base rim. Its radius is given as a multiple of the tangent radius .
- 1 is the tangent ogive, whose slope is zero at the base.
- Values above 1 meet the base at an angle.
- Values below 1 bulge past before the base.
- The arc reaches the tip only while its center is not above the axis, which needs .
The center is computed on the chord’s perpendicular bisector and the height as
which avoids the cancellation near the tip of a slender ogive.
-
OpenRocket’s ogive parameter is not adopted, because [TD] contradicts itself about it:
- A.3 defines it as .
- A.4–A.5 describe the first of a tangent ogive of length . At , , that has , not .
- The
.orkimporter reads it as A.3 defines it (the format guide). No probe design has run a secant ogive through the OpenRocket jar.
-
Haack. Monotone for , because
is the von Kármán (LD-Haack) ogive and the LV-Haack. [TD] limits to in the program.
-
A Haack nose or widening transition above has no drag data faster than sound. Nor does a bulged secant ogive (arc radius below the tangent ogive’s). So the simulator’s drag buildup has refused them since its extension through Mach 1. Their shapes, mass properties and center of pressure are unaffected, and a drag table stands in for the drag (Aerodynamics).
-
Elliptical, power-series () and Haack tips are blunt: their slope is infinite. (a flat cylinder) is rejected; model it as a tube and a bulkhead.
-
[CR] has errors. Its prose says “greater than twice the length” for the bulged secant ogive, against its own formula. Its ogive and ellipsoid areas are wrong, and the author marked them so. Its elliptical formula measures from the base, and its ellipse CP ratio should read . HPR Sim uses none of those.
Transitions
A transition runs from fore radius to aft radius over .
-
The shape’s tip lies at the smaller end. Growing aft, . A boattail is the mirror image,
[TD] doesn’t say how a shrinking transition is oriented. This choice keeps both ends’ radii exact and the profile monotone (a lesson from Loft).
-
A clipped transition ([TD] §A.7) is cut from a whole nose cone of base radius , where its radius is . The nose length is chosen so the piece is long.
- Shapes other than the ogive invert by bisection.
- The ogive’s curve depends on its fineness, so the nose length is found by bisection too.
- Conical and tangent-ogive transitions are the same clipped or not; the test checks this to 1e-12.
- A clipped ogive with is rejected: its profile isn’t monotone, so the cut is ambiguous.
Solids of revolution
Per unit density, with inner radius (zero when filled):
Each slice is an annulus: about the axis and about its diameter, moved to the reference plane by the parallel-axis theorem. excludes the end faces.
-
Each half of the profile is integrated from its own end in , where is the normalized distance from that end. The substitution removes the singularity of a blunt tip’s surface integrand, and measuring from the end keeps the tip exact. The integrals use
hpr_core::quadrature(Quadrature) at a relative tolerance of 1e-12. -
A wall of thickness is the part of the solid within of the outer surface (component geometry and mass properties). So is measured normal to the surface, which is how molded and laid-up shells are made. Its inner radius is the lower envelope of circles of radius on the profile, over :
with the minimum taken over the where . The surface is the profile over its own length, ends included, with no extension past a cut end.
- The envelope is exact for any continuous profile. Take a point above the lower half of some surface point’s circle. The profile crosses its height closer than , so it is in the wall anyway.
- Where the surface meets the end plane at an obtuse angle inside the wall, the rim’s circle
rounds the wall’s inner corner. That is the small end of a transition, or the base of a
bulged ogive.
- A square cut would add a sliver of of section per unit rim length, with the surface’s angle to the axis. That is 3.1e-4 at 7°.
- On steep ends it matters, here with . Cut square, a transition of radii 27 to 49 mm (1.1 to 1.9 in) over 15 mm (0.59 in, 56°) gains 1.28% of its wall. One of radii 20 to 37.3 mm (0.79 to 1.47 in) over 10 mm (0.39 in, 60°) gains 2.29%. Both are the sliver integrated around the rim, over this model’s wall; no test pins them.
- OpenRocket weighs its one probe transition, a shallow cone, heavier than this model by 2.85e-6 (relative). That is the sliver a square cut adds (the probes). No steep end or real part has been compared.
- The sliver grows without bound only as the end turns vertical. There, a square cut (made by extending the surface along its tangent) closes the end with a disc of thickness .
- The minimum comes from a 32-point scan, a golden-section search, and the two end points, which the search only approaches from inside.
- The hollow is integrated separately. It is split where reaches zero and where the nearest surface point moves between the lateral surface and a rim, since both are kinks.
- [TD] doesn’t say how OpenRocket measures thickness, and [CR] measures it radially. A radial wall differs from this one by a factor in wall volume, 1.4% for a cone three calibers (base diameters) long.
- OpenRocket’s masses follow a wall measured across each station, inner radius . On a straight profile that is this model’s wall: a probe cone of that shape weighs the same within 5.1e-7 (the probes). On a curved one they differ: this model weighs up to 0.48% more on three short elliptical catalog noses (the masses against OpenRocket). Whether that is the probe ogive’s 3.93e-5 is not traced.
Verification
- Closed forms (
shapes::tests::nose_volumes_match_closed_forms, 1e-10 relative):-
Every shape’s filled volume and centroid.
-
Cone and ogive: , , and from arc integrals.
-
Half spheroid: , and for prolate and oblate cases.
-
Power series: , , and the paraboloid’s .
-
Power series and parabolic series: and too; parabolic series by polynomial integrals.
-
Haack: and
integrated in .
-
Loft’s tangent-ogive value, , gives 6.7509e-4 m³ (a lesson from Loft).
-
- mpmath references (
solids::tests::filled_solids_match_the_mpmath_references):- 22 noses and transitions of every family, in both directions, clipped and not.
- All seven quantities, to 1e-12 relative (worst measured 2.4e-14).
- Reference:
validation/fixtures/design/shape-integrals.json, fromvalidation/oracles/design/shapes.py(40-digit tanh-sinh on the defining formulas, Haack in , with no code shared with Rust). - These references alone check the filled shapes’ moments of inertia, both Haack areas, and the wetted areas of two series: power () and parabolic.
- Walls against mpmath (
solids::tests::walls_match_the_mpmath_references):- 20 walls: 11 noses of every family, and 9 transitions both ways, including unclipped blunt ends and clipped ones.
- Volume, centroid and both moments to 1e-10 relative (worst measured 5.9e-12).
- Reference:
validation/fixtures/design/wall-integrals.json, fromvalidation/oracles/design/walls.py, which shares no code with Rust.- It finds the envelope from the roots of its derivative, bracketed from the window edges and solved by bisection.
- It splits the integrals at the kinks it finds, and requires every hollow integral’s error estimate below 1e-18.
- Reviews found three faults this test now pins:
- Blunt transition ends failed to converge, or were 5e-6 low, until the end points became candidates.
- The first version’s extensions along finite end tangents made wall mass jump by 8.3% between shapes whose end slopes rounded to finite and to infinite.
- The oracle itself first missed minima next to the window edge and left kinks unsplit.
- Walls by hand:
- A conical wall is the cone minus the same cone moved aft by : volume, centroid and
both moments by hand, to 1e-9. A cone so thick that its hollow is 3.8 mm (0.15 in) long matches the same
formula to 1e-12 (
a_nearly_filled_cone_matches_the_offset_cone). - A conical transition’s wall is the square-cut frustum shell less the fore rim’s sliver, in
polar coordinates about the rim. Its mass, centroid and sliver section match to 1e-10
(
mass::tests::hollow_transition_and_freeform_fin_cg_are_exact_centroids). - A tangent-ogive wall is bounded by the concentric arc of radius : volume by hand, to 1e-10.
- A tube matches the hollow-cylinder formulas.
- A wall thicker than the body fills it, and a thin wall’s volume tends to .
- A conical wall is the cone minus the same cone moved aft by : volume, centroid and
both moments by hand, to 1e-9. A cone so thick that its hollow is 3.8 mm (0.15 in) long matches the same
formula to 1e-12 (
- Each profile ends at 0 and , slopes match central differences, and parameters out of
range are errors (a lesson from Loft).
- Haack tips use and a Taylor series for below , so the tip slope is , never NaN.
- Ogive radius ratios up to 1e12 give the cone. A power series at the minimum exponent, 0.05,
matches its closed-form volume as a nose and as transitions both ways
(
extreme_parameters_stay_accurate_or_fail_loudly). - Unknown fields in a shape or wall are rejected.
- Transitions hit both radii and are monotone both ways, clipped or not (a lesson from Loft). Bulged ogives are excluded, because their profile is deliberately not monotone.
- Power-series exponents below 0.05 are rejected. Blunter profiles approach a flat face the integrals can’t resolve, and unclipped transitions below about 0.038 fail to converge.
Mass properties of components
See how HPR Sim finds each part’s mass, center of mass and inertia from its shape and material, and sums them for the rocket.
In short
- What it models: the mass, center of mass and inertia of each part, and their sum. The parts are tubes, rings, shoulders, fins and their fillets, rail buttons, lugs, mass components and recovery gear, with every tube of a cluster. There are 49 built-in material densities.
- Sources: Meriam and Kraige’s Engineering Mechanics: Dynamics, the OpenRocket technical documentation v13.05 and Abbott and von Doenhoff’s Theory of Wing Sections. Golub and Van Loan’s Matrix Computations gives the method for the principal moments. Densities come from data sheets, specifications and handbooks.
- How well it is validated: by analytic tests, the first of four kinds of evidence. A cone, a tube, four fins and an off-axis payload agree with hand calculation to 1e-11. Fin cross-sections agree with exact numerical integration to 1e-13. Density unit conversions reproduce their sources, such as the Wood Handbook’s white ash at 678 kg/m³. Against OpenRocket 24.12, on the structure (the rocket without motors) of 71 compared designs, the mass is within 1% on 70. The center of mass is within 1% of the rocket’s length on 70. The one file outside either has a named cause: airfoil fins, which OpenRocket weighs by a factor. Fin fillets agree with OpenRocket’s to 1e-15 in mass and center of mass on nine probe designs. The probes’ pitch inertia is up to 0.638% apart (below). The roll inertia is a median 1.619% apart, and that is explained. OpenRocket takes a shortcut for fins that HPR Sim does not. HPR Sim’s figure is the exact one for the fin as drawn (below). On the four files with a cluster (two designs by content), OpenRocket also stacks the tubes on the cluster’s axis (below). A ring of tube fins departs twice. For it, OpenRocket’s roll inertia is more than any mass inside the ring could have. OpenRocket’s pitch inertia leaves out how far the tubes sit from the axis. HPR Sim keeps its own for both (below). The pitch inertia is within 1% on 63. Of the 8 outside, the two copies of OpenRocket’s tube fin example are the tube fin departure, and the rest have no named cause yet. Not compared with weighed parts or a real flight (checked against OpenRocket).
- What it leaves out: the sliver between a flat fin root and the round tube, and the step ring
at a nose shoulder. Fillets are weighed, but the aerodynamics leaves them out
(Drag limits). Parachutes weigh as flat circular canopies. Where a
.orkfile leaves something unsaid (a wall of no thickness, no material), HPR Sim reads it as OpenRocket does. Two rules for overrides stay HPR Sim’s own, each measured (below). Fin sections are the simulator’s own too. An airfoil fin weighs 0.6851 of a square slab of its outline, where OpenRocket’s weighs 0.85. So HPR Sim’s airfoil fins are 19.4% lighter, with no warning (below). Packed recovery gear and mass components are OpenRocket’s too, down to the size one takes when its file writes none (below). A cluster’s inertia differs from OpenRocket’s on purpose. OpenRocket stacks the tubes on the axis, and HPR Sim weighs each where it sits (below). Some designs have parts the simulator does not read, such as a parallel stage on a rocket of several stages. They’re retained as reduced designs (the format guide), and none of the 71 compared is one. A parallel stage HPR Sim reads is weighed as its own stage (Parallel stages).
Code and sources
Code: hpr_design::mass (MassProperties), hpr_design::parts, hpr_design::fins,
hpr_design::material, hpr_design::materials. The nose and transition solids are in
Shapes.
Sources:
- [MK] J. L. Meriam and L. G. Kraige, Engineering Mechanics: Dynamics, appendix B (standard solids’ moments of inertia, the parallel-axis theorem and the inertia tensor).
- [GVL] G. H. Golub and C. F. Van Loan, Matrix Computations, 4th ed. (2013), §8.5 (the Jacobi eigenvalue method).
- [TD] S. Niskanen, OpenRocket technical documentation v13.05 (2013), §3.2.2, pp. 25–29 (fin
planforms), §3.4.4, pp. 49–50 (cross-sections), §4.2.3, p. 66 and Table 5.1, p. 75 (component
masses), pinned as
openrocket-techdoc-13.05. - [AvD] I. H. Abbott and A. E. von Doenhoff, Theory of Wing Sections, Dover (1959), eq. 6.2 (NACA four-digit thickness distribution).
The model
The conventions, the solids and fins each part is weighed as, and the materials.
Frames and conventions
These conventions were set in the decision on component geometry and mass properties.
- Body axes follow Frames: along the axis toward the nose, the zero radial direction, . Roll angles run from toward .
- A component’s frame has body axes, with its origin on the axis at the component’s forward end, or at a nose cone’s tip. So the component lies at . The design tree places it by translating it to its station (Design tree).
MassPropertiesholds the mass, the center of mass in body axes, and the full inertia tensor about the center of mass. The tensor is taken with the positive products-of-inertia convention: , so .- The operations follow [MK]:
-
Parallel axis:
with .
-
Rotation: , .
-
Combination: sum the masses, mass-weight the centers, and sum each tensor moved to the common center.
-
Zero total mass gives the plain average of the centers, so placeholders stay finite.
-
validaterequires a finite, non-negative mass, and a tensor that is symmetric (to 1e-9 of its largest entry) with non-negative principal moments obeying . That condition is the same as being positive semidefinite. Principal moments come from cyclic Jacobi ([GVL] algorithm 8.5.1). It’s accurate for repeated eigenvalues, where the closed-form trigonometric method loses .
Standard solids ([MK])
-
Hollow cylinder, radii , length : and
This covers body tubes, inner tubes and couplers, centering rings, bulkheads (), launch lugs, tube fins, and shoulders.
- is allowed. It’s a tube of no wall: mass is exactly zero, and so
is the tensor. That is a real thing for a design to say. An imported
.orksays it of twelve parts (.orkdesign files). Refusing it would force a reader to invent a wall instead. A centering ring is the exception. A bore that reaches the rim leaves no ring at all, soCenteringRingrefuses rather than weighing nothing in silence.Wall::Shellalso still refuses a zero thickness. A solid of revolution says “filled” withWall::Filled, so a zero there is a mistake, not a statement. - Loft used with no radial term, and no roll inertia at all (a Loft lesson).
- is allowed. It’s a tube of no wall: mass is exactly zero, and so
is the tensor. That is a real thing for a design to say. An imported
-
Solid cylinder, radius , height : and . This covers mass components, packed parachutes, streamers and shock cords, and each disc of a rail button. [TD] Table 5.1 treats recovery parts as cylinders too.
-
Rail button:
- Three coaxial discs stacked outward on a radial line: base (outer diameter), waist (inner diameter), flange (outer diameter).
- The waist height is the total height less the base and flange.
- The screw’s head, when there is one (
screw_height_m, 0 for none), is half a solid ellipsoid of revolution on top of the flange. It’s as wide as the button (, half the outer diameter) and the screw’s height tall. Its volume is , and its center of mass is above the flange. Its inertia is about its own axis and across it through its center. The last is half the ellipsoid’s about its base’s diameter, moved by the parallel-axis theorem. With these are a solid hemisphere’s textbook and . The head carries no drag, and OpenRocket’s comparison is below. - Buttons and lugs may repeat along the axis (
count,spacing_m).
-
Shoulder: a hollow cylinder beyond the profile’s end. A capped shoulder adds a disc of its inner radius and wall thickness, flush with its far end. The step ring between a nose’s base radius and its shoulder is not modeled.
-
Parachute: , the nominal area of a flat circular canopy plus its shroud lines. A conical or hemispherical canopy has more cloth than . Give its mass through an override (Design tree) or a matching nominal diameter.
-
Streamer: . Shock cord: .
Fins
-
Planforms ([TD] §3.2.2):
- Trapezoidal: root chord , tip chord parallel to the body, span , and sweep from the root’s leading edge to the tip’s.
- Elliptical: , centered on the root chord (implied by [TD] eq. 3.71).
- Freeform: a simple polygon from the root leading edge to the root trailing edge
, closed along the root through its root points. On a body tube the root is level,
with no root points. On a nose cone or a transition it follows the surface
(the decision on a fin root along the surface).
The heights are measured from the radius at the root leading edge. Each root point lies
within a micron of the surface. Crossing edges and points below the root leading edge are
errors. So are outlines that turn below their root or don’t run from the origin aft. The test
draws the cockpit of OpenRocket’s Pods--airframes and winglets through OpenRocket’s own root
points. Its area, mass and center of mass are OpenRocket’s to the six digits printed
(
fins::tests::a_root_along_a_nose_cone_is_openrockets).
-
Cross-sections. Each chord from to has a thickness distribution . [TD] uses the cross-section for drag only. HPR Sim also counts the volume it removes.
-
Square: .
-
Rounded: semicircular edges of radius , so a chord shorter than near a pointed tip is a disc of diameter . Its moments are closed forms in , for the removed edge material
and for . A wide rounded chord loses of section area.
-
Airfoil: with the NACA four-digit polynomial ([AvD])
- Its maximum is at .
- Its moments = 0.685083, 0.288033, 0.158919 hold term by term, and mpmath gives for .
- An airfoiled fin weighs 68.5% of the square slab, with its centroid at 42% chord.
- A hand-sanded “airfoil” is between the two. [TD] doesn’t define the section.
-
-
Integrals. Per fin, over the span with , and chordwise moments and , taken per unit density:
The span integration is split at every vertex height and runs adaptively.
- With the fin at roll 0 (points at ): , , and , all .
- Loft ignored the span (a Loft lesson) and fixed a freeform fin’s CG at (another).
-
Tabs are square slabs below the root, , with closed-form integrals. A tab is weighed over the length its design states, even where it starts ahead of the root or ends past it, as OpenRocket weighs one. OpenRocket trims two tabs to the root on loading, where the file’s rounded numbers pass it by under 0.03 mm (0.0012 in); HPR Sim keeps them as stated, a slab too small to show in a mass. A tab must meet the root over some length and reach no deeper than the body radius (a tab weighed as stated). Loft never read them (a Loft lesson).
-
The flat root is placed at radius . The sliver between it and the curved tube, deep, is ignored. Fillets are solids of their own (Clusters and fillets).
-
Cant turns each fin and its tab about the fin’s outward span axis through the root mid-chord, right-handed. So a positive cant turns fin 0’s leading edge toward (
positive_cant_turns_the_leading_edge_toward_negative_y). [TD] doesn’t state the pivot. Mass and trace are unchanged. The products of inertia in the fin’s own frame grow as . -
Sets roll the fin to and combine. Three or more fins are isotropic across the axis. One or two are not, and the full tensor keeps the difference.
Materials
Density is bulk (kg/m³), surface (kg/m²) or line (kg/m). A part asking for the wrong kind
is an error. A design stores the values, not a library key. The built-in values and their sources
are in hpr_design::materials and summarized below.
hpr_design::materials::BUILTIN holds 49 materials. Each carries its source (with table or page),
the URL it was read from, and a basis:
- published: the source states the value.
- derived: computed from the source’s numbers.
- maximum: a specification’s upper weight limit.
- vendor: a seller’s figure, used where no specification exists.
| group | values | sources | basis |
|---|---|---|---|
| hobby tubes | cardboard 790, kraft phenolic 950, Blue Tube 1,250, Quantum 1,090 kg/m³ | LOC Precision and Public Missiles weight tables (mass over wall volume); Always Ready Rocketry’s own material file | derived; published |
| composites | G10/FR-4 1,800, filament-wound E-glass 1,990, carbon/epoxy 1,580 kg/m³ | Norplex-Micarta NP130, Comptec, Hexcel HexPly 8552 data sheets | published |
| metals | Al 6061 2,700, Al 7075 2,800, steel 7,850, Ti-6Al-4V 4,430, brass 8,500 kg/m³ | Kaiser Aluminum, MIL-HDBK-5J, TIMET, Copper Development Association | published |
| woods | balsa 180; basswood, yellow birch, Sitka spruce, eastern white pine, sugar maple, northern red oak from ; birch plywood 680 kg/m³ | Wood Handbook FPL-GTR-190 (pinned as fpl-gtr-190-wood-handbook), p. 2-21 and Table 5-3a; Riga Wood Plywood Handbook | published; derived |
| plastics | PLA 1,240, ABS 1,040, PETG 1,270, nylon 6/6 1,140, PC 1,200, PMMA 1,190, acetal 1,420, PS 1,040, PVC 1,400, HDPE 955, epoxy 1,180, Depron 40, paper 755 kg/m³ | manufacturers’ data sheets (NatureWorks, SABIC, Eastman, Celanese, Covestro, Röhm, AmSty, Charlotte Pipe, Chevron Phillips, West System, Depron, HP) | published (paper derived) |
| fabrics | ripstop 1.1 and 1.6 oz/yd², Mylar and LDPE film at 1 mil, paper 80 g/m², Nomex cloth, silnylon | MIL-C-7020H, DuPont Teijin, Dow, HP, MIL-C-83429B; a seller for silnylon | maximum, derived, published, vendor |
| cords | nylon cord types I and III, tubular nylon ½“, 9/16“, 1“, ⅛“ and ¼“ Kevlar, ¼“ bungee, Tex 80 Kevlar thread | MIL-C-5040H, MIL-W-5625K, MIL-C-5651D, A-A-55220; Giant Leap Rocketry’s measurements for Kevlar | maximum, vendor, published |
- Wood at 12% moisture is (Wood Handbook eq. 4-12). The handbook’s own example, white ash at , gives 678 kg/m³.
- Specification maxima overstate typical cloth and webbing. Giant Leap’s measured 9/16“ tubular nylon is 12% under MIL-W-5625K’s limit.
- The openrocket-database (Apache-2.0) was used only as a cross-check. Two problems turned up in it:
- Its ripstop weights use 31 g/m² per oz/yd² (the factor is 33.906), so they are 8.6% low.
- Its “Plywood, aircraft” at 337–361 kg/m³ is lite-ply, not birch.
Compared with OpenRocket
How the masses compare with OpenRocket’s, and each rule where the two differ or a file is silent.
Checked against OpenRocket
In short. HPR Sim adds a design’s parts into its structure: every stage together, with no
motor. OpenRocket 24.12 computes the same thing. On September 21, 2026 the two were
compared on every file OpenRocket opens among the project’s .ork test files. One set is the reference library: designs
gathered under refs/, many of them private files other people shared. The other is the 17
example designs that ship inside OpenRocket’s program file (its Java jar). The current default
survey compares 71 designs. Some hold the same design found in two places (several private files
are copies of OpenRocket’s examples), so there are 51 different files by content. Mass and center
of mass agree closely on most, and every file outside 1% has a named cause. The roll inertia is a
median 1.619% apart. That’s OpenRocket’s shortcut for fins
(below) and, on the cluster designs, its stacking of their
tubes on the axis (below). The decision on this comparison records how it was
decided. The numbers below are from the current scratch-excluding rerun after HPR Sim
weighed every tube of a cluster
(below). Before that, the step on clusters and fillets
settled two more of the survey’s causes (next section).
What you can check yourself. The private files are not public, so only counts come from them.
A fresh clone can’t reproduce the 71-file table. It can check the probe tube and Loft’s public
demo designs (cargo test -p xtask ork_mass). It can run the script on .ork files of its
own to see OpenRocket’s numbers (Run it yourself, at the end of this section). Comparing
HPR Sim’s with them is not automated yet.
How. validation/oracles/openrocket/mass.py runs OpenRocket and asks it for each design’s
structure. It saves the design once first, so that every automatic dimension is the one OpenRocket
settles on. cargo xtask ork compares HPR Sim’s with it:
- the mass, relative to OpenRocket’s;
- the center of mass’s station, as a share of the rocket’s length;
- the roll inertia (about the rocket’s axis) and the pitch inertia (about an axis across it). Each is about the program’s own center of mass and relative to OpenRocket’s. Pitch is taken as the mean of the two inertias across the axis. That mean doesn’t depend on how either program turns its axes about the rocket’s length.
Which of OpenRocket’s numbers is roll was measured, not assumed. The script first reads a probe,
one tube of a material at 1,000 kg/m³. It’s 1 m (3.3 ft) long and 50 mm (2.0 in) in outer radius, with a 2 mm (0.079 in) wall.
Worked by hand, it weighs 0.61575 kg. Its roll inertia is = 0.0014790 kg·m²
and its pitch inertia about its middle is = 0.052052 kg·m².
OpenRocket’s numbers match to 15 digits, and so does HPR Sim’s layout of the same file (the test
the_probe_tube_is_the_one_worked_by_hand).
The thresholds, 1% of the mass and 1% of the length, were set before any design was measured. A design outside either needs a written reason, not a pass.
The results, as cargo xtask ork printed them on November 11, 2026, after a .ork stage’s
overrides left its parts in place.
| within 0.1% | within 1% | median | |
|---|---|---|---|
| mass | 64 of 71 | 70 of 71 | 0.001% |
| center of mass (share of length) | 67 of 71 | 70 of 71 | 0.000% |
| pitch inertia | 45 of 71 | 63 of 71 | 0.025% |
| roll inertia | 10 of 71 | 31 of 71 | 1.619% |
| roll inertia, OpenRocket’s fin shortcut in HPR Sim’s place | 64 of 71 | 64 of 71 | 0.000% |
Counting each file’s content once, 50 of 51 are within 1% in mass and 50 of 51 in center of mass.
On September 28, 2026, after HPR Sim read tube fins sized from the body,
60 and 68 of 71 were within 0.1% and 1% in mass. In center of mass, 65 and 68 were. Within 1%, 56
were in pitch inertia and 57 in roll inertia with the shortcut, at a median 1.686% without it.
Before tube fins were read, 58 and 66 of 71 were within 0.1% and 1% in mass, and 63 and 66 in
center of mass. Before fillets were weighed, 65 of 71 were within 1% in mass, 55 in pitch inertia, and 56 in
roll inertia with the shortcut.
Before HPR Sim read every tube of a
cluster, 58 and 59 of 71 were.
Before it read what a .ork leaves unsaid, 57 of 74 were
within 1% in mass and 58 in center of mass (median mass 0.020%). Those are the earlier
74-file measurement. The current default survey is the 71-file table above.
The 1 file outside a threshold is outside both, and has one cause. cargo xtask ork works the
causes out and counts them by content, as below. It fails if a file outside has none:
| cause | what HPR Sim does | what OpenRocket does | files by content |
|---|---|---|---|
| airfoil fin sections | integrates the airfoil’s section, 0.6851 of a square slab (below) | weighs the outline times the thickness times 0.85 | 1 |
The fin-section cause is sized, not only present. HPR Sim gives no warning for it, since the section
is HPR Sim’s own choice. So cargo xtask ork weighs the design again with its rounded and airfoil fins
weighed OpenRocket’s way: square, at 0.99 or 0.85 of their density. It names the cause only if the
design then comes within both thresholds. The one design it names is a private one: C06 in
HPR Sim’s flights of the private designs. There HPR Sim’s center of mass sits forward of
OpenRocket’s, and the same fins are a likely cause. But the survey’s thresholds are coarser than
that flight’s gap. So the fins are a lead for it, not its size
(the format guide).
Five causes are gone. A cluster read as one tube went when HPR Sim
read every tube of a cluster. The cause’s two files by content
are now within both thresholds. Pods went when HPR Sim read them.
Fin fillets, which HPR Sim left out, went when it weighed them
(below). Tube fins, which the simulator left out when OpenRocket sizes
them from the body, went when it read them
(below). OpenRocket’s Tube fin rocket, the one design with them, is now within
5.0e-6 of OpenRocket’s mass. Its center of mass is within 2.4e-6 of its length. Parallel stages,
which the simulator kept unread, went when it read them
(Parallel stages). OpenRocket’s Parallel booster staging, in the
jar and in the library’s copy, is now within 3.3e-6 of OpenRocket’s mass. Its center of mass is
within 1.3e-6 of its length. cargo xtask ork prints the file outside with the parts that differ
most, by id, or by name in an older file that writes no ids. A private design is named only by the
start of its file’s hash.
A worked example, now settled. In the first comparison
the OpenRocket jar’s Two stage high power rocket was 18.74% heavier in HPR Sim. It was 1.956 kg
in OpenRocket, and 0.3666 kg more in HPR Sim. All of it was the nose cone. Its shoulder is written
with a radius of 49.28 mm (1.9 in), a length of 50.8 mm (2.0 in) and a wall thickness of 0. HPR Sim read that as solid: a
cylinder of = 3.875e-4 m³ of the file’s own material, polypropylene at 946 kg/m³,
weighs 0.3666 kg. OpenRocket gives the same shoulder no mass, and so has HPR Sim since it
read what a .ork leaves unsaid. So the file is within 1% in
both mass and center of mass. Two causes the first comparison counted are gone the same way. One is
this shoulder of no wall (6 files by content), the other a part written with no material (1).
Two more conventions.
- Under a stage’s mass override HPR Sim scaled the stage’s inertia, and OpenRocket doesn’t. On
Loft’s public
stage-weighed.ork, whose stage override is about twice its parts’ mass, that was the first comparison’s largest inertia difference, and until November 11, 2026 its roll inertia, with OpenRocket’s fin shortcut, was still 104.78% over OpenRocket’s. The reader now gives such a stage the rule that keeps its parts in place, as OpenRocket does, and the survey no longer lists it among the files outside 1% in roll with that shortcut (A stage’s rule); a part’s mass override is still a departure kept on purpose (below). - HPR Sim’s airfoil fin section weighs less than OpenRocket’s. The CONTROL fins of the jar’s Simulation scripting example are 0.0378 kg in HPR Sim and 0.0469 kg in OpenRocket, 19.4% lighter, with no warning. It is a departure kept on purpose (below), and the cause of the one private design above.
Roll and pitch inertia. On the six Loft demo designs OpenRocket opens, the roll inertia is 1.2%
to 3.8% apart. Yet their mass, center of mass and pitch inertia agree within 0.1%, and every part
of each is within 0.3 g of OpenRocket’s. Across all 71 compared designs the median is 1.619%. It
is the fins. OpenRocket takes a shortcut for a fin set’s roll inertia, and HPR Sim integrates the
fin exactly (below). With OpenRocket’s shortcut in HPR Sim’s
place, the median is 0.000% and 64 files are within 1%. The shortcut takes OpenRocket’s own mass
for each fin set, paired by id, or in an older file by name. So the way OpenRocket weighs a section
(below) is set aside too. Five of the six Loft demos come within 0.0005%. The sixth, whose fins are
elliptical, is 0.093% apart in that row. It’s within 0.0002% once OpenRocket’s ellipse is drawn as
OpenRocket draws it, a 30-sided polygon (a test). For each of the 7 files still outside 1% (4 by
content), cargo xtask ork names a cause, and it fails if it can’t. Each has exactly one:
| cause | files by content |
|---|---|
| a mass override covering the parts inside (a departure, below) | 1 |
| tube fins, whose roll inertia is a departure (below) | 1 |
| a cluster’s tubes, which OpenRocket weighs stacked on the cluster’s axis (below) | 2 |
The cluster cause is sized, not only present. The survey names it only when HPR Sim’s roll inertia, less the spread of the clusters’ own tubes, is within 1% of OpenRocket’s. The two are +1.01% and +2.08% apart, and +0.04% and +0.00% without the spread.
The pitch inertia is within 1% on 63 of 71. Two of the 8 outside are the two copies of OpenRocket’s Tube fin rocket, 1.98% below. OpenRocket’s pitch rule for tube fins accounts for that gap (below). The other 6 have no named cause yet, and no bound is known. On the fin probes below, pitch differs by up to 0.41% where the fins weigh the same.
What it leaves out. Motors: this is the structure alone, and a motor’s mass is left to the milestone on the motors OpenRocket flies. Only the design’s selected configuration (the one OpenRocket opens it with) is weighed. The 4 files OpenRocket 24.12 does not open are not compared.
Run it yourself. CI does not run OpenRocket. It holds HPR Sim to OpenRocket’s saved answers for
Loft’s seven public demo designs, validation/fixtures/ork/openrocket-mass-loft-demo.json, with
cargo test -p xtask ork_mass. OpenRocket opens six of the seven. On those six HPR Sim is within
0.1% in mass, center of mass and pitch inertia, and every part of each within 0.3 g. With
Java 17 and the OpenRocket jar (cargo xtask refs fetch), from the repository root:
refs/venv/bin/python validation/oracles/openrocket/mass.py \
validation/fixtures/ork/openrocket-mass-loft-demo.json validation/fixtures/ork/loft-demo
refs/venv/bin/python validation/oracles/openrocket/mass.py corpus-out/openrocket-mass.json \
refs refs/hpr-sim-fixtures/imported/loft-fixtures refs/hpr-sim-fixtures/imported/debrief-fixtures --jar
cargo xtask ork
The script takes any directory of .ork files in place of refs. cargo xtask ork compares
HPR Sim with the record of the reference library only. The two imported/ directories hold the
private design library and Debrief’s private files, copied into the private flight collection.
They are named because the script doesn’t follow the symbolic link the local setup makes to that
collection. With the collection as a real directory under refs/, the script would read all of
it, and cargo xtask ork refuses the record.
What a .ork leaves unsaid, and overrides
In short. A design file does not say everything. What does a nose cone’s shoulder written with
a wall thickness of 0 weigh? What is a part that names no material made of? When a part and the
parts inside it both have an override (a mass or center of mass the
designer typed in), which wins? OpenRocket, which writes these files, has an answer to each. Its
answer is what the file means to the person who wrote it. So this project
asks it, with 32 small probe designs, each a rocket of a few
parts built to ask one question. validation/oracles/openrocket/conventions.py writes them. It runs OpenRocket 24.12 on all of them and records its answers. The test module
hpr_validate::openrocket::tests reads the same designs with HPR Sim and holds it to them. Where
HPR Sim keeps a rule of its own, the test pins how far apart the two are. The decisions are in
the decision on what a .ork leaves unsaid.
Read as OpenRocket reads it. On every probe of the readings in this table, HPR Sim’s mass is OpenRocket’s within 0.001%, part by part as well as whole. The worst, a transition, is 0.0003% apart. HPR Sim’s center of mass is OpenRocket’s within 0.001 mm (0.000039 in). Where no fin, rail button or recovery part is in the probe, the inertias agree within 0.001% too. One gap is pinned rather than hidden, and described below: an elliptical fin set weighs 0.18% more. None of these readings raises a warning. Where the file writes no value, or a wall of 0, HPR Sim takes what OpenRocket 24.12 takes, as measured on its probes. The table below lists each. One case no probe reaches: a part whose radius is no more than the 2 mm (0.079 in) default wall, with no thickness written. It’s taken as filled, as a stated wall that thick fills it.
| the file says | what it weighs (OpenRocket 24.12, and now HPR Sim) |
|---|---|
| a nose cone, transition or body tube with a wall of 0 | nothing: the part keeps its shape (HPR Sim’s drag uses the shape, not the wall) but has no wall; a part meant to be solid is written filled |
| an inner tube, coupler or launch lug with a wall of 0 | nothing |
| a shoulder with a wall of 0, or none written | nothing, whether or not the file closes its end with a cap, on a hollow nose or a filled one |
| a filled nose cone with a walled shoulder | the solid cone plus the shoulder’s own wall |
| a nose cone, transition or body tube with no thickness written | a 2 mm (0.079 in) wall, whatever its radius past that (measured on a nose cone and a tube at 50 mm (2.0 in) and at 30 mm (1.2 in), and on a transition) |
| a part weighed by its volume (a nose, transition, tube, coupler, engine block, fin set, ring or lug) with no material | cardboard, 680 kg/m³ |
| a canopy or streamer with no material | ripstop nylon, 0.067 kg/m² |
| shroud lines or a shock cord with no material | a 2 mm (0.079 in) elastic cord, 0.0018 kg/m |
| a rail button with no material | Delrin, 1,420 kg/m³ |
A worked example with the probe’s numbers: a conical nose cone 0.3 m (0.98 ft) long on a 50 mm (2.0 in) base. It has a 2 mm (0.079 in) wall of a material at 1,000 kg/m³, and weighs 0.091726 kg. With a shoulder 100 mm (3.9 in) long, 48 mm (1.9 in) in radius and a 2 mm (0.079 in) wall, it weighs 0.150787 kg. With the same shoulder written with a wall of 0, it weighs 0.091726 kg again in both programs. That’s the probe a nose whose shoulder has no wall. Before this step HPR Sim read that shoulder as solid, and would have added = 0.724 kg.
Which override wins. An override is a number the designer typed in place of what the parts add up to, usually after weighing the real thing. The file can say that an override covers the parts inside: that the number is for the part together with everything attached to it. The probes find HPR Sim and OpenRocket agree on which override wins, and on where a center is measured from:
- An override on a part that covers the parts inside it wins over any of theirs, and a stage’s that covers its parts wins over everything in the stage. A stage’s mass override that doesn’t cover them is added to them (A stage’s added mass).
- A center-of-gravity override is measured from the part’s front, not from its shoulder’s, and the shoulder moves with the part.
- A center-of-gravity override alone, written to cover the parts inside, sets the whole assembly’s center. (The two place the parts inside differently, which shows only in the inertia: below.)
This settles a Loft lesson. Loft’s rule for this came from
OpenRocket’s source and was unsettled by up to 133 mm (5.2 in). The test is
override_precedence_matches_oracle.
Where the simulator keeps its own rule. Each of these is a departure: HPR Sim knowingly differs from OpenRocket, and a test pins by how much.
| when | HPR Sim | OpenRocket | apart on the probe |
|---|---|---|---|
| a mass override covers the parts inside and states no center | keeps the center the parts lay out | puts it at the overriding part’s own, ignoring where the parts inside sit | HPR Sim’s center 3.7 mm (0.15 in) forward of OpenRocket’s, or 19.7 mm (0.78 in) if the part inside has an override of its own |
| a mass override covers more than one part | scales the inertia of everything it covers by the override’s ratio | scales only the overriding part’s own inertia, and keeps the parts inside at theirs | roll inertia 6.9% to 37% lower in HPR Sim under a tube’s |
| a center override covers the parts inside | moves the whole assembly, so the inertia about the new center is the assembly’s own | moves the overriding part alone, and adds the parts inside where they were | the center agrees; pitch inertia 2.65% lower in HPR Sim |
A .ork stage’s overrides follow OpenRocket now. OpenRocket leaves a stage’s parts where they
are, scaling nothing, since a stage has no inertia of its own. The reader gives such a stage that
rule, and its inertia matches OpenRocket’s on one stage with no motor aboard. On the lower of two
stages a difference remains: 4.95% and 3.33% over across the axis on the two probes, where it was
1.5% and 18.5%, worse on the first and better on the second (A stage’s rule).
Before, HPR Sim’s roll inertia was about 2.5 to 5 times OpenRocket’s
under a stage’s mass override on the one-stage probes.
Under a tube’s covering override HPR Sim’s roll inertia is the lower one, though it scales more of the parts. OpenRocket keeps the inertia of the parts inside while leaving their mass out of the total. So its assembly carries inertia for mass it does not count.
Why keep them? A builder who weighs a tube with its fins and motor mount inside has not moved their center. So the center the parts lay out is the better estimate. And scaling the inertia with the mass keeps it consistent with the mass: the extra weight sits where the parts’ weight does. Neither rule is right for every rocket (a heavy avionics bay at the center of mass adds little inertia). On a single part, with nothing inside, the two programs agree.
One more difference can’t be said in the HPR design format. It’s a part that overrides both its mass and its center, with one covering the parts inside and the other not. HPR Sim scopes a part’s overrides once, takes the mass’s, and warns. On the probes the center is 4.7 mm (0.19 in) apart when the center’s override is the covering one. The center agrees when the mass’s is, with pitch inertia 8.2% lower in HPR Sim.
Two gaps the probes found were both settled later (next section). A rail button sat 5 mm (0.20 in) further aft in HPR Sim than in OpenRocket, and is now where OpenRocket puts it. OpenRocket’s elliptical fin weighs 0.18% less than HPR Sim’s exact ellipse. OpenRocket’s matches, to 13 digits, a 30-sided polygon drawn inside the ellipse at equal angles. The simulator keeps the ellipse.
What it leaves out. An inner tube, coupler or lug that writes no thickness at all is read as no wall, with a warning. OpenRocket gives it a wall of its own. On the probe a 20 mm (0.79 in) inner tube gets 0.5 mm (0.020 in). A 5 mm (0.20 in) lug gets 1 mm (0.039 in), and a coupler none. One size each doesn’t say whether that wall follows the radius, and no file in the reference library has one. So HPR Sim doesn’t follow it yet. The test pins the difference, −2.4% in the mass of that probe’s structure.
Run it yourself. With Java 17 and the OpenRocket jar (cargo xtask refs fetch), from the
repository root:
refs/venv/bin/python validation/oracles/openrocket/conventions.py \
validation/fixtures/ork/openrocket-conventions.json
cargo test -p hpr-validate openrocket
Fins, rail buttons and roll inertia
In short. A rocket’s roll inertia is its resistance to spinning about its long axis. HPR Sim’s was a median 2.351% from OpenRocket’s on the 71 compared designs, and nothing explained it. It is the fins. OpenRocket works out a fin set’s roll inertia with a shortcut, and HPR Sim integrates over the fin exactly. The shortcut was measured on 33 more probe designs, each a tube and one part. HPR Sim keeps its own: a departure, a rule it keeps on purpose, measured and pinned by a test. The same probes settle how each fin section is weighed and where a rail button sits. The decisions are in the decision on fins and rail buttons.
The other parts agree, bar a rail button. A bulkhead, centering ring, inner tube, mass component, parachute, shock cord and streamer each have OpenRocket’s mass, center of mass and both inertias. They agree to 1e-15 on their probes. A rail button’s inertias are apart by up to 0.05% of its probe’s, and a launch lug’s pitch inertia by 0.03% (below).
OpenRocket’s shortcut. For a set of two or more fins, OpenRocket spreads the set’s mass evenly along a thin rod. The rod runs straight out from the body, at radius , to , and OpenRocket takes the rod’s roll inertia. is an effective span:
Here is one fin’s area, its span and its root chord. For a rectangular fin, is the span, and the shortcut is exact except that it leaves out the fin’s thickness. is shorter than the span when the fin narrows outward, and longer when it widens. The rule is inferred from OpenRocket’s output, and every tapered probe narrows outward. So a fin that widens is the rule carried past what was measured. A tab’s mass goes where the fin’s does, and neither the section nor the thickness enters. A single fin gets the same rod about its own middle, .
A worked example: the probe’s trapezoid. Three fins sit on a tube 50 mm (2.0 in) in radius. Each has a 100 mm (3.9 in) root chord and a 50 mm (2.0 in) tip chord. Its span and sweep are 50 mm (2.0 in) each, and it’s 3 mm (0.12 in) thick, of 1,000 kg/m³. Each fin has an area of 0.00375 m², so the set weighs 33.75 g. Then
so = 43.3 mm, and
OpenRocket’s figure. HPR Sim’s exact integral is 1.8284e-4 kg·m², 2.4% more: the fin’s outer part weighs more than the rod puts there.
The rod spreads the mass evenly, but a real fin’s mass follows its chord. So the sign depends on the outline: a triangle’s mass sits nearer the body than the rod’s. A tab lies inside the body tube, 40 to 50 mm (1.6 to 2.0 in) from the axis on the probe. But the rod puts its mass out with the fin’s, so OpenRocket’s figure is the larger there.
| probe fin set | HPR Sim’s roll inertia, kg·m² | OpenRocket’s, kg·m² | HPR Sim vs OpenRocket |
|---|---|---|---|
| rectangular, 100 mm (3.9 in) by 50 mm (2.0 in) | 2.6253e-4 | 2.6250e-4 | +0.013% (the thickness) |
| the trapezoid above | 1.8284e-4 | 1.7854e-4 | +2.41% |
| triangular, 100 mm (3.9 in) root, 50 mm (2.0 in) span | 1.0314e-4 | 1.0540e-4 | −2.14% |
| the trapezoid with a tab 50 mm (2.0 in) by 10 mm (0.39 in) | 1.9199e-4 | 2.0234e-4 | −5.12% |
The shortcut doesn’t match two fin probes to 1e-12. One is an elliptical fin set (its polygon,
below). The other is a canted one, by 2.66e-5 of the probe’s roll inertia, not traced.
hpr_validate::openrocket::openrocket_fin_set_roll_kg_m2 states the shortcut. The survey uses it
for the second roll row of the table above. The test each_part_alone_is_openrocket_s_or_pinned holds every probe of this section to OpenRocket’s,
or pins how far apart they are.
How each fin section is weighed. OpenRocket weighs a fin set as its outline times its thickness
times a factor for its section. The factor is 1 for square, 0.99 for rounded and 0.85 for an
airfoil. It doesn’t change with the thickness, checked at 3 mm (0.12 in) and 6 mm (0.24 in). HPR Sim works the section
out. A rounded edge is a semicircle, 0.9914 of the square section on the probe. An airfoil is
NACA’s four-digit section, 0.6851 (Abbott and von Doenhoff). A file that says airfoil doesn’t
say which airfoil, and a builder who weighed the fins can give their mass. So HPR Sim keeps its
sections. The elliptical fin stays the exact ellipse too. OpenRocket’s 30-sided polygon weighs
0.18% less.
Where a rail button sits. OpenRocket gives a rail button no length. It puts the button’s center
where a part of no length would sit, whichever end of the tube the file measures from. A row’s
first button goes there, and the rest follow aft. HPR Sim now reads a .ork button so (issue
#151). Before, the simulator put the row’s forward edge, middle
or aft edge on the position. The move depends on which end the file measures from:
| measured from | how the row moves (r the button’s outer radius, s the spacing center to center, n buttons) | two buttons of 10 mm (0.39 in) outer diameter, 100 mm (3.9 in) center to center |
|---|---|---|
| the top, after a part, or absolute | forward r | 5 mm (0.20 in) forward |
| the middle | aft (n − 1)s/2; one button does not move | 50 mm (2.0 in) aft |
| the bottom | aft r + (n − 1)s | 105 mm (4.1 in) aft |
A flight leaves the rail when its aft-most guide does. So a row placed from the top, after a part or absolutely now leaves it a radius earlier. One placed from the middle or the bottom leaves it later: more rail to travel, so a little faster off the rail. The probes check the top, the middle and the bottom, with one button and with a row of two.
A rail button’s screw head is weighed. HPR Sim reads a
.ork button’s <screwheight> and weighs the head as half a solid ellipsoid on the flange. The
model is above, under Standard solids. Before, it left the head off with a warning, and a rocket
with one did not fly (the powered pods decision). A 10 mm (0.39 in) button with a 2 mm (0.079 in) screw, in Delrin at
1,420 kg/m³, gains a head of
or 0.149 g, its center
0.75 mm (0.030 in) above the flange. OpenRocket 24.12 was probed with screws of 0, 1, 2 and 5 mm (0.20 in). It gives the
same volume to 2e-16 once its single-precision is used. HPR Sim’s double-precision gives
1.1e-8 of the volume more at a 5 mm (0.20 in) screw. Two things differ, both pinned by the test
a_rail_buttons_screw_head_is_half_an_ellipsoid:
- OpenRocket puts the head’s center above the flange, a flat half-disc’s centroid. That’s 0.049 further out than the solid’s . HPR Sim keeps the solid’s.
- With a mass override on the button, OpenRocket still moves the button’s center by the screw, and so does HPR Sim.
The screw head changes neither the drag, the center of pressure nor the normal force in OpenRocket, and HPR Sim gives it no drag either.
What is left, each pinned by a test.
- Fin fillets’ pitch inertia: −0.008% to −0.638% on the eight probes with more than one fin, and +0.425% on a single fin (below). Their mass and center agree.
- Small and not traced:
- a canted fin set’s mass, −0.004%;
- fins’ pitch inertia, up to 0.41% where the fins weigh the same, on a single fin, and up to 0.11% on the other probes;
- a launch lug’s pitch inertia, 0.03%;
- a rail button’s inertias, up to 0.05%.
- A rail button’s screw head: its center, 0.049 of the screw’s height nearer the body in HPR Sim than in OpenRocket (above).
Fin fillets were left out, a measured departure (the decision to keep it visible), until HPR Sim weighed them (below). A cluster’s departure is measured below. Two more gaps these probes found, both in packed parts, are settled below.
Run it yourself. As for the probes above: the same
script writes these, and cargo test -p hpr-validate openrocket checks them.
Tube fins
A tube fin set is a ring of short open tubes along the airframe, in place of flat fins. HPR Sim
weighs each tube as a hollow cylinder with its axis at from the airframe’s axis. is the
body tube’s outer radius and the tube’s own. HPR Sim also reads
a .ork tube fin set whose radius OpenRocket works out from the body
(the format guide has the rule).
The decision on that radius records what follows.
Mass and center agree. On 19 OpenRocket probe designs, each tube fin set’s mass is within 1e-14 of OpenRocket’s and its center within 1e-15 m. OpenRocket’s Tube fin rocket example is within 5.0e-6 of OpenRocket’s mass and 2.4e-6 of its length in center of mass. Its two inertias are not: each is a departure, a difference HPR Sim keeps on purpose, measured and pinned by a test.
Roll inertia, the first departure. Divide a part’s roll inertia by its mass and you get its unit inertia, in m². It’s the mean of the squared distance of its mass from the axis. No mass inside a ring of tubes is farther from the axis than , the outer edge of the tubes. So no ring’s unit inertia can exceed . For two tubes or more, OpenRocket’s does:
| six tubes of 20 mm (0.79 in) radius on a 50 mm (2.0 in) body | unit roll inertia |
|---|---|
| the most any ring can have, | 0.0081 m² |
| OpenRocket 24.12’s | 0.3047 m², about 38 times that |
HPR Sim keeps its own figure, which is below that bound, as it must be. For a single tube the two agree. OpenRocket puts its center at , where HPR Sim does. OpenRocket’s unit inertia about the tube’s own axis is , with the tube’s inner radius, as HPR Sim’s is.
Pitch inertia, the second departure. Pitch is turning end over end, about an axis across the airframe through the set’s center. One tube’s own unit pitch inertia, about its own middle, is for a tube of length .
- For three tubes or more, HPR Sim adds the ring’s spread, . That’s the mean squared distance of the tube axes from the pitch axis, since they sit at all around.
- On all 19 probes, OpenRocket’s is times one tube’s own, for tubes, with no term for the tubes’ distance from the airframe’s axis.
OpenRocket’s figure is 1.3 to 2.6 times HPR Sim’s on the probes. On six tubes of 20 mm (0.79 in) radius on a 50 mm (2.0 in) body it’s 1.77 times. On the probes, whose tubes are 0.1 m (0.33 ft) long, it stays under a bound. That’s the most any mass inside the ring could have about that axis, . On the Tube fin rocket’s longer tubes it is 18% over that bound, 3.352e-3 m² against 2.834e-3 m² a unit of mass. So no mass could have it. Either way it is not what tubes at weigh, so HPR Sim keeps its own. For a single tube the two agree.
On the example. On OpenRocket’s Tube fin rocket, HPR Sim’s roll inertia is 98.7% below
OpenRocket’s, and its pitch inertia 1.98% below. The pitch gap is sized. cargo xtask ork swaps
OpenRocket’s pitch rule into HPR Sim’s structure for each tube fin set and prints the result. The
gap goes from −1.9800% to +0.0023%, well inside the survey’s 0.1%. The survey
above names tube fins as the cause of the roll gap. OpenRocket’s fin
shortcut, which the survey swaps in for flat fins, is not given OpenRocket’s mass for tube fins,
so it cannot close this one.
The test a_tube_fin_sets_automatic_radius_reads_as_openrocket_does in hpr-validate holds both
departures both ways. OpenRocket’s roll is above the bound and HPR Sim’s below it, on every probe
with two tubes or more. OpenRocket’s pitch is times one tube’s own, to 1e-14. HPR Sim’s roll and
pitch match their closed forms to 1e-13.
Clusters and fillets
A cluster is a motor mount with more than one motor tube. HPR Sim weighs every tube where it sits, each with its own parallel-axis term. It repeats what a tube holds in every tube (Clusters). OpenRocket 24.12 was asked on 25 probes (the decision on clusters). It agrees on the mass and the center of mass to 1e-12, but not on the inertia. It weighs a cluster’s tubes as if stacked on the cluster’s axis. A 3-ring at scale 1 and at scale 1.5 have the same inertias in OpenRocket. It does weigh an engine block inside each tube where it sits. HPR Sim does not copy the stacking, since the tubes are not on the axis.
The fixed 3-ring probe is a tube and a 200 mm (7.9 in) inner tube, three of them 23.09 mm (0.91 in) from the axis. Each
inner tube has a 20 mm (0.79 in) outer radius and 1 mm (0.039 in) wall. OpenRocket’s saved structure is 0.3813893481458014 kg, with
center 0.24036243822075784 m (0.788590676577 ft), roll 0.0007674901427941916 kg m² and pitch 0.007191233036548777 kg m². HPR Sim’s mass and center are the same. Its roll inertia is +5.11% apart and its pitch
+0.273%: the spread of the tubes, and half of it. The spread is , 3.92e-5 kg m², for each
tube’s mass at = 23.09 mm from the axis. On every cluster probe on the body’s axis the difference is exactly
that, to 1e-12, whatever the pattern, scale, contents or overrides. Off the axis, three differences
are left and pinned as measured, with the spread taken out. A lone tube 10 mm (0.39 in) off the axis is
+0.303% in roll and +0.016% in pitch. That’s in roll and half of it in pitch, as
if OpenRocket left the offset out. Here is the tube’s mass, its offset and the
structure’s mass. The pitch of two clusters off the axis is +0.015% and +0.021%, which the project
has not traced. Before HPR Sim weighed every tube, it read
one. That left it 12.85% light, 5.95 mm (0.23 in) forward, 2.43% low in roll and 3.68% low in pitch. each_part_alone_is_openrocket_s_or_pinned and
a_cluster_weighs_as_openrocket_s_but_for_its_tubes_spread check these.
Fin fillets
A fin fillet is the rounded glue joint along a fin’s root, where the fin meets the tube. HPR Sim weighs fillets as OpenRocket 24.12 does (the decision on fillets). Before, it left them out with a warning. The 5 mm (0.20 in) and 10 mm (0.39 in) probes were then 0.808% and 2.79% light (the decision on clusters, fillets and unread parts).
The shape. A fillet fills the corner between the tube and the fin’s side. Its concave face is a
circle of the fillet’s radius that touches both. Its section is bounded by three edges: the tube’s
circle, the fin’s plane and that circle. As in OpenRocket, the fin is taken as having no thickness
there, so the section starts at the fin’s middle plane, not its face. Two fillets run along each
fin, one each side, as long as the root chord. So each is a prism of that section. It is made of the
file’s filletmaterial. A file that names none gets OpenRocket’s cardboard, 680 kg/m³. Most
fillets are epoxy, which is heavier (HPR Sim’s epoxy is 1,180 kg/m³). So set filletmaterial in
OpenRocket, or the fillet’s material in HPR Sim, to what you used.
The equation. Take the body radius and the fillet radius . Take outward from the body’s axis along the fin’s mid-plane, and square to it. The fillet circle’s center is at , with . That puts it from the axis, so the circle touches the tube. The section is the triangle , , less two circular sectors. One is the tube’s, up to the angle , and the other the fillet circle’s, whose angle is :
On a flat body ( very large) this tends to : a square less a quarter circle.
HPR Sim works out the section’s first and second moments the same way, in closed form. The sectors’
second moments are computed in a stable form. But the final subtraction still loses about
digits: at most 2 for a fillet 1% of the body radius or larger. A test checks all four
against numerical integration to 1e-11 (fillet_section_is_its_region_by_quadrature in
hpr_design::fins). Far from real fillets the subtraction cancels away. So HPR Sim weighs a
fillet under a millionth of the body radius as nothing, and refuses one over a thousand times it
(FILLET_RATIO_MAX). It gives a body of no radius no fillet. Against 60-digit arithmetic, the
area keeps 10 significant digits at a millionth of the body radius and 12 at a thousand times it.
That was checked once while writing the code. The thousand is a cautious limit, not where the
digits run out: at ten thousand times it still keeps 10.
A worked example. An invented 5 mm (0.20 in) fillet on a tube 30 mm (1.2 in) in radius. Then = 34.64 mm and = 0.1433 rad (8.21°).
| piece | formula | area |
|---|---|---|
| the triangle | 86.60 mm² | |
| less the tube’s sector | 64.51 mm² | |
| less the fillet circle’s sector | 17.84 mm² | |
| the section | 4.253 mm² |
That is 79% of the 5.365 mm² a flat body would give: the tube curves away from the fin, so the
corner holds less. Three fins with a 100 mm (3.9 in) root chord have six fillets. Their volume is
= 2,552 mm³ = 2.55 cm³. In cardboard they weigh
= 1.735 g. A unit test pins these numbers
(the_worked_fillet_example_is_the_docs in hpr_design::fins).
How well. Nine probe designs measure it: the 5 mm (0.20 in) and 10 mm (0.39 in) probes of the earlier fillets step, and seven new ones:
- fillets of 30 mm (1.2 in);
- fillets in their own material;
- fillets naming no material;
- a single fin;
- four fins of rounded section;
- a freeform fin set;
- a wider tube.
On every one the fillets’ mass and center of mass are OpenRocket’s to 1e-15, and the test holds
them to 1e-12. On the rounded-section probe the whole fin set’s mass is 1.79e-4 apart. That’s from
the fin section’s factor (above), not from the fillets. The whole
probe’s pitch inertia is apart by −0.0077% to −0.638% on the eight with more than one fin, growing
with the fillets’ mass. On the single fin it is +0.425%, near the +0.406% a single fin reads
without fillets. HPR Sim’s figure is the exact prism’s. How OpenRocket works out a fin’s pitch
inertia has not been measured (the decision on fins and rail buttons). The roll rows use OpenRocket’s fin shortcut, as every fin probe
does. each_part_alone_is_openrocket_s_or_pinned pins every row.
What it leaves out. The fillets’ drag and lift: the aerodynamics ignores them (Drag limits). A fillet that is not a circular arc, such as a hand-shaped bead of glue, is weighed as one.
Packed parts
A parachute, streamer, shock cord or mass component (an altimeter, a battery, ballast) is weighed as a solid cylinder (above). The cylinder is its packed length and packed radius, where it sits in the tube. Two cases need a rule of their own. HPR Sim now takes OpenRocket’s for both, measured on probe designs OpenRocket 24.12 reads (the decision on packed parts). Like every OpenRocket rule on this page, they are inferred from what OpenRocket prints, not read from its source.
A file that writes no packed size. OpenRocket packs the part 25 mm (0.98 in) long and 12.5 mm (0.49 in) in radius.
The radius is a fixed number, not the tube’s bore. It’s the same in bores 48 and 98 mm (3.9 in) in radius.
OpenRocket does not shrink it to fit a bore of 8 mm (0.31 in), and neither does HPR Sim. Each number
stands alone. So a file that writes only a length gets the 12.5 mm (0.49 in) radius. One that writes only a
radius gets the 25 mm (0.98 in) length. HPR Sim reads a .ork the same way, with no warning.
Before, it read a length of zero with no warning, and a radius of zero with one.
A mass override on a part that weighs nothing. A parachute with no canopy, or a mass component of 0 g, given a 30 g override: OpenRocket spreads the 30 g over the packing. So does HPR Sim now. In a packing 50 mm (2.0 in) long and 20 mm (0.79 in) in radius that is:
| formula | 30 g in the probes’ packing | |
|---|---|---|
| roll inertia | 6.0 × 10⁻⁶ kg·m² | |
| pitch inertia, about its own center | 9.25 × 10⁻⁶ kg·m² | |
| center | halfway along the packing | 25 mm (0.98 in) aft of its forward end |
Before, HPR Sim put the 30 g at a point, which left the probe’s roll inertia 0.805% low. Any other part that weighs nothing still becomes a point mass under an override. Both programs do that (above).
How well. Eleven probes ask these questions, a tube and one packed part each. HPR Sim’s structure is OpenRocket’s to 1e-12 on every one, in mass, center of mass, roll and pitch. The earlier 74-file before-and-after measurement took the roll inertia from 49 to 53 files within 0.1%, and from 55 to 57 within 1%. That’s with OpenRocket’s fin shortcut in HPR Sim’s place. The current survey, on 71 designs, has 64 within 0.1% and within 1% with that shortcut (above):
| (earlier 74-file measurement) | before | after |
|---|---|---|
| center of mass within 0.1% of length | 54 of 74 | 55 of 74 |
| pitch inertia within 0.1% (median) | 34 of 74 (0.110%) | 37 of 74 (0.086%) |
| roll inertia, fin shortcut in HPR Sim’s place, within 1% | 55 of 74 | 57 of 74 |
| roll inertia, HPR Sim’s own fins, within 1% (median) | 29 of 74 (2.112%) | 28 of 74 (2.354%) |
The last row moves the wrong way. HPR Sim’s own fin roll departs from OpenRocket’s (above). In one file the point mass had left HPR Sim’s roll inertia low, which happened to cancel part of that departure. The packing now adds it back.
What it leaves out. A packed size the file writes but HPR Sim can’t read as a number is read as zero, with a warning, like any unreadable number. Every probe places its part from the tube’s top. How the 25 mm (0.98 in) length moves a part placed from the middle, the bottom or after another part is worked out, not measured. The override rule was probed on a parachute, a mass component and a shock cord. A streamer takes it too, by the same packing, without a probe of its own. Mass is unchanged: the rules move mass, they add none.
Run it yourself. refs/venv/bin/python validation/oracles/openrocket/conventions.py validation/fixtures/ork/openrocket-conventions.json writes the probes (it needs OpenRocket 24.12
and Java 17), and cargo test -p hpr-validate openrocket checks them.
Verification
- By hand:
mass::tests:- two boxes make one box;
- point masses give the products of inertia;
- rolling swaps and mixes axes, so is ;
- rotation keeps the principal moments;
- motor elements land on the axis.
tests::composite_rocket_inertia_matches_hand_calculation(crate root) combines a filled cone, a tube, four fins and an off-axis payload. Each part’s moments come from its own formula and the six tensor terms are written out; the result agrees to 1e-11.parts::tests::a_nose_cone_with_a_capped_shoulder_adds_up_by_handchecks the cone, tube and cap to 1e-11.fins::tests:- A rectangular fin is a box, and four fins are the sum of rotated boxes.
- A swept fin’s matches quadrature of the planform.
- A fin canted 90° is the box turned.
- Tube fins match the parallel-axis theorem.
- Closed forms against quadrature:
- Each cross-section’s , , , matches exact quadrature of to 1e-13, on a wide chord and one narrower than .
- The airfoil constants match to 1e-14.
- Trapezoidal, elliptical and freeform areas and centroids match to 1e-12.
- Properties (
mass::tests, proptest): combining is associative and order-free, and turning a body keeps its principal moments. The inertia about any point exceeds that about the center. - Materials: ids are unique, sources present, and the unit conversions reproduce the sources (1.1 oz/yd² = 37.3 g/m², 225 ft/lb = 6.61 g/m, white ash 678 kg/m³).
- Loft lessons:
Solid motors
Learn how to fly a commercial solid motor in HPR Sim, and how it models the thrust curve, propellant burn, mass and ejection delay.
In short
- What it models: commercial solid motors: the thrust curve and its statistics (total impulse, burn time, average thrust, class), and how the propellant burns away. It also models the motor’s mass, center of mass and inertia as it burns, thrust at altitude, and ejection delays.
- Sources: NASA SP-8039 (1971), the National Association of Rocketry’s Standard Motor Codes, ThrustCurve.org’s glossary, statistics page and code, and RocketPy 1.13.0’s motor code.
- How well it is validated: by analytic tests (exact answers worked out by hand) and by another code (code-to-code). Those are the first and third of the four kinds of evidence. Small numbers here are in scientific notation, and a relative difference is a fraction of the value compared. ThrustCurve.org’s own statistics code agrees to 3e-15, relative, on all 412 files that pass the 1% check, once its averaging of two or more samples at the same time is turned off on the 8 files that have them. With that averaging on, as ThrustCurve.org runs it, 6 of the 412 differ in at least one of total impulse, burn time, average and peak thrust, by up to 6.5% (a peak thrust), and one of them would fail the 1% check (Validation). On three of the 32 curves first bundled, RocketPy’s total mass and inertias agree within 7.9e-5 relative, the centers of mass within 5.9e-6 of the motor’s length. The propellant’s own mass and inertias agree within 1e-4 of their values at ignition. OpenRocket 24.12 reads the same 32 curve files. On each it gets exactly the same total impulse, peak thrust, burn-time window and curve duration. Its average thrust differs by definition: HPR Sim’s is +0.0107% to +0.3147% higher. Nothing else in this model is compared with OpenRocket: not the propellant’s burn-back, its mass and inertias, or the delays. The files that fail the 1% check have only that check against ThrustCurve.org’s figures so far (the whole catalog). Nothing here is compared with a real flight.
- What it leaves out: anything but commercial off-the-shelf solids. The 80 catalog motors with no curve file that reads can’t fly (the whole catalog). Propellant burns in proportion to the impulse delivered, an approximation. With only catalog data, the center of mass stays at mid-length. Commercial motor files give no nozzle exit size, so thrust at altitude goes uncorrected unless one is supplied. Grain temperature isn’t modeled either: every motor flies its certified curve, fired with the grain at about 15 to 25 °C. A grain 10 K warmer delivers 0.1% to 0.8% more impulse, which adds 0.06 to 1.3% to apogee. Its shorter, harder burn moves apogee by −0.2 to +0.4% too, or by +1.1 to +2.2% for a slow, long burn. So on a hot day the predicted apogee can read low, the flattering side for a waiver. A grain 20 K cold loses 0.1% to 2.6% of apogee to impulse alone. These figures are borrowed from military and sounding-rocket motors. One hobby test of 71 F-class motors agrees (+0.2% impulse per 10 K) (propellant temperature, hobby firings).
Using a motor
A flight needs a motor in the rocket’s motor mount. There are two ways to get one:
- take one of the 1,004 motors that come with HPR Sim, or
- read a thrust-curve file, such as one downloaded from ThrustCurve.org, by hand or through the library (Matching motors to ThrustCurve’s records).
Either way, the motor then goes into one of the rocket design’s configurations. A short program,
crates/hpr-sim/examples/motors.rs,
shows all of this: it counts the built-in motors and lists one of each class with a passing file, reads a .eng file, and flies that motor in a
rocket. Run it from anywhere in the repository (the setup is on
Getting started):
cargo run --example motors -p fusionspace-hpr-sim
It prints this. The output is committed in
motors.output.txt.
CI runs the program on macOS, Windows and Linux and fails if it prints anything else. So the
counts and rows below are always the code’s.
1004 motors come built in, 924 of them with a curve file. One of each class:
dia length loaded total average burn
designation maker type class mm mm mass g impulse N·s thrust N time s
B4 Quest single-use B 18 80 19.8 4.9 4.4 1.11
C5 Estes single-use C 18 70 23.8 7.8 3.9 1.98
D5 Quest single-use D 20 96 45.1 17.6 3.8 4.59
26E31-15A Cesaroni reload E 24 69 52.0 26.1 30.7 0.85
F30FJ AeroTech single-use F 24 90 70.0 47.1 30.4 1.55
G142 AeroTech single-use G 29 113 97.6 84.6 136.5 0.62
166H175-14A Cesaroni reload H 29 231 247.0 166.1 175.0 0.95
I175WS AeroTech single-use I 38 214 348.0 333.2 177.5 1.88
644J94-P Cesaroni reload J 38 367 660.0 644.6 95.0 6.79
K750ST AeroTech reload K 75 266.7 1948.0 1296.7 741.8 1.75
2645L265-P Cesaroni reload L 54 649 2481.0 2646.0 267.3 9.90
M1350W AeroTech single-use M 75 622 4808.0 5179.5 1350.1 3.84
N3120X-PS AeroTech single-use N 75 1156 8200.0 10369.1 3125.1 3.32
21062O3400-P Cesaroni reload O 98 1239 16842.0 21041.0 3424.3 6.14
From the .eng file: I377CT by Loki, 38 mm by 292 mm, 560 g loaded, 250 g of propellant
525.8 N·s (class I), 377.9 N average over 1.39 s, 657.0 N peak
effective exhaust velocity 2103 m/s
Valetudo on the I377CT: 8.82 kg at liftoff
leaves the 3 m rail at 17.7 m/s
apogee 151.7 m above the pad, at 6.09 s
Not yet validated: see the Accuracy page before trusting these numbers.
The whole program is at the end of this page.
The bundled motors
Each curve is a ThrustCurve.org file, bundled unchanged, under the license
the whole catalog gives. The size, masses and
delays come from its header, and the rest is worked out from its curve. Its ThrustCurve.org
record’s impulse, thrusts and burn time are bundled too, as published facts with
credit (third-party notices).
They aren’t the maker’s data. Each file is checked against them: its total impulse, average
thrust and burn time must each be within 1% of the record’s to pass. A gap is the file’s figure
less the record’s, as a share of the record’s, so + means the file reads high. A motor flies a
passing file where it has one, else the first by format and by who measured it. Flying a failing
file in hpr sim warns, naming each failing figure: burn time +2.00%. So does a failing mass
check (below). The library gives the same warnings: Rust’s
Motor::from_catalog keeps them in warnings(), and Python’s raises each as a UserWarning. Check such a file against the maker’s data.
hpr motors show lists each file with its check. cargo xtask motor-catalog writes the catalog,
and a test fails if the committed one differs.
| column | what it is | where it comes from |
|---|---|---|
| designation | The motor’s full name (motor designation) | the motor’s name, as ThrustCurve.org lists the file |
| maker | The manufacturer, abbreviated | as ThrustCurve.org lists the file |
| type | single-use, or reload: a propellant load for a reusable case | as ThrustCurve.org lists the file |
| class | The impulse class letter | HPR Sim, from the curve |
| dia, length | The case’s diameter and length, mm | the file’s header |
| loaded mass | The motor ready to fly, g. For a reload this includes the case | the file’s header |
| total impulse | Total impulse, N·s | HPR Sim, from the curve |
| average thrust | Average thrust, N | HPR Sim, from the curve |
| burn time | Burn time, s | HPR Sim, from the curve |
Before the lookups moved to the whole catalog, 32 of these motors were the only ones built in. How those 32 were chosen:
- They were public-domain ThrustCurve.org curves of motors in production.
- When they were chosen (September 17, 2026), each curve’s total impulse, burn time and average thrust were within 1% of the values ThrustCurve.org publishes for the motor. Peak thrust is not held to it: it runs from 16.7% below (Cesaroni 26E31-15A) to 2.1% above (Loki M1378LR).
- The files’ headers differ from ThrustCurve.org’s records in a few places, and the header is what the simulator flies. Five lengths differ, from 1.2% shorter (the B4) to 1.3% longer (the N3300R). So do 7 propellant masses, from 2.7% lighter (the C5) to 52% heavier (the 26E31-15A). So do 6 loaded masses, from 4.0% lighter (the C5) to 2.3% heavier (the D5). For the 26E31-15A the header is the likelier: the record’s 11.1 g of propellant would need an effective exhaust velocity of 2,350 m/s (7,710 ft/s) for its 26.1 N·s, more than every one of the 32 but the K400C. The delays are the header’s too, which often lists fewer settings than the maker sells.
- There were up to three per impulse class, from different manufacturers, none in class A.
- The selection, and the curves left out, are in the ThrustCurve.org data notes.
In code, Catalog::bundled() returns the list
(Catalog). catalog.find("I377") finds a motor
by its designation or common name, ignoring case, spaces and hyphens. A leading maker name
keeps only that maker’s motors (Estes C6). A motor whose designation is the name outranks one
whose common name is: D5 is Quest’s D5, not the D5-P. Otherwise it returns every match: I175
finds both the AeroTech I175WS and the Cesaroni 411I175-14A. Then
entry.bundled_motor() builds the motor
(CatalogMotor), with the catalog’s size and
masses. The catalog doesn’t say where inside the motor its mass sits, so the simulator uses a
rough guess, the envelope default. The propellant and the rest of the motor (case, nozzle and
closures) are each spread evenly along its length. So the center of mass stays at mid-length as
it burns (The whole motor gives the details).
The whole catalog
hpr-motor carries a copy of ThrustCurve.org’s whole solid catalog, taken on October 28, 2026:
the record of every single-use and reload motor, 1,004 of them, in production or not, and 1,701
of the 1,706 files listed for them. Every lookup reads it: hpr motors, hpr sim --motor and a
design’s motor (every motor by name). 32 designations are
shared by several makers. Such a motor’s selector, the name that finds it alone, is its maker’s
short name and designation; hpr motors list --json gives each motor’s selector.
- Each motor’s names and stated figures are its record’s, unchanged. Its listed figures are its
default file’s own: a passing file where it has one, else the first by format and by who
measured it. The 80 motors with no file that reads list their record’s figures, and can’t fly:
hpr motors listnames them in a closing note, andhpr motors showandhpr sim --motorrefuse them. - Each file is stored with its 1% check, passing or not. 412 of the 1,701 files pass, and 239 of the 924 motors with a file have one that does. The other 685 fly with a warning naming each failing figure.
- ThrustCurve.org’s statistics code checks the figures of the 412 files that pass
(Validation). The 1,289 that fail have only the 1% check. The comparison with
OpenRocket and the
.eng/.rseround trip cover the 32 files first bundled. The round trip over every file is planned (issue #1002). - Of the 1,701 indexed files, 589 are public domain, 33 free to use, and 1,079 carry no license; none is marked restricted. The third-party notices say how each is used.
- Five files are left out, each listed in the index with its reason:
- two RockSim files whose times run backwards;
- three whose header’s diameter is more than 10% from the record’s, either way: two give 75 mm (3.0 in) for a 54 mm reload (Loft lesson L43), and one 38 mm (1.5 in) for a 29 mm single-use motor. Every other header sits within 7.3% of its record (four files give a Pro150 reload’s 150 mm (5.9 in) where the record gives 161 mm (6.3 in)); the three are 31% to 39% off. Sizes closer than 10% apart, such as 152 mm (6.0 in) and 161 mm (6.3 in), aren’t told apart.
- 48 motors’ default files give a propellant mass more than 5% below their record’s, and warn; 151 more than 5% above it, which alone doesn’t (issue #1003). Either side may be the wrong one.
- 36 of the 840 motors whose file and record both give a loaded mass are more than 5% apart, 17
heavier and 19 lighter (issue #1233),
and warn, naming both. The Quest D8’s file gives 454 g (16 oz), its record 45.6 g (1.6 oz).
Either may be wrong; if the record is right, a heavier file gives too low an apogee, a lighter
one too high a margin. A propellant share outside the records’ span, about 11.5% to 75%, warns
too (the D8’s 4.8%). With the loaded mass within 5%, a burnout mass (loaded less propellant)
more than 5% from the record’s burnout mass, either way, warns: 208 more.
cargo xtask motor-catalogprints them. - What still passes unwarned: a burnout mass (the empty case) up to 5% from the record’s, either way, while the loaded mass is within 5%; past that the burnout check doesn’t run, and the loaded-mass warning fires instead. A light case, aft of the center of gravity as on nearly every rocket, moves it forward, so the margin after burnout reads high. On RocketPy’s Calisto, a case 5% light adds 0.037 calibers; the earlier bound allowed 0.098 (issue #1294).
Online, hpr motors update caches the motors and files ThrustCurve.org’s records show as added
since; it can miss a file swapped for another under an unchanged record
(newer motors). Offline, it prints the bundle’s
date, counts and size:
$ hpr motors update --offline
The bundled catalog: ThrustCurve.org's solid motors as of 2026-10-28
motors 1004, 924 with a file that reads
files 1701, and 5 left out
passing 412 files within 1% of their records, of 239 motors
size 4.2 MB (4196056 bytes)
note: offline, with no whole update cached; online, `hpr motors update` looks for motors and files newer than 2026-10-28
Motor data and thrust curves courtesy of ThrustCurve.org, https://www.thrustcurve.org/
python3 validation/oracles/thrustcurve/snapshot.py takes a fresh snapshot, and cargo xtask motor-catalog writes the index from it. The command names each file it expects to leave out by
its id; any other file left out fails it.
A motor from a file
Motor files come in two formats, and ThrustCurve.org serves both:
- RASP
.eng, a plain-text format named after RASP, the rocket simulation program it comes from. It is the more common of the two: 889 of the 1,712 solid-motor files ThrustCurve.org held when surveyed. - RockSim
.rse, an XML format from the RockSim simulator.
The example reads a .eng file in four steps:
- Read the text. For a file you downloaded, use
std::fs::read_to_string("my-motor.eng")?. The motor crate never opens files itself. The example builds one of the bundled files into the program withinclude_str!instead, so that it runs anywhere. - Parse it.
eng::parse(&text)?(eng::parse) returns the file’s entries, one per motor (a file can hold several), and a list of warnings. The reader is lenient: it accepts the oddities real files have and reports each one, with its line number (reader policy). This file reads with no warnings. - Take the curve.
entry.thrust_curve()?makes the thrust curve, starting it from zero thrust at ignition. - Build the motor with
SolidMotor::from_envelope(curve, diameter_m, length_m, propellant_kg, loaded_kg)(SolidMotor). A.engheader gives the size in millimeters and the masses in kilograms. So the example multiplies the size by 0.001 and passes the masses as they are. Check that step yourself: the motor can’t tell a size left in millimeters. The units check looks at the impulse and the propellant mass, not the size, so any positive size is accepted. If the same size goes into the rocket, the design checks stop the flight for a diameter too wide for the mount. A length too long for it only draws a warning (Putting it in a rocket).
For a .rse file, use rse::parse (rse::parse) instead.
Its motors are in engines rather than entries. Its masses are in grams (initial_mass_g,
propellant_mass_g), so multiply those by 0.001 too. Forget it for the propellant, and the units
check catches it: the exhaust velocity is 1,000 times too small, and the motor is refused. The
check sees only the propellant mass. Forget it only for the loaded mass, and the motor is accepted
as 1,000 times heavier.
The file here is Loki Research’s I377. The program prints what it read, 38 mm by 292 mm (1.50 by 11.5 in), 560 g
loaded with 250 g of propellant. From the curve it works out 525.8 N·s, an I motor, averaging
377.9 N over 1.39 s. Its effective exhaust velocity, 2,103 m/s (6,900 ft/s), is well inside the check’s range.
Three things to know about a motor built from a file:
-
The header can be wrong. Whoever made the file typed its size and masses. Of ThrustCurve.org’s 554 public-domain files, 66 headers give a length more than 1 mm (0.039 in) off the catalog’s. Five give a diameter more than 0.5 mm (0.020 in) off (data notes, section 4). The bundled motors fly their headers’ values too.
cargo xtask motor-catalogrefuses a file whose header diameter is more than 10% from its record’s. In Loft, one header listed a 54 mm motor as a 75 mm motor (Loft lesson L43). For any other motor, check the header against the motor’s page on ThrustCurve.org.A motor fetched from ThrustCurve.org gets one more check, against its record: a propellant mass over 5% below the record’s draws a warning naming both (
PROPELLANT_SHORT_BOUND). With the file’s loaded mass right, that flies too heavy a burnout mass and too low an apogee, the side that flatters a waiver. A heavier one draws none, and the loaded mass isn’t checked (survey, section 5). -
Where its mass sits is a rough guess, the envelope default (The whole motor). If you know the grain sizes,
SolidMotor::newwithPropellant::Grainsdoes better (Where the propellant is). -
Its nozzle size is unknown, so its thrust is not corrected for altitude (Thrust at altitude).
Putting it in a rocket
A rocket design keeps its motors in configurations: named sets of motors, at most one in each
motor mount (Motors and configurations). The example adds
one to Valetudo, the rocket of Getting started: a
Configuration with the id from-file,
holding one MountedMotor.
field of MountedMotor | what it holds |
|---|---|
mount | The id of the mount in the design, here motor-mount |
designation | A name, for display |
diameter_m, length_m | The case’s size, in meters. The design checks compare the diameter with the mount’s bore: a motor wider than its mount is an error, and the flight refuses to start unless design errors are accepted (--accept-design-errors) or a nominal size’s real case fits (a nominal motor in its matching tube). A case that reaches forward past the mount’s top is only a warning |
motor | The motor built above |
delay | The ejection delay chosen, if any. A parachute can fire on it, with the MotorDelay trigger (Recovery) |
Valetudo’s mount is 43 mm (1.7 in) inside, so this 38 mm motor fits. Simulation::new(&rocket, "from-file", ...) then flies the configuration by its id: straight up from a 3 m (9.8 ft) rail, in calm
air, with no parachutes. The rocket weighs 8.82 kg at liftoff and leaves the rail at 17.7 m/s
(58 ft/s). It reaches 151.7 m (498 ft) above the pad at 6.09 s. These flight numbers are not
validated (evidence row G24). See Accuracy before
trusting them.
A design file holds configurations in the same form, as JSON, with the motor written out in full.
See the configurations list at the end of
the Valetudo design.
Every motor lights at launch, , unless its ignition says otherwise: at a time, after
another motor’s burnout, or after its stage separates (Staging). It then burns on its
own clock from that moment.
Code and conventions
Where the motor code lives, its sources, and the units and axes it uses.
Code and sources
Code: hpr_motor (API reference), in its modules curve, class,
motor, grains, mass, delay and catalog. The file formats are described in
.eng files and .rse files.
Each source has a short key in square brackets, used below. A source that can be downloaded is pinned. Its address and a checksum of its bytes are in the reference lock file, under the name given. So anyone can fetch the same copy (Checking a claim).
- SP NASA SP-8039, Solid Rocket Motor Performance Analysis and Prediction (1971),
free from NASA, pinned as
nasa-sp-8039. Page notes: nasa-sp-8039-motor-definitions.md. - NAR National Association of Rocketry, Standard Motor Codes, as
archived on February 5, 2014, pinned as
nar-standard-motor-codes. - TC-G ThrustCurve.org’s glossary, pinned as
thrustcurve-glossary. - TC-S ThrustCurve.org’s “Motor Statistics” page, pinned as
thrustcurve-motorstats. - TC-A ThrustCurve.org’s statistics code,
simulate/analyze/analyze.jsin the site’s source at commit577afa6, pinned asthrustcurve3-analyze. It is under the ISC license, a permissive open-source license like MIT, so this project may read it and run it. - [RP] RocketPy 1.13.0 (MIT),
rocketpy/motors/motor.pyandsolid_motor.py, pinned asrocketpy. Notes: rocketpy-solid-motor.md.
Line numbers below, such as “lines 40–91”, link to those lines of the source.
Conventions
- Time is seconds from ignition.
- Positions are meters along the motor’s axis from the nozzle exit plane (where the exhaust leaves) toward the forward closure (the motor’s front end). So points toward the nose, like the body frame (Frames). The design model places the motor’s nozzle exit in the body frame (its milestone).
- Every part is symmetric about the axis. is about the axis and about a transverse
axis, both through the part’s own center of mass (RocketPy’s
I_33andI_11). - Motor files keep their own units (mm, kg or g). The model is SI: meters, kilograms and seconds.
The model
How a motor’s thrust, propellant, mass, altitude effect and delay are worked out.
Thrust curve
A thrust curve is the motor’s thrust against time, as its file lists it.
-
Samples joined by straight lines, as [RP] reads them (
interpolation_method"linear"). Before the first sample the curve starts from when , as the RASP format specifies (.engfiles) and TC-A integrates. From the last sample on , that instant included. Like any step, the end takes the later value. So at burnout the thrust, the mass flow and the propellant left are all zero together. -
Equal consecutive times are a step: the later value holds from that time on. Real files use them for an abrupt burnout. Decreasing times and negative thrust are rejected, and so is a curve with no impulse or no burn time (defined below).
-
A sample is delivered when it starts or ends a stretch of the curve that lasts some time ( or ). The thrust then really takes its value. A sample that starts a stretch is reached at its own instant. One that ends a stretch is approached ever closer as time runs up to its instant. A sample strictly inside a run of three or more equal times is never delivered: the step jumps straight past it. Nor is the first sample of a step at the curve’s start, or the last of a step at its end. Peak thrust is the largest delivered sample, which is exactly the most the curve’s thrust reaches. The burn-time crossings below compare only delivered samples with the threshold. For example, times
0, 1, 1, 1, 2s and thrusts10, 10, 1000, 10, 0N hold 15 N·s. The step skips the 1,000 N sample, so the thrust never exceeds 10 N, and 10 N is the peak. The burn runs from 0 to 1.95 s. Counting the skipped sample would set the 5% threshold at 50 N, above anything the curve delivers. The curve would then be refused (the decision record, issue #10, the report of the refusal). A one-off run over the surveyed ThrustCurve.org files found no file whose statistics change. Its scripts are not committed; the decision record has the counts. -
Before integrating, TC-A drops leading points below 500 µN and averages points closer than 50 µs (lines 40–91). HPR Sim keeps leading zeros and treats equal times as steps. On the 412 files that pass the 1% check, the results agree to 3e-15 on all but 6, each with repeated times, where the averaging moves at least one of total impulse, burn time, average and peak thrust, by up to 6.5% (Validation). A survey on September 17, 2026 read 1,710 of ThrustCurve.org’s 1,712 solid-motor files. The two agreed to 1e-9 on all but 17 with repeated times, and on those differed by up to 1.1% in average thrust. HPR Sim keeps the step because a vertical drop is what the file draws.
-
Total impulse: the exact integral of the lines (SP glossary p. 96: ),
is the same sum up to , with the partial interval.
-
Burn time follows the rule of NFPA 1125, as ThrustCurve.org applies it. NFPA 1125 is the US National Fire Protection Association’s code for making model and high-power rocket motors. The burn runs from the moment the thrust first reaches 5% of peak to the moment it last falls to 5% of peak. Each crossing is interpolated on its segment (TC-G “Burn Time”; TC-S; TC-A lines 165–203). The peak and the crossings use delivered samples only (above). The last sample’s time is not the burn time (Loft lesson L39: Loft took it as the burn time).
-
Average thrust: total impulse over the NFPA 1125 burn time (TC-G “Average Thrust”; TC-A line 231).
- TC-S says instead “the total impulse during the 5%-defined burn time”. The two differ by the impulse outside the window, a median 0.13% on ThrustCurve’s public-domain curves (data notes). HPR Sim follows the glossary and the site’s code.
-
Impulse class: each letter covers twice the total impulse of the one before.
Agoes up to 2.5 N·s,Bto 5,Cto 10, and so on. In general , from1/8A() toO(), and on toZby doubling. Upper limits are inclusive: NAR statesCas “5.01 to 10.0 N-sec”. Loft gaveBfor 2.5 N·s (Loft lesson L38).
Propellant consumption
The effective exhaust velocity is the thrust divided by the rate at which propellant mass leaves, (SP glossary p. 95). Held constant through the burn, it makes the propellant burned proportional to the impulse delivered so far. When half the impulse has been delivered, half the propellant is gone. With the total impulse, the impulse delivered by time , and the propellant at ignition:
- This is [RP]
SolidMotor(solid_motor.py:401-418;motor.py:483-524). ThrustCurve’s.rsefiles tabulate their mass column the same way (.rsefiles). - Holding constant is an approximation. SP gives in instantaneous form, with the propellant’s mass flow (p. 95). Measured specific impulse (, the same quantity divided by standard gravity) drifts during a burn as the nozzle erodes: one motor lost 6 to 9 s of specific impulse by burnout (SP p. 14). Its efficiency also differs with the pressure inside the motor, in a comparison between motors rather than along one burn (SP Fig. 18, p. 40, which plots vacuum specific-impulse efficiency against chamber pressure). So real consumption is not exactly proportional. No data published for commercial motors resolves the difference.
- All propellant is gone at the last sample. The whole burned mass leaves as exhaust. Inert material that also leaves (bits of liner and igniter) is not modeled.
Where the propellant is
-
Column (
Propellant::Column): a hollow cylinder (outer radius, inner radius, length) at a fixed center. It keeps its shape and loses density as it burns, soThis is [RP]
GenericMotor’s model (motor.py:1580-1649, a solid cylinder). -
BATES grains (
Propellant::Grains): identical BATES grains (outer radius, starting bore radius, starting height), spaced apart, with a gap between them. Each burns on its bore, the hole along its axis. It also burns on both ends unless the ends are inhibited: coated so that they can’t burn ([RP]solid_motor.py:487-632).- Every grain needs a bore (). A solid end burner is a grain with no hole that burns only on one face. It shortens without widening. This regression (the way the grain burns back) doesn’t describe that, and neither does RocketPy’s.
- Facing ends burn even with no gap, as in [RP].
- Every burning surface recedes by the same depth , the web burned so far (the web is the thickness of propellant between the burning surfaces). The first formula holds with the ends burning, for ; the second with the ends inhibited, for :
and
Here is one grain’s volume and the propellant’s density, so the last line says the grains hold the propellant left.
-
[RP] integrates , in time, with the burning area. It uses LSODA, a general-purpose solver for ordinary differential equations (ODEs), from the Python library SciPy. Because , that ODE is the relation above. HPR Sim solves it for by safeguarded Newton iteration, exactly at any time. That is Newton’s method, which improves a guess using the slope, kept inside an interval known to hold the answer. A step that would leave the interval halves it instead.
-
comes from the geometry, as in [RP].
-
About the stack’s center, which doesn’t move:
The last term sums over the grain offsets ([RP]
solid_motor.py:724-740,784-789).
The whole motor
-
The dry mass (case, closures, liner, nozzle: everything but the propellant) is one element: mass, center and inertias about its own center.
with_added_dry_massjoins more hardware, such as a retainer (the cap or clip that holds the motor in its mount). It must be positive: at burnout it is the whole motor, and with no mass it has no center. -
The motor is the dry mass and the propellant combined about the instantaneous center with the parallel-axis theorem:
This is [RP]
Motor.I_11(motor.py:585-666). -
The envelope default (
SolidMotor::from_envelope) applies when only the motor’s size and masses are known, as from a catalog entry or a motor file’s header:- the propellant is a solid column of radius filling the length, centered at ;
- the dry mass (loaded minus propellant) is a thin tube, and , also centered at .
These are crude: the center of mass stays at throughout. Loft fixed the CG at the midpoint with no inertia of its own (Loft lesson L40). HPR Sim gives the parts inertia, and moves the CG as soon as the dry and propellant centers differ.
- ThrustCurve’s loaded mass includes the reusable case (TC-G “Total Weight”: “propellant and case”).
- [RP]
GenericMotor.load_from_engsets its chamber radius to the motor diameter (motor.py:1759-1761). That quadruples the inertia terms (and the default nozzle area it derives from that radius). HPR Sim uses .
-
A catalog entry’s diameter, length and masses are its curve file’s header values (A motor from a file). ThrustCurve.org’s own records differ in a few places (the bundled motors).
The effective exhaust velocity is a units check
Both constructors, SolidMotor::new and SolidMotor::from_envelope, work out the effective
exhaust velocity from the curve and the propellant mass. They refuse a motor whose
is outside 200 to 5,000 m/s (656 to 16,404 ft/s). It is a guard against a slip in the units
of the propellant mass, not a filter on propellant:
- It catches a propellant mass in grams typed where kilograms belong, such as a
.rsefile’spropellant_mass_gpassed unconverted. That moves by a factor of 1,000. Nothing else in the API notices. Take the 411I175’s envelope typed in millimeters and grams,from_envelope(curve, 38.0, 245.0, 228.9, 437.5). It has positive, finite dimensions and a propellant mass below the loaded mass, and an exhaust velocity of 1.8 m/s (5.9 ft/s). The grams give it away, and the check refuses it. - It can’t catch a size in the wrong unit. doesn’t depend on the diameter or the length, and
the motor accepts any positive size. The example’s I377 with its size left in millimeters,
from_envelope(curve, 38.0, 292.0, 0.250, 0.560), is accepted, at the same 2,103 m/s (6,900 ft/s). Only the design checks see a size, and only the one given to theMountedMotor(Checks). A diameter wider than the mount’s bore is an error,motor_wider_than_mount, and the flight refuses to start unless design errors are accepted (--accept-design-errors). Within a nominal size’s slack for its narrower case it only warns,motor_tight_in_mount. A case that runs forward past the mount’s top is only a warning,motor_past_mount_top, so a length slip alone still flies. Nor does involve the loaded mass, so a loaded mass in grams passes too. - It lets through every real motor checked. In an earlier survey, the 1,708 ThrustCurve.org files whose motor’s record gives a propellant mass, each taken with that mass, ran from 236 to 3,031 m/s (774 to 9,944 ft/s). Their median is 1,866, and 90% of them are between 928 and 2,210. In the whole catalog, the 924 motors’ default files, each with its own header’s propellant mass, run from 296.83 m/s (973.9 ft/s, a black-powder A8) to 4,128.18 m/s (13,543.9 ft/s, a J228). That highest is no real motor’s: the J228’s header gives 270 g of propellant, where ThrustCurve.org’s record gives 569 g. The guard lets it through, and the J228 flies with 270 g. Since issue #1003 closed, a file more than 5% short of its record’s propellant draws a warning when it flies.
- Its headroom is real but not great at either end. In the earlier survey both ends are data errors. The lowest, 1.18x above the floor, is a Cesaroni E75 record giving 104 g of propellant for a 52 g motor. The highest, 1.65x below the ceiling, is a misfiled curve. The lowest value NAR’s list backs, a Quest B4’s, is 1.85x above the floor. In the catalog HPR Sim flies, the J228 above is 1.21x below the ceiling. Issue #11 records the fallback if a motor ever falls below 200 m/s (656 ft/s).
here is the curve’s own impulse, uncorrected for air pressure. The reasoning in full, the table of percentiles, and two figures that were once got wrong are in the exhaust-velocity note.
Thrust at altitude
A motor pushes harder in thinner air. Its thrust has two parts. One is the momentum of the exhaust. The other is a pressure term: the exhaust’s pressure at the nozzle exit less the air’s, times the exit area (SP eq. 2, p. 3; SP-8039’s unit constant is 1 in SI):
Here is the mass flow and the exhaust speed at the exit. is the exit pressure, the ambient (air) pressure and the exit area. With the flow unchanged, a curve measured at reference pressure gives, at ambient ,
- SP doesn’t print this conversion; it follows from eq. 2. [RP]
Motor.pressure_thrust(motor.py:1173-1191) applies the same term. - is the air pressure at the static test site, where the motor was fired on a test stand
to measure its curve. It is stored with the nozzle (
Nozzle::reference_pressure_pa). Motor files and catalogs don’t record it, so a design gives it, or gives none (below). Standard sea-level pressure (101 325 Pa) suits a motor tested near sea level, but it is a guess. Take a test at 1,500 m (4,921 ft) elevation, 84.6 kPa in the 1976 standard atmosphere. For that motor, sea-level pressure makes the term 16.8 kPa × too large at every altitude. - It holds while the exhaust fills the nozzle to its exit. A nozzle made for high altitude, tested at sea level, can have its flow come away from the nozzle wall (separate). Then the conversion doesn’t hold. That is this project’s inference. SP pp. 32–34 say the flow stays attached while the outside pressure is “less than or only slightly greater than” the exit pressure, that an outside pressure “considerably greater” can separate it, and that an overexpanded nozzle delivers less thrust.
- HPR Sim applies it strictly inside the burn, ( the curve’s last time), as
RocketPy’s flight does (
simulation/flight.py:1936-1956). HPR Sim applies the term only where the curve’s thrust is positive; RocketPy also adds it inside zero-thrust gaps, where nothing flows. HPR Sim never lets thrust go negative. Without a known nozzle it returns the curve. Commercial motor files carry no exit diameter:.enghas no field for one, and the.rseformat’sexitDiaattribute is always 0 (.rsefiles). So a motor read from a file or the catalog gets no correction. - A nozzle may leave
reference_pressure_paempty (None,nullin a design file). The curve is then flown as it is at every pressure, which is what RocketPy does by default: itsMotor(reference_pressure=None)makespressure_thrustzero (motor.py:1188-1189). The designs transcribed from RocketPy’s examples sayNonefor that reason (ADR-021). Take the Valetudo of Getting started, at a 1,400 m (4,593 ft) site. With the sea-level stand-in it carried about 23 N of thrust (15.7 kPa × 1.47e-3 m²) that RocketPy’s example never flies. It reached 874 m (2,867 ft), where it now reaches 779 m (2,556 ft). A design must say which it means. The key is required,nullfor none, so leaving it out is an error rather than a silent choice. The unit testhpr_motor::motor::tests::pressure_correction_uses_the_exit_areapins both forms and the missing key. - The full-flow term steps in just after ignition and steps to zero at (the integrator should treat both as events). The ignition transient is the first moments, while the pressure inside the motor builds. The tail-off is the end of the burn, while that pressure falls. In both, the real exit pressure is far from its full-flow value, so the term misstates thrust there. In the tail-off, where the exit pressure falls with the chamber’s, the term overstates thrust. Take the 411I175, with a 9.5 mm (0.37 in) exit radius, 19 mm (0.75 in) across, in vacuum. In the 0.14 s after the NFPA 1125 burn ends, the term adds 3.9 N·s, and the curve itself delivers 0.45 N·s. The 3.9 N·s is 0.95% of total impulse.
Delays
A motor’s ejection delay is the time from burnout to its ejection
charge, which deploys the recovery. TC-G lists every achievable delay, adjustable ones included.
A plugged motor has no ejection charge, and files mark it P. See
hpr_motor::delay and .eng files for
the markers files use. A 0 is read as its own “zero or plugged” setting. The RASP spec says it
means ejection at burnout, but most files mean plugged. HPR Sim never turns it into an ejection
event by itself: the user has to decide.
Validation and example
The tests that pin the motor model, and the whole example program.
Validation
- Catalog (
catalog::tests): every figure the catalog lists is its curve file’s own, bit for bit, so whathpr motorslists is what flies. Each file’s stored check is worked out again from the file and its motor’s committed record. 412 of the 1,701 files pass. For the 32 first bundled, 1% was the bundling rule, and all 32 pass. In Loft, a mis-sourced curve flew about 26% high (Loft lesson L42). Of 554 public-domain curves, 196 passed (data notes, which also list the four motors whose stored values are printed coarser than 1%). Each of those 32 files is public domain, its bytes matching the SHA-256 checksum (a fingerprint of a file’s exact bytes) recorded at download. These checks answer Loft lessons L41 to L43, on curve licenses, loose impulse checks and wrong headers. - ThrustCurve’s code (
catalog::tests::every_bundled_curve_matches_thrustcurve_statistics_code):validation/oracles/thrustcurve/analyze_stats.jsruns TC-A (ThrustCurve.org’s code), its bytes unchanged, on every file stored as passing, 412 of them: once as the site runs it, and once with its merge turned off. It writes the results to a fixture,validation/fixtures/motor/thrustcurve-analyze-stats.json. HPR Sim’s impulse, burn window, burn time, average and peak thrust agree to 3e-15, relative: the largest gap measured is 2.93e-15, and the test fails above 1e-12. A burn window’s start under 1 ms is compared in seconds instead, and agrees to 3e-18 s. So the definitions are checked, not only the 1% rule.- Two or more samples at the same time are read differently, on purpose
(the decision record). HPR Sim reads them as a step: the thrust jumps from the
first value to the second, because a vertical drop is what the file draws. TC-A merges
points less than 50 µs apart into one point at their average thrust. 8 of the 412 files have
such points. The script also runs TC-A with that merge turned off (its
timeEpsilonset to 0), and on those 8 files HPR Sim is held to that run. On 6 of them the merge moves a figure, and the test names each; on the other 2 it moves none. The largest move is in the RockSim file of Cesaroni’s 2372K1440-17A, which has 1,061.8 N and then 2,168.21 N, both at 0.01 s. HPR Sim reads a jump, so its peak is 2,168.21 N. TC-A averages the two to 1,615 N, below the next sample, 2,036.3 N, which becomes its peak. So HPR Sim’s peak thrust is 6.5% higher. Another file’s burn time is 0.61% longer here. - The recount (
analyze_stats.js --recount) works out which files pass from the raw snapshot ThrustCurve.org answered, with TC-A and not HPR Sim’s code, and fails unless the index agrees. It agrees on all 1,701 files the index holds: 412 pass, and 239 motors have one that does. One file passes with every sample kept and would fail with the merge: Cesaroni’s 2765L730-P file, whose burn time is 0.68% short of its record here and 1.28% short after the merge. The raw snapshot isn’t committed, so the recount runs on the maintainer’s machine, not in CI. - CI runs
cargo xtask motor-catalog --check. It works out each file’s figures again from its bytes, and fails if a file stored as passing is more than 1% from its record, or a file stored as failing is within 1% of it.
- Two or more samples at the same time are read differently, on purpose
(the decision record). HPR Sim reads them as a step: the thrust jumps from the
first value to the second, because a vertical drop is what the file draws. TC-A merges
points less than 50 µs apart into one point at their average thrust. 8 of the 412 files have
such points. The script also runs TC-A with that merge turned off (its
- OpenRocket (
catalog::tests::openrocket_s_total_impulse_matches_every_bundled_curve):validation/oracles/openrocket/motors.pyhands each of the same 32 files to OpenRocket 24.12’s own motor loader. It records what the loader makes of it invalidation/fixtures/motor/openrocket-curve-stats.json, tied to each file by its SHA-256. The two codes are compared on the same bytes, so what is measured is the arithmetic, not two catalogs’ data for one motor. Four numbers are identical, to the last bit of anf64, on all 32 curves. They are total impulse, peak thrust, the 5%-of-peak burn-time window (OpenRocket’sgetBurnTimeEstimate) and the curve’s whole duration. That duration is OpenRocket’sgetBurnTime, the last listed time rather than a window. The test holds the impulse to the 0.1% that M2.2c asks for, met with everything to spare. It also asserts the bit-for-bit equality, so this paragraph cannot go stale while the suite stays green. Both codes integrate the listed points as straight lines. Both prepend(0, 0)to a file whose first point is after ignition (29 of the 32 start between 1 and 40 ms). So the point counts match as well, and nothing rounds differently.-
One definition genuinely differs, and is recorded rather than held (ADR-066): the average thrust. Both codes divide by the same 5% window. OpenRocket’s numerator is the impulse inside it, while HPR Sim’s, following TC-A, is the whole curve’s. The tails below 5% are the difference. So HPR Sim’s average is the higher on every one of the 32, by +0.0107% to +0.3147% (median +0.0965%). The test prints all three. Carrying an average thrust between the two codes means saying which numerator it used.
-
Curves outside this repository are held to the same bound. They are not committed, so
cargo xtask orkchecks them on the machine that has them. It fails if one is outside 0.1% (M2.2c2, ADR-067):- The curves the reference library’s designs embed, which are other people’s data. HPR Sim parses each file itself, so these are real checks. All 3 agree to the last bit.
- Every solid curve in the motor database OpenRocket 24.12 ships: 1,288 of its 1,452 motors, the rest hybrids. The survey supplies them to designs that name a curve by digest without carrying it. Both codes integrate the samples OpenRocket has already parsed, so agreement to the last bit proves the hand-off, not two independent readings.
The counts, and what the database motors’ masses leave out, are on the
.orkformat page.
-
- RocketPy (
motor::tests::matches_rocketpy_solid_motor_for_three_bundled_motors): three bundled curves with BATES loads. They cover grains that burn out radially (the bore reaches the outer wall first) and axially (the burning ends meet first). They also cover inhibited ends, and both of RocketPy’s axis directions (positions measured from the nozzle forward, or toward the nozzle).validation/oracles/rocketpy/solid_motor.pywritesvalidation/fixtures/motor/rocketpy-solid-motor.json, and regenerates it byte for byte.- On 203 times per motor, total mass, and agree within 7.9e-5 of RocketPy’s own values. At the same times the center of mass agrees within 5.9e-6 of the motor length.
- Quantities that go to zero are compared against a fixed scale. Propellant mass and inertias use their ignition values, grain height its initial height, and centers the motor length. On that scale they agree within 1e-4. Before burnout the propellant mass differs by up to 69% of RocketPy’s own value, where RocketPy holds 6.9 mg in the 38 mm motor. That comes from RocketPy’s interpolation between the points its ODE solver stored.
- The test holds 0.1% on these scales.
- Files: 1,710 of ThrustCurve’s 1,712 solid-motor files read, and write back out and read again
with every value identical to the last bit. The other two have times that go backwards
(
.rsefiles). - Unit and property tests cover exact impulse integration, burn windows, grain volume inversion, the parallel-axis theorem, and the impulse-fraction flow integrating to . Property tests check a rule on many random inputs.
The example program
This is the whole of
crates/hpr-sim/examples/motors.rs,
line for line the file CI runs. Using a motor walks through what it does.
//! Motors: the thrust curves that come with HPR Sim, and a motor read from a RASP `.eng` file
//! like the ones ThrustCurve.org serves, put in a rocket's motor mount and flown.
//!
//! Run it from anywhere in the repository:
//!
//! ```text
//! cargo run --example motors -p fusionspace-hpr-sim
//! ```
//!
//! The documentation site's *Solid motors* page (`docs/physics/motor.md`, "Using a motor") walks
//! through it. What it prints is kept next to it in `motors.output.txt`, and CI checks that the
//! two still agree (`cargo xtask examples --check`).
#![allow(
clippy::print_stdout,
reason = "the project's lints forbid printing in library code, and this program exists to print"
)]
use std::error::Error;
use hpr_core::geodesy::Geodetic;
use hpr_design::{Configuration, Ignition, MountedMotor, Rocket};
use hpr_motor::catalog::MotorType;
use hpr_motor::{Catalog, ImpulseClass, SolidMotor, eng};
use hpr_sim::{Environment, EventKind, FlightSettings, Rail, Simulation, Termination};
fn main() -> Result<(), Box<dyn Error>> {
// 1. The motors that come built in: every solid motor in ThrustCurve.org's catalog. Most
// have a curve file; a motor whose files all fail ThrustCurve.org's 1% check still flies,
// with a warning. One per impulse class here: the first in the catalog's order with a
// file that passes. Size and loaded mass are its file's header values; impulse, class,
// average thrust and burn time are worked out here from its curve.
let catalog = Catalog::bundled()?;
let with_curve = catalog
.motors
.iter()
.filter(|entry| entry.default_curve().is_some())
.count();
println!(
"{} motors come built in, {with_curve} of them with a curve file. One of each class:",
catalog.motors.len()
);
println!();
let mut classes = Vec::new();
let shown: Vec<_> = catalog
.motors
.iter()
.filter(|entry| {
entry
.default_curve()
.is_some_and(|curve| curve.check.passes)
})
.filter(|entry| {
let new = !classes.contains(&entry.impulse_class);
if new {
classes.push(entry.impulse_class);
}
new
})
.collect();
let heading = [
[
"", "", "", "", "dia", "length", "loaded", "total", "average", "burn",
],
[
"designation",
"maker",
"type",
"class",
"mm",
"mm",
"mass g",
"impulse N·s",
"thrust N",
"time s",
],
];
for [a, b, c, d, e, f, g, h, i, j] in heading {
println!("{a:<12} {b:<8} {c:<10} {d:<5} {e:>5} {f:>7} {g:>9} {h:>11} {i:>9} {j:>7}");
}
for entry in shown {
let motor = entry.bundled_motor()?;
let curve = motor.curve();
let kind = match entry.motor_type {
MotorType::SingleUse => "single-use",
MotorType::Reload => "reload",
_ => "other",
};
let class = ImpulseClass::from_total_impulse(curve.total_impulse_ns())?;
// An entry the catalog gives no loaded mass for would show a dash; every bundled one has
// a loaded mass.
let loaded_g = entry
.total_mass_g
.map_or_else(|| "-".to_owned(), |mass_g| format!("{mass_g:.1}"));
println!(
"{:<12} {:<8} {kind:<10} {:<5} {:>5} {:>7} {loaded_g:>9} {:>11.1} {:>9.1} {:>7.2}",
entry.designation,
entry.manufacturer_abbrev,
class.label(),
entry.diameter_mm,
entry.length_mm,
curve.total_impulse_ns(),
curve.average_thrust_n(),
curve.burn_time_s(),
);
}
// 2. A motor from a file. This is one of the bundled files, built into the program so that it
// runs anywhere. For a file you downloaded, read its text instead with
// `let text = std::fs::read_to_string("path/to/your-motor.eng")?;`
let text = include_str!("../../hpr-motor/data/thrustcurve/curves/5f4294d20002e90000000863.eng");
let parsed = eng::parse(text)?;
for warning in &parsed.warnings {
println!("warning, line {}: {}", warning.line, warning.message);
}
let [entry] = &parsed.value.entries[..] else {
return Err("expected one motor in the file".into());
};
// The file gives the size in millimeters and the masses in kilograms; the motor takes meters
// and kilograms. Only the size needs converting, and the motor can't tell if it isn't: its
// units check looks at the impulse and the propellant mass, not the size.
let diameter_m = entry.diameter_mm * 1e-3;
let length_m = entry.length_mm * 1e-3;
let motor = SolidMotor::from_envelope(
entry.thrust_curve()?,
diameter_m,
length_m,
entry.propellant_mass_kg,
entry.total_mass_kg,
)?;
let curve = motor.curve();
println!();
println!(
"From the .eng file: {} by {}, {} mm by {} mm, {:.0} g loaded, {:.0} g of propellant",
entry.name,
entry.manufacturer,
entry.diameter_mm,
entry.length_mm,
entry.total_mass_kg * 1e3,
entry.propellant_mass_kg * 1e3,
);
println!(
" {:.1} N·s (class {}), {:.1} N average over {:.2} s, {:.1} N peak",
curve.total_impulse_ns(),
ImpulseClass::from_total_impulse(curve.total_impulse_ns())?,
curve.average_thrust_n(),
curve.burn_time_s(),
curve.peak_thrust_n(),
);
println!(
" effective exhaust velocity {:.0} m/s",
motor.exhaust_velocity_m_s()
);
// 3. Into a rocket: a new configuration that puts the motor in the design's motor mount. The
// rocket is Valetudo, the rocket of `first_flight.rs`. Its mount is 43 mm inside, so this
// 38 mm motor fits: the design checks compare the case diameter given here with the bore.
let mut rocket: Rocket = serde_json::from_str(include_str!(
"../../../validation/designs/rocketpy-valetudo.json"
))?;
rocket.configurations.push(Configuration {
id: "from-file".to_owned(),
name: format!("{} from its .eng file", entry.name),
motors: vec![MountedMotor {
mount: "motor-mount".to_owned(),
designation: entry.name.clone(),
diameter_m,
length_m,
motor,
// No ejection delay is chosen: this flight carries no parachutes.
delay: None,
ignition: Ignition::Launch,
failed_tubes: Vec::new(),
}],
});
// Fly it, straight up from a 3 m rail in calm air, with no parachutes.
let site = Geodetic::from_degrees(32.99, -106.97, 1400.0)?;
let simulation = Simulation::new(
&rocket,
"from-file",
Environment::standard(site)?,
Rail::vertical(3.0),
FlightSettings::default(),
)?;
let flight = simulation.run(&mut ())?;
if flight.termination != Termination::GroundHit {
return Err(format!("the flight ended with {:?}", flight.termination).into());
}
let sample = |kind| {
flight
.event(kind)
.map(|event| event.sample)
.ok_or(format!("the flight has no {kind:?}"))
};
let (liftoff, rail_exit, apogee) = (
sample(EventKind::Liftoff)?,
sample(EventKind::RailExit)?,
sample(EventKind::Apogee)?,
);
println!();
println!(
"Valetudo on the {}: {:.2} kg at liftoff",
entry.name, liftoff.mass_kg
);
println!(
" leaves the 3 m rail at {:.1} m/s",
rail_exit.cg_velocity_enu_m_s.length()
);
println!(
" apogee {:.1} m above the pad, at {:.2} s",
apogee.height_above_ground_m, apogee.time_s,
);
println!("Not yet validated: see the Accuracy page before trusting these numbers.");
Ok(())
}
Aerodynamics
See how HPR Sim computes drag, normal force, center of pressure and roll from canted fins, subsonic and, less certainly, supersonic.
In short
-
What it models: the air’s forces on a rocket. The normal force is the sideways push at an angle to the airflow, and the center of pressure is where it acts. Both run from Mach 0 to 5, as do drag, the rolling moment from canted fins and the roll rate. A flight can use another program’s drag, or its normal force and center of pressure, instead of HPR Sim’s (The normal force from RASAero II).
-
Sources: Barrowman’s 1966 report, 1967 thesis and Centuri TIR-33 (1970), the basis of Barrowman’s method. Supersonic linear theory for fins past Mach 1. For drag, mainly Niskanen’s 2009 OpenRocket thesis. Stoney’s 1961 NASA measurements of noses through Mach 1 and MIL-HDBK-762 (1990) for boattails faster than sound add to it. For tube fins, Weissinger’s ring-wing formula and Fletcher’s 1957 NACA measurements.
-
How well it is validated:
-
Faster than sound, drag is only partly validated, and it misses both ways. It reads high against a wind tunnel, most of all for thin, sharp fins. The body alone reads a little low against a handbook’s worked example. A rocket with a short, steep boattail reads 5% to 15% low against RASAero II. Treat a supersonic flight’s drag, and its apogee, as rough.
-
Against OpenRocket, faster than sound, HPR Sim’s supersonic pressure drag (mostly wave drag) is about twice OpenRocket’s on the one supersonic flight compared. The comparison was read from OpenRocket’s per-component output, not kept as a record. Which is right is open (#222, a supersonic flight). For the nose alone a public probe keeps a record: at Mach 1.3, 1.5 and 2, OpenRocket 24.12 gives a tangent ogive of fineness ratio 3 under 1% of the pressure drag its own documented method gives. That is a confirmed defect in OpenRocket 24.12. Whether HPR Sim’s value matches a measured nose stays open (a tangent ogive past Mach 1).
-
Base drag under power is checked against one measured flight, and HPR Sim’s reads low. HPR Sim takes the burning motor case’s area off the base (Niskanen); OpenRocket keeps the whole base. On a NACA missile model’s flight below Mach 0.8, whose motor case is wider than its base, HPR Sim’s rule leaves no base drag under power: too little drag, so too high an apogee (which error flatters). The whole base reads high, and the jet raised the base drag where either rule lowers or keeps it (Base drag under power against the Hermes A-3A’s flight). No hobby rocket’s has been measured (evidence row G14). On one private supersonic flight the choice moves the apogee by about 24 percentage points (#222, Drag).
-
A boattail’s own drag faster than sound against 58 readings of 20 measured boattails of 3° to 10°, Mach 1.2 to 3.12: −21.9% to +28.3%. It is within 0.0123 in drag coefficient. Through Mach 1 it reads low, and under Niskanen’s subsonic rule long boattails get almost nothing. Steeper ones in a thick boundary layer read high: +26.4% to +54.2% for 16°. The drag of the base behind a boattail is within 0.0102 of 12 measured bases. Behind a small base, that difference can be 40% of the base’s own drag (Boattails faster than sound).
-
Drag reads high against a wind tunnel. NASA’s wind-tunnel tests of the Arcas Robin sounding rocket, Mach 0.6 to 4.63, measured the forebody only (the models’ bases sat on a sting). Against them every reading is high, and 2 of 44 are within 10%, both at Mach 1.0 with the fins on. With the fins on, from Mach 1.5 up, HPR Sim reads +39.4% to +154.0% high: the fins take a blunt edge’s formula. With the fins off it reads +13.5% to +24.1% from Mach 1.5 and +12.0% to +54.1% below. Most of that fins-off excess is the models’ 15° boattail. HPR Sim over-predicts that boattail’s drag in a boundary layer thicker than the boattail is deep. HPR Sim’s base drag behind a plain cylinder has been checked against no measurement faster than Mach 0.3 (Drag against the Arcas Robin wind tunnel).
-
Drag reads low against RASAero II past Mach 1.6, missing M1.8’s 10% there. The curves labeled RASAero in RocketPy’s example rockets don’t record their fins or surface finish, so HPR Sim uses stated guesses. Against Calisto’s, the one real RASAero II export, HPR Sim is within 10% at every Mach number up to 0.8. It is within 10% at 5 of the 7 between and at 8 of 17 from 1.2 to 2.0. There it reads −14.9% to −5.1%, lowest at Mach 2 (evidence row G26). Other plausible fins bring 14 to 17 of the 17 within 10%, though none puts every row of every band within it. Before HPR Sim modeled the boattail’s wave drag, it read −29.8% to −24.4% there (Drag against RASAero II through Mach 2).
-
Drag at Mach 0.3 against the same curves: two of seven cases within 10%; two boattailed ones fell just outside when the base behind a boattail was relieved (ADR-362). Cavour under power (motor burning) is −18.3%, cause open, and Valetudo’s table is 1.44 times its own OpenRocket export.
-
Against MIL-HDBK-762’s worked example, a rocket whose drag the U.S. Army’s handbook calculates term by term with every input known. With the fins left out, HPR Sim is within 10% at 6 of 12 Mach numbers. It reads +12.3% to +31.9% from Mach 0.9 to 1.2 (the nose and the base). From Mach 1.6 it reads −6.0% to −9.6% (friction and the base) (Drag against MIL-HDBK-762’s sample calculation).
-
The normal force and center of pressure at Mach 0 against Barrowman’s worked examples (rockets he calculated by hand). Every center of pressure agrees within 1%, and so does every normal-force slope but his six-fin Recruiter’s. It is +2.87% high for the rocket and +3.42% for its fins, mostly from a different six-fin rule. Against the same wind tunnel, Mach 0.6 to 4.63, from Mach 1.5: slope within +9.4% to −3.3% and center of pressure within 0.53 calibers. The long model misses the half-caliber target at Mach 1.8 and 2.3, where its body reads high. From Mach 0.8 to 1.2 the short model misses a target at four of five rows. The long one misses at all three from 0.9 (Normal force through Mach 1).
-
On a second measured body, the Basic Finner, free flights in a Canadian range from Mach 1.08 to 3.15 show HPR Sim’s slope 9.3% to 24.9% low and its center of pressure 0.03 to 0.34 calibers forward, the side that understates stability. The cause is not found (The Basic Finner’s normal force against DREV’s range). Against the same flights, with its wedge fins’ drag modeled from published figures, HPR Sim’s zero-lift drag reads 16.5% to 21.3% low from Mach 1.83 to 3.15, cause not found. Its pitch damping reads 24.7% to 39.6% low there, and 25.4% high at Mach 1.077 (The Basic Finner’s drag and pitch damping).
-
The body faster than sound, by the method a flight blends in over 0.3 in Mach from Mach 1.2 at the earliest. On the bodies it covers, against its report’s wind-tunnel measurements of 120 cone- and ogive-cylinders from Mach 3 to 6.28. There, 117 slopes are within ±0.2 per radian and 109 centers of pressure within 0.2 calibers. The method is checked against the Arcas Robin wind tunnel’s body alone (its two lengths, the short model and the long). The nose is a pointed one fitted to its shape, and the lip behind its boattail is left off (Checking the shock-expansion method):
- Like for like, fitted at the tunnel’s angles with the body lift a flight adds, the body with its boattail reads +3.4% to +41.0%. It is within 15% from Mach 3.96. Before M1.8e6 sized body lift and the boattail’s share, it read 14.9% to 73.2% high. At its 62 angles from 5.5° to 21.7°, 48 are within 15%.
- The method alone at against the tunnel’s line, which includes crossflow. The nose and cylinder of the short model: within 5% from Mach 1.8 to 2.96, and −15.0% and −18.7% past Mach 3. The long model: −13.7% to −26.4% throughout.
HPR Sim’s committed Arcas Robin designs fly that method to their base since M1.8e8. Like for like, the short model’s body reads 3.02 to 3.95 per radian from Mach 1.5. From Mach 1.5 the tunnel reads 2.19 to 4.15 (Normal force through Mach 1).
-
In whole flights in wind, body lift, which RocketPy leaves out, is the largest reason a slow rocket’s drift differs from RocketPy’s (ADR-026). Nothing against a real flight.
-
Roll: the spin that canted fins give, against NASA’s measured roll effectiveness (the rolling moment per degree of cant). Within 5.3% at all 8 readings from Mach 2.3 to 4.63, and 14.3% to 47.8% high at Mach 1.5 and 1.8. The roll damping reads 11.7% to 27.5% high from Mach 1.53 to 2.76 against the US Naval Ordnance Laboratory’s (NOL’s) wind tunnel, and 8.8% high on average in the core band and 5.0% in the extended band against Canada’s DREV free-flight range, both on the Basic Finner, a standard finned test body (Roll against the Arcas Robin and the Basic Finner).
-
Another program’s normal force, read from RASAero II’s export: every row of Calisto’s export comes back from HPR Sim’s table. A flight on a table swings in pitch as the equations predict. No real export has flown faster than Mach 0.75 (The normal force from RASAero II).
-
Pods take each pod’s parts on Barrowman’s rules, once per pod. They are checked against hand-worked numbers, and against OpenRocket on six probe designs, within 0.92% of its apogee below Mach 0.81. No measured flight checks them. Both codes leave out the pods’ and the body’s effect on each other’s flow, and HPR Sim a single pod’s off-axis moments (Pods).
-
Tube fins, each tube a ring wing below Mach 0.8: the slope is within 3% of five rings measured in a wind tunnel. No tube fin rocket has been checked against a measurement. On OpenRocket’s example, HPR Sim’s apogee is 6.95% higher, a net gap in the drag. OpenRocket’s tube-fin drag was refined against real flights, so HPR Sim’s probably reads low. The center of pressure rests on a judgment that moves that example’s margin from 0.29 to 0.79 calibers, against OpenRocket’s 1.87. The gap to OpenRocket is measured on 14 probe designs and pinned by a test; nothing measured says which code is nearer (Tube fins, #228).
-
-
What it leaves out: large angles and stall, though a flight uses these models at every angle. Faster than sound (transonic and supersonic):
- A steep boattail’s drag in a thick boundary layer reads high, and nothing corrects for it.
- The fins’ drag takes a blunt edge’s formula, which reads far high for thin, sharp fins.
- Nothing models a thin fin’s own wave drag or the drag where fins meet the body.
- A flight takes a pointed nose and its cylinder from the shock-expansion method, which marches along the body and adds the cylinder’s lift.
- A boattail behind them comes from a measured correlation of boattails of 4° to 9.5°, an extrapolation for steeper ones. HPR Sim stops reading it past the angle where the flow separates (The body faster than sound in a flight).
A nose with a vertical tip (power-series, Haack, elliptical) takes a Newtonian cap ahead of the method, checked on a sphere-cone only (Blunt tips). A lip inside a boattail’s wake carries nothing (A lip in a boattail’s wake). A conical flare flush with the tube ahead of it flies the method too, last in its run, while its corner’s shock stays attached. Checked against one measured flare, it reads −1.9% and +7.0% at Mach 1.9 and 2.3 and +13.4% at 2.96. It reads +51.5% and +50.4% at 3.95 and 4.63 (What a marched flare is worth). A flare shallow enough to turn the flow almost not at all is read by an older, rougher method instead. Nothing measures it (A near-flat flare). A rocket with any other widening shape, or any step, behind the nose keeps slender-body theory for its whole body at every speed. A motor retainer behind a step down counts: the step ends the run. That theory reads low past Mach 3 (A step in radius: −8.65% and 1.03 calibers at the threshold). Body lift leaves out the fall in crossflow drag past the critical crossflow Reynolds number (Body lift). It reads too large at the few degrees a slope is fitted over. The body alone misses the 15% target the milestone set on six of eleven wind-tunnel rows, by +37.7% at worst. It is within 5% at Mach 3.96 and 4.63 (The body alone, against the 15% target). There are no damping coefficients for pitch and yaw: a flight takes that damping from each part’s own local flow. The roll forcing near Mach 1.5 reads high, the roll damping reads high faster than sound, and no committed comparison checks roll below Mach 1.5 (Roll: forcing and damping).
Code and conventions
Where the code and its sources are, the symbols the page uses, and how the parts’ forces add up to your rocket’s center of pressure.
Code and sources
Code:
hpr_aero::body(bodies of revolution)hpr_aero::crossflow(body lift)hpr_aero::fins(fin sets)hpr_aero::nose_drag(noses’ drag through Mach 1)hpr_aero::afterbody(boattails faster than sound)hpr_aero::shock_expansion(the body faster than sound)hpr_aero::blunt_tip(a blunt tip’s cap and its handover)hpr_aero::table(tables from other programs)hpr_aero::tube_fins(tube fins)hpr_aero::model(a whole rocket’s terms, built from itsLayout)
Decisions: ADR-008 (normal force and center of pressure) and ADR-009 (drag). The milestones:
- M1.5a: the subsonic normal force and center of pressure
- M1.5b: the subsonic drag and override tables
- M1.8a: the normal force through Mach 1 (ADR-027)
- M1.8b1: the drag through Mach 1 (ADR-028)
- M1.8b3: boattails faster than sound (ADR-030)
- M1.8c: roll (ADR-031)
- M1.8d: the normal force from RASAero II (ADR-032)
- M1.8e1: the body faster than sound
(
hpr_aero::shock_expansion, ADR-033), flown from M1.8e2 - M1.8e4: the boattail’s share of the body faster than sound
- M1.8e6: body lift’s size at every speed and the boattail’s
measured share
(
hpr_aero::supersonic_boattail, ADR-037)
The rest of transonic and supersonic flow arrives with the rest of M1.8, the supersonic aerodynamics milestone.
A Loft lesson is something learned from Loft, the project that came before FusionSpace HPR: usually a mistake it made, sometimes a check worth keeping. This page names the ones on aerodynamics and the test that covers each.
Sources:
- [B66] J. S. and J. A. Barrowman. The Theoretical Prediction of the Center of Pressure,
NARAM-8, 1966 (
barrowman-1966-naram8-nakka; the Apogee copy lacks pp. 39–50). - [B67] J. S. Barrowman. The Practical Calculation of the Aerodynamic Characteristics of Slender Finned Vehicles, MS thesis, 1967 (NASA/TM-2001-209983).
- [TIR] J. S. Barrowman. Calculating the Center of Pressure of a Model Rocket, Centuri TIR-33, 1970.
- [N09] S. Niskanen. Development of an Open Source model rocket simulation software, MSc thesis, 2009, chapter 3.
- [TD] OpenRocket technical documentation 13.05 (the thesis revised; a document, not code).
- [G] R. Galejs. Wind Instability: What Barrowman Left Out, Sentinel 39.
- [762] MIL-HDBK-762(MI). Design of Aerodynamically Stabilized Free Rockets, 1990.
- [TN2114] S. M. Harmon and I. Jeffreys. Theoretical Lift and Damping in Roll of Thin Wings with Arbitrary Sweep and Taper at Supersonic Speeds: Supersonic Leading and Trailing Edges. NACA TN 2114, 1950.
- [D4013] J. C. Ferris. Static Stability Investigation of a Single-Stage Sounding Rocket at Mach Numbers from 0.60 to 1.20, NASA TN D-4013, 1967.
- [D4014] C. D. Babb and D. E. Fuller. Static Stability Investigation of a Sounding-Rocket Vehicle at Mach Numbers from 1.50 to 4.63, NASA TN D-4014, 1967.
- [N6652] F. J. Regan. Roll Damping Moment Measurements for the Basic Finner at Subsonic and Supersonic Speeds, NAVORD Report 6652, US Naval Ordnance Laboratory, 1964 (DTIC AD0600975).
- [DREV] A. D. Dupuis and W. Hathaway. Aeroballistic Range Tests of the Basic Finner Reference Projectile at Supersonic Velocities, DREV-TM-9703, DREV (Valcartier, Canada), 1997 (DTIC ADA636861).
- [S61] W. E. Stoney. Collection of Zero-Lift Drag Data on Bodies of Revolution from
Free-Flight Investigations, NASA TR R-100, 1961 (
nasa-tr-r-100-stoney-1961); p. 11, the base drag of a conical afterbody. - [J53] J. R. Jack. Theoretical Pressure Distributions and Wave Drags for Conical Boattails, NACA TN 2972, 1953.
- [CS51] E. M. Cortright Jr. and A. H. Schroeder. Investigation at Mach Number 1.91 of Side and Base Pressure Distributions over Conical Boattails without and with Jet Flow Issuing from Base. NACA RM E51F26, 1951.
- [DN54] C. A. de Moraes and A. M. Nowitzky. Experimental Effects of Propulsive Jets and Afterbody Configurations on the Zero-Lift Drag of Bodies of Revolution at a Mach Number of 1.59. NACA RM L54C16, 1954.
- [MJ54] B. Moskowitz and J. R. Jack. Aerodynamics of Slender Bodies at Mach Number of 3.12 … V: Aerodynamic Load Distributions for a Series of Four Boattailed Bodies, NACA RM E54B11, 1954.
- [C57] J. M. Cubbage Jr., Jet Effects on the Drag of Conical Afterbodies for Mach Numbers of 0.6 to 1.28, NACA RM L57B21, 1957.
- [Love57] E. S. Love. Base Pressure at Supersonic Speeds on Two-Dimensional Airfoils and on Bodies of Revolution with and without Fins Having Turbulent Boundary Layers, NACA TN 3819, 1957.
- [C72] W. B. Compton III. Jet Effects on the Drag of Conical Afterbodies at Supersonic Speeds, NASA TN D-6789, 1972.
- [R1135] Ames Research Staff. Equations, Tables, and Charts for Compressible Flow, NACA Report 1135, 1953.
- [SD56] C. A. Syvertson and D. H. Dennis. A Second-Order Shock-Expansion Method Applicable
to Bodies of Revolution Near Zero Lift, NACA TN 3527, 1956 (also NACA Report 1328;
naca-tn-3527-syvertson-dennis-1956). - [S64] J. L. Sims. Tables for Supersonic Flow Around Right Circular Cones at Small Angle of
Attack, NASA SP-3007, 1964 (
nasa-sp-3007-sims-1964-cones-small-alpha). - [J77] L. H. Jorgensen. Prediction of Static Aerodynamic Characteristics for Slender Bodies
Alone and With Lifting Surfaces to Very High Angles of Attack, NASA TR R-474, 1977
(
nasa-tr-r-474-jorgensen-1977). - [WP68] W. D. Washington and W. Pettis Jr., Boattail Effects on Static Stability at Small
Angles of Attack. U.S. Army Missile Command report RD-TM-68-5, 1968
(
washington-pettis-1968-rd-tm-68-5). - [J68] C. M. Jackson Jr., W. C. Sawyer and R. S. Smith. A Method for Determining Surface
Pressures on Blunt Bodies of Revolution at Small Angles of Attack in Supersonic Flow, NASA TN
D-4865, 1968 (
nasa-tn-d-4865-jackson-1968). - [S62] A. Seiff. Secondary Flow Fields Embedded in Hypersonic Shock Layers, NASA TN D-1304,
1962 (
nasa-tn-d-1304-seiff-1962). - [R22] C. E. Rogers. RASAero II Comparisons with ARCAS Center of Pressure (CP) and Drag Coefficient (CD) Wind Tunnel Data, Rogers Aeroscience, 2022 (slides).
- [RAS] C. E. Rogers and D. Cooper. Rogers Aeroscience RASAero II Aerodynamic Analysis and Flight Simulation Program Users Manual, version 1.0.2.0, 2019.
- [F57] H. S. Fletcher. Experimental Investigation of Lift, Drag, and Pitching Moment of Five
Annular Airfoils, NACA TN 4117, 1957 (
naca-tn-4117-fletcher-1957-annular-airfoils). - [H65] S. F. Hoerner. Fluid-Dynamic Drag, 1965, p. 7-13, Ring Foil; p. 3-12,
Fig. 20, the forebody pressure drag of blunt heads; and p. 3-20, eq. 35, the subsonic base
drag of a body of revolution (
hoerner-1965-fluid-dynamic-drag). - [HB85] S. F. Hoerner and H. V. Borst. Fluid-Dynamic Lift, 1985, p. 19-16, Ducted Body
(
hoerner-borst-1985-fluid-dynamic-lift). - [W21] N. Wagner. Theoretical and Experimental Investigation into the Flight of an X-Zylo,
arXiv:2102.02647, 2021, eq. 15, quoting J. Weissinger, Zur Aerodynamik des Ringflügels, 1955
(
arxiv-2102.02647-x-zylo-ring-wing). - [PNK57] W. C. Pitts, J. N. Nielsen and G. E. Kaattari. Lift and Center of Pressure of
Wing-Body-Tail Combinations at Subsonic, Transonic, and Supersonic Speeds, NACA Report 1307,
1957 (
naca-report-1307-pitts-nielsen-kaattari-1957-wing-body-tail-lift).
Conventions
An aerodynamic coefficient is a force divided by the dynamic pressure and by the reference area. is the pressure of the oncoming air, , with the air’s density and the airspeed. A coefficient has no units, so one number describes a small rocket and a large one of the same shape. These are the page’s symbols; each section also defines its own.
| symbol | meaning | unit |
|---|---|---|
| , | the reference diameter, and the reference area that every coefficient here is divided by | m, m² |
| station, | a station: a position along the rocket, in meters aft of the nose tip (Frames, Design tree) | m |
| , , | the axes of the body frame, fixed to the rocket: along its axis toward the nose, the direction around the body that fins are placed from, and square to both | none |
| the Mach number: airspeed divided by the speed of sound | none | |
| the total angle of attack: the angle between the nose direction and the rocket’s velocity relative to the air, from 0 to (Frames). The oncoming air flows the opposite way, so at it meets the nose head-on | rad | |
| the flow roll: which way around the body the air crosses it, measured from toward (Frames) | rad | |
| the coefficient of the normal force: the sideways push, square to the axis, in the plane that holds the axis and the airflow | none | |
| the normal-force slope: how fast grows with . It is for , and the derivative at ([N09] eq. 3.8) | per rad | |
| the side-force coefficient: a sideways push across that plane, along × the direction the air crosses in. Only sets of one or two fins produce it | none | |
| CP | the center of pressure: the station where the normal force acts | m |
The rocket’s CP is the average of its components’ CPs , each weighted by that component’s slope ([B66] p. 38; [N09] eq. 3.29):
The components are the nose cones, transitions, body tubes and fin sets; a body tube’s own slope is 0 (Bodies of revolution, below). A rocket whose slopes add up to zero has no CP.
In code, the page uses these names:
| name | what it is |
|---|---|
Layout | a design resolved into placed parts, from Rocket::layout; it holds the reference diameter (reference_diameter_m) |
AeroModel | a rocket’s aerodynamic terms, built from its Layout |
Flow | the conditions a model is evaluated at: , and |
NormalForce | the result, for the whole rocket or one component: (coefficient), (slope_per_rad), the CP (cp_station_m, None when there is none) and (side_coefficient) |
NormalForce::moment_m | the normal force’s turning effect about the nose tip, divided by and : , in meters. At an angle of attack the CP is moment_m / ; unlike the CP, moment_m is defined even when the forces cancel |
Your rocket’s center of pressure
HPR Sim works out the CP from the rocket’s shape alone, the way Barrowman’s method does by hand. Each nose, transition and fin set gets its own slope and CP (the next two sections). Your own rocket prints the CP, the center of gravity and the stability margin of an example rocket.
To get it in code:
- Take the rocket’s
AeroModelfrom a simulation withSimulation::aero, or build one from a design withRocket::layoutandAeroModel::new. - Call
AeroModel::normal_forcewithFlow::axial(mach): the air straight along the axis, at a Mach number below 5. The result’scp_station_mis the CP, in meters aft of the nose tip, and itsslope_per_radis the rocket’s . AeroModel::components, at the same flow, lists each component’s share, which shows what moves the CP.
What changes it:
-
Speed. Below Mach 1.2 only the fins’ terms change with Mach number; past it the bodies’ can too (The body faster than sound in a flight). Up to Mach 0.8 the fins’ slope grows through the Prandtl-Glauert factor, the classic correction for the air’s compressibility. Its effect grows as the speed nears that of sound (Prandtl-Glauert, under Fins). How much a fin set gains depends on its span, area and sweep. So as the rocket speeds up, the CP moves toward its fins:
- With fins only at the tail, it moves aft.
- With canards (a second fin set near the nose) as well, both sets gain. The CP can move either way, depending on each set’s shape and place.
- Up to Mach 0.8 HPR Sim keeps each fin set’s own CP a quarter of the way along its mean aerodynamic chord (MAC). The MAC is a weighted average of its chords. From there the CP moves aft. The fins’ slope grows up to where supersonic theory starts, Mach 1.2 or later, and falls past it (Fins through Mach 1). So a fast rocket’s CP moves forward again.
Flow::axial(0.0)gives the low-speed CP that Barrowman’s method gives by hand. -
Angle.
Flow::axialgives the small-angle CP. At an angle of attack, body lift adds a force at each body’s side-view centroid (the center of its outline seen from the side). The CP moves with it (Bodies of revolution, below). -
Stability. A rocket is statically stable when its CP is aft of its center of gravity (CG).
Assembly::mass_propertiesgives the rocket’s mass, CG and inertia seconds after ignition. A simulation’s assembly comes fromSimulation::assembly.- Its
cg_mis the CG in body axes, so the CG’s station is−cg_m.z. - The CP’s station less the CG’s, divided by , is the stability margin in calibers.
- Flight metrics gives the margin from the rail exit to apogee or the first deployment, with the air along the axis. It gives the margin at Mach 0 (the static margin) and at the flight’s Mach number (the flight margin). It gives none where the slopes all but cancel.
Bodies of revolution
Nose cones, transitions and body tubes, from the outer profile. A shoulder (the sleeve of a nose or transition that slides into the next tube) is inside the body and adds nothing. For one component:
| symbol | meaning | unit |
|---|---|---|
| its length | m | |
| its cross-section area aft of its fore end; at the fore end, at the aft end | m² | |
| its volume | m³ | |
| its CP, aft of its own fore end (not the body axis ) | m | |
| its planform area: the area of its outline seen from the side. Body lift acts at its centroid, the center of that area | m² |
Body lift is the extra push of the air crossing the body at larger angles of attack. It grows with , so it adds nothing to the slope at . Its size is in Body lift, below.
The slope ([B66] eq. 10, [B67] eq. 3-65, [N09] eq. 3.19):
The CP, aft of the fore end ([B66] eq. 28, [B67] eq. 3-89, [N09] eq. 3.28):
The moment slope ([N09] eq. 3.25):
Body lift, at the planform centroid (Body lift; [J77] eq. 2.12):
- A nose with a sharp tip has slope 2. A cylinder has 0 and no CP. A boattail has a negative slope. The CP formula for a frustum (a cone with its tip cut off), [B66] eq. 44, still holds for a boattail ([B66] p. 21).
- Radius steps (an extrapolation). A step where one body component meets the next adds
at the joint. This is the limit of a transition whose length goes
to zero. So the body’s total slope is [B66] eq. 10 over the whole body. [B67] p. 18 assumes no
discontinuities, so this goes beyond the source. Leaving the step out would silently drop its slope (a 27 mm (1.1 in) nose base on
a 29 mm (1.1 in) tube loses 13%). It is reported with the aft component (
BodyAero::step_area_m2). A blunt front face gets no term, as eq. 10 gives. The design checks warn about steps (radius_step). The real flow separates there, and the drag buildup counts it as a zero-length shoulder or boattail (Steps in radius, under Drag). - and the planform come from integrating the real profile (
hpr_design::revolve), so ogive, power, parabolic and Haack transitions (Shapes) get their own CP. Loft used the conical transition’s CP formula for every shape (Loft lesson L9). [B66] puts a tangent ogive nose’s CP at instead, with the nose’s length: 0.2–0.9% different at fineness 2.8–5. - Slender-body theory’s slope has no Mach term. [B67] p. 18 leaves body compressibility out as a conservative choice. [N09] p. 22 takes the body’s normal force as the same at all speeds. Faster than Mach 1.2 a flight can use another method (The body faster than sound in a flight).
- Body lift is zero at , so Barrowman’s worked examples don’t test it.
Body lift
Changed in M1.8e6 (ADR-037): until then HPR Sim used Galejs’s constant, with at every speed.
That slope was fitted from −4° to +4°, and below Mach 1 body lift adds a little to it. The air crosses the body faster than sound from crossflow Mach 0.95. With Galejs’s constant, 34 of the 62 angles are within 15%, and the body reads 41% high at Mach 0.6, against the same poorly determined readings.
At an angle of attack the air meets the body partly from the side, at . Behind a long cylinder in a cross-wind the air separates, and the drag of that separated flow pushes the body sideways. Jorgensen sizes body lift from that drag through two factors. is the drag coefficient of an infinitely long circular cylinder in the crossflow. is the ratio of a finite cylinder’s to an infinite one’s. Both depend on the crossflow Mach number , the Mach number of the air crossing the body. also depends on the body’s fineness , its length over its largest diameter.
| term | formula or value | source |
|---|---|---|
| body lift | , at each part’s planform centroid | [J77] eq. 2.12, p. 10 |
| crossflow Mach number | [J77] eq. 2.3, p. 8 | |
| 1.20 up to 0.2, rising to 1.334 at 0.5 and 1.985 at 1.0, then falling to 1.266 by 4.8 | [J77] Fig. 1, p. 75 | |
| at low , | 0.577 at = 2, 0.685 at 10, 0.753 at 20, 0.815 at 40 | [J77] Fig. 4, p. 77 |
| with , | 0.69 at 0; 0.717, 0.804, 0.815, 0.845, 0.994, 0.979, 0.769, 0.910 and 0.937 at 0.4 to 1.2 in steps of 0.1; 0.985 at 1.4; 0.984 at 1.6 | [J77] Fig. 6, p. 78 |
| for fineness | the equation below, the most has reached up to that | HPR Sim’s, a judgment |
- is Jorgensen’s value below the critical crossflow Reynolds number, where the air separates from a smooth cylinder early: “” at low speed (p. 15). From 0.6 to 1.2 HPR Sim takes the points Jorgensen marks as extrapolated from NASA Ames wind-tunnel data. From 1.4 it takes his curve through the supersonic experiments.
- . (Jorgensen’s; the shock-expansion method below uses for something else.) Fig. 4 gives against length for cylinders measured only at low speed. Fig. 6 gives how grows toward 1 as the crossflow speeds up, but only for the two bodies it was computed from. Jorgensen divided the those bodies’ (fineness 10 and 12) measured normal force gives (his Fig. 5) by Fig. 1’s . For any other fineness HPR Sim scales Fig. 6’s by how much Fig. 4 changes it for the body’s length. It lets that scaling fade by the share Fig. 6 has risen toward 1. The share it uses, , never falls back. Fig. 6 dips at only because Jorgensen divided by Fig. 1’s peak there, not because length counts again. Below 0.8, where Fig. 6 only rises, this is ; past 0.8 every fineness takes Fig. 5’s to within 0.3%. That rule is HPR Sim’s; it gives Fig. 6 back for a body of fineness about 10.6 and stays below 1.
- Sampled, not smoothed. Near Fig. 1’s peaks and Fig. 6’s dips, each
steeply. HPR Sim reads both at the eleven crossflow Mach numbers Jorgensen computed Fig. 6 at and
interpolates between them. So their product is his own there: within 3% of his Fig.
5 at all ten points from 0.5 to 1.6 (test
the_product_follows_figure_5).
A worked example. NASA’s short Arcas Robin model without fins, fineness 18.18, has a planform of 20.79 times its cross-section. At Mach 2.3 and , . Fig. 4 gives ; Fig. 6 gives , so
With , , and body lift is
Adding the attached-flow part (the method’s slope at small angles, without crossflow), HPR Sim’s body gives 1.632 there; the tunnel measured 1.630. This point happens to agree closely; across the 62 points the spread is −22.3% to +31.7% (table below).
What changes in a flight. At the low crossflow speeds of most flights is : 0.82 at fineness 10, 0.90 at 20, 0.95 at 30, against Galejs’s 1.1. A slow rocket leaving the rail in wind feels it most (Validity and open questions). The tunnel points where HPR Sim reads high, the air crossing the body faster than sound, are at 12° to 21° from Mach 2.96 up. A flight meets such angles that fast only if it is unstable or hit by a strong gust.
How it was checked. The Arcas Robin wind tunnel measured the body alone from −5° to 21° at six
Mach numbers (TN D-4014). The points above +4° were read for this milestone
into
arcas-robin-high-alpha.json).
arcas-robin-crossflow.json
compares HPR Sim’s body at each point, with the pointed nose fitted to the tunnel’s and the lip left
off (Checking the shock-expansion method):
| crossflow Mach number | points | HPR Sim’s against the tunnel’s | with Galejs’s |
|---|---|---|---|
| under 0.45 | 21 | −6.9% to +31.7% | +1.9% to +61.4% |
| 0.45 to 0.95 | 25 | −22.3% to +13.0% | −21.1% to +17.0% |
| 0.95 and over | 16 | +0.8% to +16.5% | −21.7% to −7.1% |
At the lowest crossflow speeds the readings can’t split what is left between body lift and the slope at (Checking the shock-expansion method). Where the air crosses faster than sound, HPR Sim’s (1.45 to 1.61) is above what the tunnel’s points need (1.26 to 1.54). Jorgensen’s was worked out from measured normal force less his own attached-flow term, . HPR Sim pairs it with its own, times its slope. That term is 8% larger at 20°. Faster than sound it carries the method’s slope for the nose and cylinder, 2.55 to 3.40 against slender-body theory’s 2. Two cautions from Jorgensen: his comes from cylinders measured “only at very low subsonic Mach numbers” (p. 17). The other: the tunnel tripped its boundary layer. That can move the flow past the critical crossflow Reynolds number, where falls to “between about 0.15 and 0.30” (p. 15).
What it leaves out. HPR Sim omits that fall past the critical crossflow Reynolds number (about
, [J77] Fig. 2), which Jorgensen computes only for illustration. It omits roughness
and fins’ effect on the body’s crossflow. It also omits Jorgensen’s own attached-flow term,
, in place of HPR Sim’s .
Galejs’s constant stays available for comparison
(BodyLift::Galejs, with
AeroModel::with_body_model):
[G] cites Hoerner’s 1.1 to 1.5 and fitted 1.0 to his own data.
Bodies faster than sound
Flown faster than sound for a pointed nose and its cylinder (The body faster than sound in a flight, below). This is M1.8e1’s method, the second-order shock-expansion method as a tested library model. Against its report’s wind-tunnel data, 117 of 120 slopes are within 0.2 per radian. On the Arcas Robin’s body it reads from 16% high at Mach 1.5 to 26% low past Mach 3 at . That comparison leaves out the body lift a flight adds. Compared the way the tunnel measures, the body reads high (Checking the shock-expansion method, under Verification). It needs a pointed tip; a blunt or vertical one (power-series, elliptical and Haack noses) takes a Newtonian cap ahead of it (Blunt tips, below).
Slender-body theory, above, gives a pointed nose a slope of 2 and a cylinder none, at any speed. Faster than sound that is too little. The air speeds up around the shoulder where the nose meets the cylinder, and its pressure then recovers along the cylinder toward the free stream’s. At an angle of attack it recovers unevenly around the body, so the cylinder carries lift too, more the longer it is. NASA measured the Arcas Robin’s body alone at 3.9 per radian at Mach 3.96, where slender-body theory gives 2 for its nose.
HPR Sim computes that lift by Syvertson and Dennis’s second-order shock-expansion method ([SD56]). It does so for a body with a pointed tip and supersonic flow everywhere on it, as the slope at small angles of attack (). The older generalized shock-expansion method holds the pressure constant along each straight piece of the profile. The second-order method also carries the pressure’s rate of change across each corner, so the pressure can recover along a piece:
- The tangent body. The profile becomes straight elements, each tangent to it. The first is at the tip. The rest are at equal steps along a curved nose (ten per curved piece, the report’s own choice), one per cone or cylinder. Where two elements meet is a corner.
- The tip is a cone, so its flow is exactly a cone’s. The Taylor-Maccoll equation, the exact equation of supersonic flow over a cone, is integrated from the shock to the surface ([R1135] eq. 177). The shock must be attached, touching the tip, which holds up to a half-angle that grows with the Mach number. For cones under 0.03°, where that equation can’t be integrated, HPR Sim takes slender-cone linear theory, blended in up to 0.06°.
- Around each corner the flow turns by a Prandtl-Meyer expansion.
- Along each element the pressure relaxes from its value behind the corner toward the pressure on the element’s tangent cone. It is the cone, pointed into the oncoming flow, whose surface has the body’s local slope there. The lift per unit length relaxes the same way, toward that cone’s.
- The slope and CP follow by adding the lift over the body.
The pressure along an element ([SD56] eqs. 8, 9):
The gradient behind a corner ([SD56] eqs. 4, 6):
The gradient at an element’s end ([SD56] eq. 10):
The lift per unit length ([SD56] eqs. 5, 19):
The slope and CP ([SD56] eqs. 14, 21):
is an element’s angle to the axis, and the pressure over the free stream’s (the
undisturbed air ahead of the rocket). is the Mach number at the surface, and the radius at
the corner. is how much a thin tube of flowing air widens as its Mach number rises. It
is the tube’s area over its area at Mach 1 ([SD56] eq. 7). is the Mach angle .
is the slope of the tangent cone, digitized by hand
from the report’s Fig. 2 into a table. It is continued past that chart’s 24° to 30° by Sims’s own
tables of the same theory (ADR-042,
cone_normal_force_slope).
For a worked example with numbers, see
Checking the shock-expansion method.
- A cylinder’s tangent cone is the free stream, so its lift decays to nothing along it.
- A boattail has no tangent cone. The report’s footnote 8 takes the free stream’s pressure and a slope of 2, “reasonable results for bodies having moderate amounts of boattail”. The method does the same, but a measurement says it takes too little lift off. Since M1.8e6 a flight gives a boattail a measured share instead (The body faster than sound in a flight).
- Where the method stops. The relaxation holds only where the gradient behind a corner points toward the tangent cone’s pressure (, [SD56] p. 13). The report states that as a condition and doesn’t say how it went on where it fails, near a sharp tip at high Mach number. HPR Sim’s own reading is to reduce such an element to the older generalized method, which the report says the equations become at . There the pressure stays as it is along the element and no gradient passes to the next corner. On the report’s fineness-3 ogive at Mach 5.05 that departs from its values (issue #81: the method’s limit near a sharp tip). HPR Sim reads an element that way wherever it has a tangent cone of its own, behind the nose or on it (A near-flat flare). A cylinder’s tangent cone is the free stream and a boattail’s is footnote 8’s. So neither is a solution of that element’s own flow. One of those that would need reducing is refused instead. The whole body then keeps slender-body theory (issue #123: a cylinder’s or a boattail’s reduced element).
- Mach number over nose fineness. The report states the method for 0.4 to 2, and HPR Sim doesn’t enforce it. A nose of fineness is below the range up to Mach : a 5:1 nose up to Mach 2.0, a 6:1 nose up to Mach 2.4. A flight starts using the method between Mach 1.2 and 1.5, so such a nose spends most of the way to Mach 2.5 below the range. One measured row sits there, the short Arcas Robin at Mach 1.5, at 0.36. Its body alone reads 4% above the tunnel at , inside the measurement’s ±0.32 per radian. On the slope fitted at the plotted angles it reads 37.7% above (The body alone, against the 15% target). On that row the whole rocket’s center of pressure, fins on, reads 0.25 calibers aft of the tunnel’s, the side that makes the margin look larger (Normal force through Mach 1). The report’s own Mach 6.28 rows sit above the range, at 2.09.
- Its range. The report states the method for Mach number over nose fineness from 0.4 to 2, within ±0.2 per radian and ±0.2 calibers of its measurements. Fig. 2 covers Mach 3 to 10; below Mach 3 HPR Sim holds the Mach 3 curve, an assumption. The tip’s shock must be attached, and the profile continuous. Tangent cones run to 30°: to 24° from Fig. 2, and from there to 30° from NASA SP-3007’s tables of the same theory. They agree with the chart to 0.0021 per radian where both cover the same angle (ADR-042). A cone steeper than 30° is refused, and the whole body then keeps slender-body theory.
- What it leaves out: the crossflow lift that grows with (Body lift, above), and anything viscous. It is the slope at small angles only.
The body faster than sound in a flight
The fastest validation flight is Prometheus: see its max_mach rows in the validation report.
What is extrapolated. A transition that isn’t conical takes the same correlation from its length and radii. Past 16° the flow separates, and HPR Sim holds the correlation at its 16° reading (the 16° rule, issue #90: how steep a boattail the correlation should cover). A tube behind the boattail takes the method’s decay of its expansion, which no measurement here checks. A blunt or vertical nose tip takes a Newtonian cap ahead of the method (Blunt tips), an extrapolation from spherical caps. A conical flare flush with the part ahead of it flies the method while its corner’s shock is attached. One measured flare has been put beside it (What a marched flare is worth). Where the shock is not attached, the flare is read drawn out, and that half still has none. Any other widening shape, or any step, keeps slender-body theory, which on the Arcas Robin’s body reads 15% to 50% below the tunnel faster than sound.
Which model your rocket gets. Every body takes body lift at every speed. Past Mach 1.2, a rocket takes the method below for its nose, tubes and boattails when its first body is a nose. That nose is pointed, or has a blunt or vertical tip that the cap covers. The method applies only when nothing but tubes of its radius and boattails (and tubes behind those) follows the nose. A lip wholly inside a boattail’s wake rides along, carrying nothing (A lip in a boattail’s wake). A lip only partly in the wake gets the method in the wake’s own proportion, and slender-body theory for the rest. A conical flare flush with the part ahead of it joins the run as well, and ends it (A flare through the method). A widening part behind a boattail is a lip, not a flare, and keeps the lip’s rule. Anything else keeps slender-body theory for its whole body at every speed. Examples are a step, a widening shape other than a cone, and a nose steeper than the cap’s handover all the way to its base. A motor retainer behind a step down is another, since the step ends the run.
Where that choice still jumps. It is one choice for the whole body. So a rocket either side of any threshold it turns on gets two different models. The difference is the whole body’s, not the part that changed. At Mach 3 and 4°, each remaining threshold is worth
this much. The first four rows use two test bodies. The flare behind a boattail is on a finless body, so its share is of a body’s normal force alone. The other three are on the tests’ straight rocket, which keeps its four fins, so the two kinds of share don’t compare. The last column says who owns it. Open is an issue with no milestone behind it. Queued is a milestone on the roadmap. No longer a switch is a threshold since removed, kept here because its size is the measured cost of the model it replaced. The tests pin the rows: issue_87s_switches_are_this_big the first four, a_lip_in_a_boattails_wake_carries_nothing the lip’s two, and a_near_flat_flare_marches_every_row_and_the_fallback_is_still_measured the last:
| drawing this | normal force | center of pressure | who owns it |
|---|---|---|---|
| a step in radius, past a billionth of the local radius | −8.65% | 1.03 calibers | queued: M1.14d: supersonic accuracy, these switches first, and M1.14h above Mach 2.5; issue #87: a step has no model of its own |
| a flare behind a boattail and too long for its wake, however small | −27.5% | 0.29 calibers | queued, as the first row; issue #120: a lip longer than its wake |
| a pointed tip steeper than the cone tables’ 30° | −7.7% | 0.81 calibers | queued, as the first row; issue #121: a tip past the cone tables |
| a vertical tip steeper than the cap’s handover to its base | −7.0% | 0.64 calibers | queued, as the first row |
| a lip leaving its boattail’s wake by rising or by sitting back | −29 to −34% | 0.93 to 1.97 calibers | no longer a switch: the rise is weighed, ADR-041 |
| a lip longer than its boattail’s drop in diameter, however little it rises | −33.0% | 1.77 calibers, forward | queued: M1.14d: supersonic accuracy, after the four switches above, since it reads less stable; issue #120: a lip longer than its wake |
| a near-flat flare, 0.03816° to 0.05882° at the table’s top rows, which the march used to refuse | −8.3% | 1.16 calibers | no longer a switch: the element is read by the generalized method, ADR-050 |
In the first four rows the center of pressure moves aft when the method is lost. So a rocket that trips one reads more stable than one that doesn’t. The near-flat-flare row goes the same way: its test pins the center of pressure 1.16 calibers aft on slender-body theory. The two lip rows go the other way. Their tails take lift off in a boattail’s wake. There slender-body theory puts the center of pressure forward of the method’s, so losing the method there reads less stable. Which way it goes depends on the body; what is reliable is the size.
The lip row about length is a switch the wake’s grading does not cover. The length limit is a threshold, not a ramp. It is the one this page’s measurements use to take a rocket off the method without changing a radius or an angle.
The first lip row is no longer a switch: it is spread over the band the wake grades, as above. The second still is one. Nor is the last. Since M1.8e19 the march reads that flare’s element rather than refusing it. What is left where it used to switch is the loading’s step at the corner’s crossing: +0.129% and 0.0051 calibers on this rocket. The step is larger on other bodies and on longer flares (A near-flat flare). The two tips moved rather than went. A pointed tip’s edge is the cone tables’ 30° since M1.8e11. A vertical tip’s edge is the handover’s cap, which stands at 24° for the reason in What the cap is worth.
The flare went (M1.8e17, ADR-047): a conical flare in the free stream now flies the method. Nothing jumps across the boundary where its shock detaches; see A flare through the method below. The second row is what is left of it, a flare behind a boattail. That is a lip in the boattail’s wake rather than a flare in the free stream, and it keeps its own rule. The last row is what that milestone turned up on the way: a band of near-flat flares, a third of a millimeter tall, whose one element the march reduces to the generalized method. M1.8e19 closed it.
The step stayed, and M1.8e15 says why. The march needs a profile without a jump in it. So a step needs a model of its own, not a decision about an existing one. The obvious fix turned out to cost more than it saved. What that milestone did measure is in A step in radius below. Its threshold is a billionth of the radius, a few hundredths of a nanometer on a 54 mm (2.1 in) body. Any step a person would draw is past it. A rocket whose shape sits near one of these thresholds is worth checking on both sides.
What a flight takes. The method covers the nose, when it is the first body (a blunt or vertical tip behind its Newtonian cap). Body tubes straight behind it at the same radius are covered. So are boattails (transitions that narrow toward the tail) and tubes behind those, with no step between them (M1.8e4). A conical flare is covered too, and ends the run (M1.8e17). It flies only if nothing else behind them changes the radius: no step, and no widening shape but that flare. Mixing the method’s nose and cylinder with slender-body theory’s boattail would put the center of pressure further off than slender-body theory alone. So the boattail takes a supersonic share too, measured (below). Each covered part gets its own share, so the flight’s pitch damping still comes from each part’s own local flow. That flow is taken at one station per part; the part’s force and its moment about the nose tip are the method’s either way. A nose or cylinder takes that station at its share’s own center of pressure. A boattail’s share is usually negative, and so is a tube’s behind it. The method carries the boattail’s expansion down the tube, where it fades out over several calibers. So a long tube can lose as much as the short boattail. On the tests’ finned rocket (hand-measured, not pinned), a 5.7° boattail 0.05 m (0.16 ft) long takes 0.284 per radian off at Mach 2. Footnote 8 took 0.117 there. The 0.3 m (0.98 ft) tube behind the boattail takes 0.210 per radian off at Mach 2. Such a share could cross zero as the Mach number changes, sending its center of pressure off to infinity. So these parts take their local flow where slender-body theory does, on the part. A boattail takes it at its slender-body center of pressure, a tube at its body-lift station. Only the damping feels this. On the test rocket at Mach 2 the tube’s share acts at 1.040 m (3.41 ft). Its flow is taken at about 1.15 m (3.8 ft). With the center of mass near 0.7 m (2.3 ft), that part’s (negative) damping reads about 30% large. Body lift, the term, is unchanged.
The boattail, measured. Washington and Pettis ([WP68]) mounted the aft section of a wind-tunnel model on its own balance. They measured it with a conical boattail and as a plain cylinder of the same length, Mach 1.75 to 4.5. They also measured a whole model with and without a boattail from Mach 0.8 to 1.5. The boattail’s increment in slope, per degree on the cylinder’s area, collapses onto one curve:
with the diameter ahead of the boattail, its base diameter and its length. The slope is read by hand from [WP68] Fig. 5, p. 8, into
WP_SLOPE_PER_DEG to about ±0.02 per radian. The increment acts about halfway along the boattail, from 43% of its length at
Mach 2 to 64% at 4.5 ([WP68] Fig. 6, p. 9). A flight gives a boattail the share the method gives
a cylinder of the boattail’s length and fore diameter in its place. The increment is added at its own center of pressure (test the_boattail_takes_washington_and_pettis_increment). Slender-body theory
gives the same boattail at every speed, which is Fig. 5’s own subsonic line. Faster than sound the measured increment is less than half of that line at the Arcas Robin’s speeds (0.24 to 0.47), footnote 8’s less again. The curve is not always below that line. Across Fig. 5 it runs from 0.23 to 1.58 times the line, passing it at an argument of 0.635, near Mach 1.
A steep boattail reads the correlation no steeper than 16°. Washington and Pettis measured
boattails of 4° to 9.5°, where the flow follows the surface. Past about 16° it doesn’t: the drag
buildup already treats a boattail as separating from there
(Boattails faster than sound, Cubbage’s steepest attached
boattail). Nothing measures what a separated boattail’s normal force then does. So HPR Sim reads the correlation at the steepest angle where the flow is still attached. A boattail past 16° takes the increment of one of the same radii drawn out to 16°. Its center of pressure stays on the real boattail (ADR-040,
issue #90: how steep a boattail the correlation should cover).
The Arcas Robin’s 15° boattail is untouched; Calisto’s 18.4° reads its correlation as a 16° one.
The increment is continuous in the angle, so a rocket doesn’t jump as its boattail is drawn
steeper (test a_separating_boattail_reads_the_correlation_at_its_steepest_measured_angle).
Why hold it rather than let it fade. The two honest limits for a separated boattail are the correlation held at 16° and nothing at all. Nothing at all means the body behaves as though the boattail were a cylinder, since a separated surface no longer turns the flow. HPR Sim takes the first. The increment is negative, so it takes lift off the tail. Holding it keeps the center of pressure forward. Letting it fade to zero would move the center of pressure aft and make a steep boattail look more stable than anything measured. The tests’ rocket has an ogive nose, a tube and a 30° boattail. Its body’s center of pressure sits this much further aft if the increment fades away than if it is held:
| Mach | between the two rules, calibers |
|---|---|
| 1.5 | 1.35 |
| 2 | 0.91 |
| 3 | 0.75 |
| 4.63 | 0.67 |
That is the size of the doubt, and it is largest where a hobby rocket spends its supersonic flight. A boattail steeper than 16° is worth two thirds of a caliber at Mach 4.63. At Mach 1.5 it is worth a third of a caliber more than one. HPR Sim takes the forward end of that range (test
a_separating_boattail_reads_the_correlation_at_its_steepest_measured_angle pins both ends).
One more bound is on the holding, not the measurement. Reading a longer boattail
walks the correlation’s argument toward zero. There Fig. 5’s curve comes from the report’s lowest supersonic runs and rises past Munk’s slender-body line. The report plots that line there for comparison at subsonic speeds (p. 3). HPR Sim does not invent a length and then
read that branch, so the extra the holding takes off stops at potential flow’s
(holding_the_correlation_stops_at_potential_flow).
A boattail’s read at its own length is never clipped, wherever it sits. That is the correlation as published. A genuinely long boattail reads the same near-Mach-1 branch with no bound at all. A 4° boattail to 0.6 of the radius reads 1.29 times Munk’s line at Mach 1.5, and HPR Sim flies it. Only the length the 16° hold invents is capped. The bound bites when the aft radius is under about of the fore radius. That is two fifths at Mach 1.2, a quarter at 1.3, a twentieth at 1.45, and nothing much above Mach 1.49. It bites only where the method’s table has started, which on such shapes it barely has.
How much that is worth is measured. A sweep takes boattails of 16° to 53.6° narrowing to between a thousandth and three tenths of the fore radius. It reads their shares back out of the table (what_the_potential_flow_bound_reaches).
- At the table’s rows a boattail never takes off more lift than potential flow, except in the sliver described below. In that sliver a boattail’s own read already passes potential flow, and the bound never clips that.
- The bound moves a printed coefficient by about 0.060 per radian at most, at 53.5° narrowing to a thousandth of the radius. That is the printed number, after the join’s weight. The holdback on the boattail’s own cross-section is up to about six times larger near the join, where the join is barely open. 53.5° is the steepest boattail the sweep found the method willing to table at all. The method refuses 53.6°, and refuses shallower angles than that where the boattail narrows less.
No committed design comes near. The steepest is Calisto’s 18.4°. Its aft radius is 0.685 of its fore radius, where the bound would need under 0.40 even at Mach 1.2.
Two caveats, both small but real. The bound applies where the shares are computed, at the table’s rows. Between rows the table interpolates, so a printed value beside a row of the next kind can sit past potential flow. It can do so by up to about 0.003 per radian on the shapes swept. And there is a sliver just above the hold’s own angle (the sweep finds it at 16°, 16.5°, 17° and 17.25°). In it, a boattail is deep enough that its own read already passes potential flow. The bound never clips a boattail’s own length, so the hold does nothing there, and the rocket flies an extrapolation nothing measured checks. That window runs a few hundredths of a Mach from where the table starts, so the join is barely open across it. The window closes as the angle or speed rises, not at a fixed angle.
The two models draw opposite consequences from the same angle. Separation lowers a boattail’s pressure drag toward the base value. Here it holds the lift the boattail takes off instead of letting it shrink. The argument for that is the stability one above, not a flow one. The angle is also read on each narrowing part’s own chord angle. The drag merges adjacent narrowing parts into one cone before grading. So a boattail drawn in several parts can be graded differently by the two.
A worked example. The Arcas Robin’s boattail narrows from 2.25 in to 1.308 in over 1.757 in, so and . At Mach 2.3, and Fig. 5’s argument is 2.071/0.781 = 2.652. There the curve reads −0.01263 per degree, −0.7237 per radian. Times 0.662, that is −0.479 per radian on the body’s cross-section. Slender-body theory gives −1.324, footnote 8 −0.103. Across the tunnel’s Mach numbers:
| Mach | Washington and Pettis, per rad | footnote 8, per rad | slender-body theory, per rad |
|---|---|---|---|
| 1.5 | −0.622 | −0.177 | −1.324 |
| 1.8 | −0.554 | −0.144 | −1.324 |
| 2.3 | −0.479 | −0.103 | −1.324 |
| 2.96 | −0.409 | −0.068 | −1.324 |
| 3.96 | −0.340 | −0.038 | −1.324 |
| 4.63 | −0.314 | −0.026 | −1.324 |
Their models were conical boattails of 4° to 9.5°, 0.82 to 1.18 diameters long, narrowing to 0.72
to 0.86 of the diameter. The Arcas Robin’s is steeper (15°), shorter (0.78) and narrower (0.58),
so its row is an extrapolation. Their points scatter about the curve by up to about 15%. Past the
curve’s end (an argument of 6.1: a short boattail at a high Mach number) HPR Sim holds its last
value. BodyModel keeps footnote 8 for comparison.
A table. One run of the method takes a few milliseconds, too slow for every step of a flight. So the first time a flow faster than Mach 1.2 needs it, HPR Sim runs the method every 0.05 in Mach from Mach 5 down. It stops at the lowest Mach at which the method holds, and keeps the results. Between those Mach numbers it interpolates in a straight line. That took about 0.3 s once per rocket in a debug build on the development Mac. The time was measured by hand, for a body the method takes from Mach 1.2. A body whose join starts higher adds about 48 runs for the bisection below. A rocket that never passes Mach 1.2 never pays it.
The join. Write SB for slender-body theory, SE for the shock-expansion method, and for where the join starts. That is Mach 1.2, or the lowest Mach at which the method holds if that is higher. HPR Sim narrows that Mach down between two rows of the table by halving the gap (bisection). It stops when no smaller step exists in the computer’s numbers. It then runs the method at that Mach and adds the result as an extra row. The start must be that exact. There the method’s shares climb from zero like the square root of the distance in Mach. So a start off by puts -sized shares in that row. So the start moves smoothly with the nose’s shape instead of in 0.05 steps. A cone with a 20° half-angle (the angle between its side and its axis) joins from Mach 1.341910. Each 0.1° steeper, up to 20.5°, moves the start about 0.0027 later, to 1.355500. From to , each covered part’s slope, moment and station move linearly from SB’s to SE’s, with clamped to 0 to 1:
Every piece is a straight line in Mach, so nothing jumps. The test
the_supersonic_join_has_no_jump looks at ±1e-9 in Mach on each side of the join’s ends, of table rows, between rows and at Mach 4.999. a_blunter_cone_joins_where_the_method_starts_to_hold does the same for the 20° cone, whose join starts higher.
the_joins_start_moves_with_the_nose_not_in_steps pins that cone’s start and the 20.5° cone’s to 1e-6. It checks the start is off the grid, and that the cylinder’s share at the start is under 1e-5 per radian (about 1e-7). It also checks the start moves by less than 1e-7 when the cone steepens by a
millionth of a degree (2.7e-8). a_boattailed_body_flies_the_method_without_a_jump does the same
±1e-9 probe for the finned rocket with its boattail and tail tube. Mach 1.2 to 1.5 is a judgment. Below Mach 1.2 the flow over the nose is transonic, which the method doesn’t cover. Mach 1.5 is the lowest Mach of NASA’s supersonic tests of the Arcas Robin, in TN D-4014
(ADR-034,
the decision behind it). Small changes in shape can still switch a body between the two models. An example is a nose so steep that the method never holds at any Mach up to 5. The rocket then keeps slender-body theory throughout
(issue #87).
A worked example: the Arcas Robin’s body. NASA measured the Arcas Robin’s body without fins in a wind tunnel (TN D-4014). The secant-ogive nose (a tangent ogive’s cousin, its arc larger) is fitted to the report’s coordinates, and the boattail is left off. Flown through a flight’s own code, the nose and cylinder give the method’s own values. They are equal on the table’s rows (Mach 1.5, 1.8, 2.3), and within 1e-4 between them.
With the boattail on (the lip behind it off, a flare the method doesn’t take), the boattail takes its measured share. That is 0.31 to 0.62 per radian off, most at Mach 1.5 (footnote 8 took 0.03 to 0.18). At the short model reads 12.0% to 26.2% below the measured line and the long model 29.7% to 33.3% below it. That line is fitted over the plotted angles, so it carries crossflow lift. These columns leave body lift out; fitted the same way with the body lift a flight adds, the same body reads 3.4% to 41.0% high (Checking the shock-expansion method).
HPR Sim’s committed Arcas Robin design flies the method to its base since Blunt tips and A lip in a boattail’s wake. The last two columns are the method’s own values for its power-series nose, cylinder and boattail, with the lip carrying nothing. Slopes are on the body’s cross-section, at . The measured slope is fitted over the plotted angles with the boattail and lip on. So it also carries some crossflow lift and their share, which is why every column reads below it here.
| model | Mach | measured, per rad | method, per rad | flight, nose and cylinder, per rad | flight vs measured | flight, with boattail, per rad | with boattail vs measured | design as committed, per rad | committed vs measured |
|---|---|---|---|---|---|---|---|---|---|
| short | 1.5 | 2.192 | 2.552 | 2.552 | +16.4% | 1.930 | −12.0% | 1.852 | −15.5% |
| short | 1.8 | 2.613 | 2.724 | 2.724 | +4.3% | 2.171 | −16.9% | 2.143 | −18.0% |
| short | 2.3 | 3.078 | 2.931 | 2.931 | −4.8% | 2.452 | −20.3% | 2.394 | −22.2% |
| short | 2.96 | 3.284 | 3.124 | 3.124 | −4.9% | 2.716 | −17.3% | 2.612 | −20.5% |
| short | 3.96 | 3.884 | 3.300 | 3.300 | −15.0% | 2.963 | −23.7% | 2.735 | −29.6% |
| short | 4.63 | 4.149 | 3.371 | 3.371 | −18.7% | 3.063 | −26.2% | 2.718 | −34.5% |
| long | 1.8 | 3.159 | 2.724 | 2.724 | −13.7% | 2.171 | −31.3% | 2.143 | −32.1% |
| long | 2.3 | 3.525 | 2.932 | 2.932 | −16.8% | 2.453 | −30.4% | 2.394 | −32.1% |
| long | 2.96 | 3.868 | 3.127 | 3.127 | −19.2% | 2.718 | −29.7% | 2.614 | −32.4% |
| long | 3.96 | 4.455 | 3.313 | 3.313 | −25.6% | 2.974 | −33.3% | 2.740 | −38.5% |
| long | 4.63 | 4.615 | 3.395 | 3.395 | −26.4% | 3.082 | −33.2% | 2.724 | −41.0% |
The rows are in
validation/fixtures/aero/shock-expansion.json
(arcas_robin: nose_and_cylinder, in_flight, in_flight_with_boattail and as_designed), written by cargo xtask aero. No test re-reads the flight columns, so they are regenerated by hand.
What it leaves out. Steps, and widening shapes that are not cones, as above. A conical flare has its own section (A flare through the method). A blunt or vertical tip takes the cap of Blunt tips, below. The method itself has no crossflow lift; a flight adds body lift on top.
A lip in a boattail’s wake
What this covers: a short flare at the very base, behind a boattail, like the reflex lip of NASA’s Arcas Robin models.
The rule. A lip that sits wholly in a boattail’s wake carries no potential-flow slope from the Mach number where the method takes over. Below the join it keeps slender-body theory’s , and the join blends the two, so nothing jumps. HPR Sim takes the shelter’s share from its drag model (ADR-030, which takes the same lip’s drag away). The lip is wholly in the wake up to a rise of a quarter of the boattail’s drop in diameter. From a rise of half that drop it is not in the wake at all. The wake fades over any tube between them. On top of that fraction the normal force asks one thing the drag model doesn’t. The lip must be no longer than the boattail’s drop in diameter, the wake’s own scale. Otherwise it grows out of the wake however little it rises. ADR-039, the lip’s decision record, sets out the readings behind the share itself.
A lip part way out of the wake. Where the wake covers the lip only partly, the drag model has always graded it so. Since M1.8e10 the normal force reads the same number as a weight. The method’s share counts for the wake’s share of the lip, slender-body theory for the rest, exactly as they blend across the Mach join (ADR-041). It is the whole wake fraction, not the rise alone. The shelter fades with the lip’s rise, with any tube between it and the boattail, and with anything else in the way.
The jump is gone. A lip drawn a hair taller no longer switches the whole body between the two models. On the tests’ rocket at Mach 3 that switch was worth a third of the normal force and 1.77 calibers of center of pressure. The sensitivity is not gone; it is spread over the band. On that rocket, at Mach 3 and 4°:
| drawn from | to | normal force | center of pressure |
|---|---|---|---|
| a lip rising a quarter of the boattail’s drop | rising a half (2.5 mm (0.098 in) of radius) | −29.1% | 0.93 calibers |
| a lip flush behind the boattail | one a boattail’s drop in diameter behind it (10 mm (0.39 in)) | −33.8% | 1.97 calibers |
That table is a design sensitivity: how the printed answer moves as you draw the lip differently. It is not how far apart the two models are, which is what a lip in the band is uncertain by. At one fixed shape (a lip rising a quarter of the drop) the two models differ by 33.0% of the normal force and 1.77 calibers. Nothing measured says which is right for a part-sheltered lip. That number has not changed; what changed is that a rocket can no longer cross it in a ten-thousandth of its geometry.
Why nothing. Three readings point the same way.
- The tunnel itself. TN D-4014 ([D4014] p. 6) traces an odd chamber axial force at Mach 1.50 and 1.80, fins off, to the reflex lip. The report says the effect is “masked” once separation runs over the boattail at higher Mach numbers or the fins thicken the boundary layer. It says the longer model shows none of it, “probably because of the thicker boundary layer at the model base”. So the lip does something at those two speeds, and those are the very rows whose moment implies a negative share below. What it does there isn’t a normal force this model can carry.
- Seiff’s own limits. His embedded Newtonian flare method holds for “thin shock layers when the flow is not extensively separated” ([S62] p. 13). He notes that “a 90° ramp will invariably separate the flow” (p. 4). The Arcas lip’s face stands about 57° to the axis, behind a 15° expansion.
- The size, at most. Taken anyway as an upper bound (eq. 9, p. 12), Seiff’s method gives 0.044 per radian at Mach 1.5, falling to 0.014 at 4.63. Slender-body theory gives 0.178 at every speed. For a conical flare at one dynamic pressure, eq. 9 is . Here is the flow that has expanded through the boattail’s turn. Seiff measures from the local stream. Here it is taken to the axis, 56.8°, the looser of the two.
What the moment says, and what it can’t. For each fins-off row, there is a share at the lip’s station that would put HPR Sim’s center of pressure on the measured one. It runs from −0.256 ± 0.068 per radian (short model, Mach 1.5) to +0.229 ± 0.084 (long, Mach 3.96). It changes sign with Mach number and with the model’s length. Fitting one share:
| rows | share, per radian | per degree of freedom | from zero | from slender-body theory’s 0.178 |
|---|---|---|---|---|
| all eleven | +0.021 ± 0.019 | 4.5 | 1.1 σ | 8.4 σ |
| the short model’s six | −0.016 ± 0.022 | 6.4 | 0.7 σ | 8.7 σ |
| the long model’s five | +0.108 ± 0.034 | 0.9 | 3.2 σ | 2.1 σ |
A per degree of freedom of 1 means rows agreeing within their own error bars. The short model’s 6.4 means its rows disagree among themselves. The long model’s 0.9 means its five agree, on a share of +0.108. That is five times Seiff’s bound at that speed and three standard errors above zero, yet still two below slender-body theory’s.
So the moment does not settle the lip, and the model doesn’t rest on it. Each row’s share blames the lip for every miss in the center of pressure. HPR Sim’s body alone reads 15% to 19% high on the long model at Mach 1.8 and 2.3. That shifts its center of pressure by far more than any lip. The short model’s own fit comes out negative, which no flare can produce. What the moment does say is that slender-body theory’s 0.178 at the base is too much. It is eight standard errors out on the short model, two on the long.
How it was checked. The committed designs, fins off, through a flight’s path, fitted at the tunnel’s plotted angles as Checking the shock-expansion method fits them. Slopes are on the body’s cross-section; centers of pressure are aft of the nose tip. The last column is where HPR Sim’s whole-body center of pressure would sit if the lip carried slender-body theory’s share instead of nothing. HPR Sim’s slopes here are fitted over the tunnel’s angles, so they carry body lift. The same bodies’ slopes at , in Checking the shock-expansion method’s table, are lower.
| model | Mach | measured, per rad | HPR Sim, as committed, per rad | vs measured | measured CP, calibers | HPR Sim’s CP, calibers | HPR Sim’s CP with the lip at slender-body theory’s share, calibers |
|---|---|---|---|---|---|---|---|
| short | 1.5 | 2.192 | 3.017 | +37.7% | 1.00 | 2.46 | 3.33 |
| short | 1.8 | 2.613 | 3.290 | +25.9% | 2.36 | 3.06 | 3.84 |
| short | 2.3 | 3.078 | 3.598 | +16.9% | 3.56 | 3.69 | 4.37 |
| short | 2.96 | 3.284 | 3.838 | +16.9% | 3.21 | 3.75 | 4.43 |
| short | 3.96 | 3.884 | 3.946 | +1.6% | 4.88 | 4.57 | 5.16 |
| short | 4.63 | 4.149 | 3.950 | −4.8% | 5.05 | 4.72 | 5.30 |
| long | 1.8 | 3.159 | 3.770 | +19.4% | 4.61 | 4.31 | 5.19 |
| long | 2.3 | 3.525 | 4.071 | +15.5% | 5.04 | 4.89 | 5.68 |
| long | 2.96 | 3.868 | 4.400 | +13.7% | 5.33 | 4.64 | 5.47 |
| long | 3.96 | 4.455 | 4.428 | −0.6% | 6.19 | 5.20 | 5.98 |
| long | 4.63 | 4.615 | 4.425 | −4.1% | 6.40 | 5.96 | 6.65 |
The rows are in
validation/fixtures/aero/arcas-robin-lip.json,
written by cargo xtask aero, and a test holds this table to it cell by cell. With the lip left off entirely the same bodies read within 0.05 percentage points of these rows at ten of the eleven. The other row, Mach 1.5 on the short model, is within 0.5 percentage points. So the lip changes little but which parts of the body the
method may cover.
What it means for a rocket. Most rockets have no lip, and nothing changes for them. For one that does, the rule decides whether the whole body flies the method or slender-body theory. That is worth more than the lip itself. On the Arcas Robin’s short model at Mach 2.96 the body’s slope goes from 2.08 per radian to 3.84. The whole rocket’s slope goes from −16.3% against the tunnel to +3.7% (Normal force through Mach 1). The extra lift sits on the body, ahead of the fins, so the center of pressure moves forward by 0.22 calibers there. That is a little less stability margin, and a good deal more restoring force.
What it leaves out. The lip still has drag, and its own wake rule there (ADR-030). Nothing here measures a lip’s lift directly: the tunnel gives forces for the whole body, and the moment bounds the share rather than measuring it. The shelter used to be a switch in shape, of the family issue #87 tracks. It was a large one, because it decides whether the whole body flies the method. Since M1.8e10 the rise no longer switches it. On the test rocket at Mach 3 and 4°, lips rising 0.2499 and 0.2501 of the boattail’s drop now agree to a ten-thousandth. What is left is how far apart the models are at one shape. That is 33.0% of the normal force, and the center of pressure 1.77 calibers forward on slender-body theory. The difference is spread over the band the wake grades (above). A narrowing part behind the run is a boattail the method hasn’t covered, not a lip, and keeps slender-body theory’s share. A widening part behind a boattail that is too long for the wake stays a lip as well. It still takes the whole body off the method. The flow reaching its corner is the wake’s, which the march does not compute, so A flare through the method does not apply to it.
Where a flare’s march stops
In short: a flare is a transition that widens toward the tail. The method will march one, but only up to a limit, and that limit is not where the flare’s shock detaches. The limit is where the corner’s turn would take the flow to Mach 1. That is a property of HPR Sim’s method rather than of the air, and it depends on the whole body ahead of the flare. On the body measured below it falls short of a wedge’s detachment angle at Mach 1.5 and runs past it at Mach 2. Taking the tube away moves it past the wedge at both. From Mach 2.13 to Mach 5, the highest checked, the limit is neither: it is the 30° where the cone tables end. The flare’s own detachment angle is not known here: the wedge’s is a conservative stand-in for it. This section is the measurement. It is why the attachment test a flight uses had to be chosen rather than read off the march’s refusal (ADR-045). The next section, A flare through the method, covers what a flight does with a flare. The one after it, What a marched flare is worth, covers how close that comes to a measured flare. Neither this section’s edge nor the drawn-out reading past it is compared with a measurement.
Second-order shock-expansion turns every corner isentropically (no entropy rise, so no shock) with the Prandtl-Meyer angle ([SD56]) eq. 3. A flare is a compression corner, so the turn spends . Whether a shock stands attached to that corner is a separate question. It decides whether the march is modeling the real flow at all.
The table below sweeps the flare’s angle on a fixed body (a pointed 2.75° cone, five calibers of
tube, and a conical flare). The sweep bisects the steepest flare the march accepts, until the two angles are adjacent double-precision numbers. The two angles are NASA TN D-4865 model 2’s; the layout is not. That model is blunt-nosed and has no tube at all. The edge depends on what is
ahead of the flare, because that is what sets the flow reaching it. Angles are quoted to seven
decimals so the differences add up. The detachment column is taken at the free-stream Mach
number. The flow reaching the flare is a little faster, which would move the wedge’s angle by about
0.02°. Both tests are in
shock_expansion.rs:
a_flare_marches_to_the_isentropic_turn_not_to_detachment and
past_mach_2_13_the_flare_stops_where_the_cone_tables_do.
| free stream | the march accepts a flare to | a wedge’s shock detaches at | so the march is |
|---|---|---|---|
| Mach 1.5 | 11.9312175° | 12.1126689° | 0.1814514° short of it |
| Mach 1.547787962528 | 13.346819° | 13.346819° | exactly on it |
| Mach 2 | 26.4714031° | 22.9735318° | 3.4978713° past it |
| Mach 2.5 | 30° (the tables) | 29.7974° | 0.20° past it |
| Mach 3 | 30° (the tables) | 34.0734° | 4.07° short of it |
How much of that is the tube. A great deal, and it is the point rather than a caveat. What the march has left to spend is of the flow arriving at the corner, and the body ahead sets that flow. Keeping the same cone and flare and changing only the tube’s length:
| tube | the march accepts a flare to, Mach 1.5 | at Mach 2 |
|---|---|---|
| none (the report’s own layout) | 14.194333° | 28.509856° |
| 1 caliber | 12.821811° | 27.500078° |
| 2.5 calibers | 12.144405° | 26.815015° |
| 5 calibers (the table above) | 11.9312175° | 26.4714031° |
So the first row of the first table is a property of that five-caliber body, not of the method. The march stops there short of a wedge’s detachment. On the report’s own tube-less layout the Mach 1.5 edge is 14.19°, two degrees past the wedge’s limit. What does not depend on the body is the conclusion. The march’s edge is set by the corner’s isentropic turn. It lands on both sides of a wedge’s detachment angle depending on nothing more than how long the tube is.
The detachment angles are a wedge’s largest deflection ([R1135], through
wedge_detachment_angle_rad, which
lives with the blunt-tip cap because that cap uses the same relation). A cone’s shock holds to
steeper angles than a wedge’s, and a conical flare on a cylinder sits between the two. Only the rows where the
march stops below the wedge’s angle prove anything about attachment. Where the march runs past
it, the flare’s own limit may still be higher. Which boundary a flight uses is
the next section’s subject. The table shows that the march’s edge
lands on both sides of any such boundary. From HPR Sim returning an answer, you cannot tell that
the flow it modeled is the flow that would be there.
The last two rows of the first table are a different limit altogether. Each element’s tangent cone is looked up in NASA SP-3007 Table 2, whose slopes stop at 30°. The milestone that took them there from 24° is M1.8e11 (ADR-042). So from Mach 2.129702032593 to Mach 5, the highest checked, every Mach number gives the same edge. The reference data runs out before the flow does, and the last column then says nothing about attachment.
An 18.5° flare, the report’s angle, on the 2.75°-cone body above (not the next section’s flared rocket, whose numbers are close but not these). The march accepts it from Mach 1.721760; a wedge’s shock reaches 18.5° only at Mach 1.767575. Between the two, HPR Sim returns a number for a flare whose shock is, on that reckoning, detached. That is a bow shock standing ahead of the juncture with a pocket of subsonic flow behind it. An isentropic corner turn does not describe it. TN D-4865’s lowest run, Mach 1.50, is below both, and there the march refuses outright, as the report itself says it should. On a shorter body those two Mach numbers move, as the table above shows.
What it leaves out. These digits pin what this program does, not what air does. Every one of them comes from bisecting HPR Sim’s own refusal, and the 30° rows come from where a lookup table ends. A band of very shallow flares is not marched by the second-order law at all. The pressure behind such a corner moves away from its tangent cone’s rather than toward it. So its one element is reduced to the older generalized method. Since M1.8e19 that method is read rather than refused (A near-flat flare). Where that band sits is a property of the body ahead of the corner, and it moves by orders of magnitude. It is 0.773° to 0.823° at Mach 3 on this 2.5-caliber body. At the same Mach number on the flared rocket of A near-flat flare it is 0.0066° to 0.0081°. The whole edge is inviscid, too. From Mach 2.96 up TN D-4865 records the boundary layer separating ahead of the flare and reattaching on it. That moves the pressure rise downstream of where a tangent body puts it, and nothing here models that. And below Mach 1.5 nothing here was measured, although a flight uses the method from Mach 1.2.
A flare through the method
In short: since M1.8e17 a rocket with a flare flies the shock-expansion method rather than dropping to slender-body theory the moment one is drawn. The method marches through the flare’s corner while the shock there stays attached. A steeper flare is read as one of the same radii drawn out to the steepest attached angle. That keeps the answer from jumping as a shape or a speed crosses that boundary.
What qualifies is narrow. The flare must be conical, flush with the part ahead of it and not in a boattail’s wake. There must be nothing behind it that carries lift of its own. A boattail then a flare is a lip in a wake and keeps that rule; any other widening shape still ends the run. The decision record is ADR-047.
Why a test had to be picked. The march will return a number for a flare whose shock has long since detached (the section above measures exactly that). So “the method answered” is not evidence the flow it modeled is the flow that would be there. Something independent has to say where the corner’s shock detaches.
The test. A flare’s shock springs from a circular corner, not from a point apex. Where the
shock forms, the flow is two-dimensional. The body’s radius is the scale over which the
axisymmetric relief acts, and at the corner itself none of it has happened yet. So HPR Sim uses
NACA Report 1135’s ([R1135]) largest deflection behind an attached plane oblique shock (eq. 168 into
eq. 138). TN D-4865 ([J68]) p. 5 uses the same relation to hand a blunt tip’s cap over to this method. HPR Sim’s blunt-tip cap and this flare test call one function, wedge_detachment_angle_rad.
Two details matter.
- It is read at the flow reaching the corner, not at the free stream. The body ahead has
already changed the air, and which way depends on what that body is. The ogive nose and tube of
the tests’ flared rocket leave it a little slower than the free stream. The 2.75° cone
and tube of the section above leave it a little faster. The
march knows by how much
(
aft_flow). On the tests’ flared rocket a Mach 2.0 free stream reaches the corner at Mach 1.9998. The limit is then 22.9698° and not the free stream’s 22.9735°. The march is downstream-only, so the flare cannot change the flow arriving at its own corner. That lets the limit be worked out before the flare is drawn. - The cone tables cap it at 30°, because past that the march has no tangent cone to relax toward (tangent cone, ADR-042). That bounds the flare’s surface angle, while the shock bounds the turn at its corner, so each caps its own quantity. On a flare behind a cylinder, where the surface ahead is at 0°, the two are the same number. There the cap binds from Mach 2.5192034260 of the flow reaching the corner up; a faster flow buys nothing above that.
The shock’s bound is on the turn and not on the flare’s angle. So a flare put straight onto an ogive nose (no tube between them) is read differently from the same flare behind a tube. The corner there turns the flow by the flare’s angle less the nose’s base slope, so the limit bites at a steeper flare. The tests’ flared rocket has an ogive nose 0.25 m (0.82 ft) long on a 27 mm (1.1 in) radius. A 0.7 m (2.3 ft) tube of that radius follows. On this rocket the surface ahead is at 0° and the turn and the angle are one number:
| free stream | the flow reaching the corner | the corner is read to |
|---|---|---|
| Mach 1.5 | Mach 1.4999688 | 12.1118502° |
| Mach 2.0 | Mach 1.9997809 | 22.9697612° |
| Mach 2.5 | Mach 2.4989548 | 29.7863106° |
| Mach 3.0 | Mach 2.9965267 | 30° (the tables) |
| Mach 4.95 | Mach 4.8922987 | 30° (the tables) |
A cone’s shock holds to steeper angles than a wedge’s. So if a conical flare on a cylinder does sit between the two, this errs one way only. It stops reading some flares whose shock is in fact still attached, and reads none whose shock is not. Nothing here measures where a flare’s own boundary is. So that “if” is an argument, not a result, and erring low is not the same as erring safely. A flare just past the limit is not left unread; it is read as a different flare, and how different nothing here measures either.
Past the limit, the flare is drawn out. A flare steeper than the limit is read as a flare of the same radii stretched to the limiting angle, longer and shallower. It turns the same air through a corner the shock can hold. Its center of pressure is put back on the real flare, at the same fraction along it. Because the radii are kept and the angle is not, every flare steeper than the limit reads the same force, held at the limit. There is no bound on how far that goes, and it under-reads badly at the extreme. At Mach 2 a 75° flare reads 1.638 per radian against slender-body theory’s 2.010. The flare is an annular face a detached bow shock would stand in front of. The truth is above both. The method reads a steep flare as less stabilizing than it is. That is the safe direction for a stability margin and the wrong one for a load. This is the boattail rule turned around. A boattail past 16° reads the correlation of one of the same radii drawn out to 16° (ADR-040, A boattail faster than sound). The radii are what set how much air the flare turns, and they are never changed.
That makes the answer continuous, by construction rather than by tuning. At the
limit the drawn-out flare is the real flare, so the two readings are the same body. The test
nothing_jumps_where_the_flares_shock_detaches probes either side of the boundary. At Mach 2.0
(a row of the table, so the reading is that row’s and not an interpolation) the boundary is a flare
of 22.969761173077°:
| probe, in the flare’s angle | change in the normal-force slope (fraction) |
|---|---|
| ±1e-9° | 4.527e-11 |
| ±1e-7° | 4.527e-9 |
| ±1e-5° | 4.527e-7 |
A hundredfold smaller probe moves the answer a hundredfold less. So what the probe finds is a
slope and not a step: the reading is continuous across the boundary. Its slope is not, and
nothing here claims otherwise. A cap makes a kink, because below the boundary the flare’s angle
moves the body the march sees and above it only the radii do. Measured at the same place,
changes by −31.4% across the boundary on the whole rocket. On the flare’s
own share it changes by −141.6%, changing sign. The marched branch is not smooth in the angle either: the same
probe at 20°, away from any boundary, finds +3.5% and +41.1%
(the_cap_makes_a_kink_in_the_slope_even_though_the_reading_holds). Probing the
Mach number instead gives 3.622e-10, 3.622e-8 and 3.622e-6 for the same
three probes. This is at the 18.5° of TN D-4865’s model 2, whose shock holds on the tests’
flared rocket from Mach 1.767666917849. That half is taken on the table’s own rows rather than on a reading between them.
The crossing falls inside the Mach 1.75 to 1.80 interval. There the reading is a straight line
between rows and would look continuous whatever the two branches did.
What it is worth. The tests’ flared rocket has a 10° conical flare 0.3 m (0.98 ft) long behind that tube, opening to a 79.9 mm (3.1 in) radius. A 0.2 m (0.66 ft) tail tube follows the flare, and the rocket has four fins. Its reference is the largest diameter, 0.1598 m (0.524 ft), and the numbers are at a small angle of attack. The method reads less normal force than slender-body theory and puts the center of pressure forward of it. So this rocket now reads less stable rather than more:
| the method | slender-body theory | the method’s center of pressure | |
|---|---|---|---|
| Mach 2.0 | 3.5371 per rad, at 7.365 calibers | 3.7153 per rad | 0.089 calibers forward |
| Mach 3.0 | 2.8899 per rad, at 7.015 calibers | 3.0815 per rad | 0.169 calibers forward |
| Mach 4.95 | 2.4880 per rad, at 6.681 calibers | 2.6431 per rad | 0.238 calibers forward |
So for a flare of this size the stability margin drops by a tenth to a quarter of a caliber,
growing with Mach number. a_flared_body_flies_the_method pins every figure in the table.
The old behavior is still selectable, for comparing:
BodyModel::with_supersonic_flare(SupersonicFlare::SlenderBody) in Rust, or
{"supersonic_flare": "slender_body"} in the body model’s JSON, reproduces every number from
before this milestone. Which to fly is not settled here. Neither column has been compared with
a measured flare. The method is the default because the rest of the body
already uses it faster than sound, not because it is known to be closer.
What it leaves out.
- The one measured flare is not this flare. What a marched flare is worth compares an 18.5° flare on a 2.75° cone, at six speeds, three of them with its boundary layer separated. The 10° flare in the table above is not that body. So the size of the difference it shows is still a change of model rather than a measured correction.
- The flare’s own detachment angle is still the wedge’s. A conical flare on a cylinder sits between a wedge and a cone, and nothing here measures where it is.
- Below about Mach 1.5552 the method has no reading for an 18.5° flare on the tests’ rocket at all. The corner’s isentropic turn runs out before its shock detaches (the section above). So the body’s table of the method’s shares starts there, and the join carries the reading up from slender-body theory’s over 0.3 Mach. That is continuous (a ±1e-9 probe at the join’s start moves the slope 8.5e-10 of itself). But it means a flare’s march is not used at all at the low end of what a flight uses.
- A near-flat flare is read by the older, rougher method. Between about 0.0004° and 0.059° on the tests’ rocket, depending on the Mach number, a flare’s single element is reduced. The pressure behind its corner sits just past its tangent cone’s while the gradient the tube delivers still pushes it away. So HPR Sim reads that element by the generalized shock-expansion method instead. The same reading applies on a nose (issue #81: the method’s limit near a sharp tip). Until M1.8e19: the near-flat flare the march refused such an element behind the nose. The whole body then fell back to slender-body theory at every Mach number, a switch worth −8.3% and 1.16 calibers. A near-flat flare below solves for where the region is at each Mach number and says what the change was worth. It also gives the one step that is left: +0.129% and 0.0051 calibers on this rocket. On a body with a short shoulder the step is up to +4.3% and 0.19 calibers.
- The march ends at the flare, and nothing behind it may carry lift. Anything behind the flare takes slender-body theory’s share, which for a tube is nothing. But a part that carries a share of its own, such as a small tail cone, takes the whole rocket off the method again. It does so at every Mach number, exactly as a second flare would. A flare followed by a plain tube and fins is the layout that flies. Where it does fly, the relaxation the method would give the tube behind the flare is left out. That reads a little less stable, not more.
- Everything here is inviscid. From Mach 2.96 up TN D-4865 records the boundary layer separating ahead of the juncture and reattaching on the flare. This moves the pressure rise downstream of where a tangent body puts it. Nothing here models that.
What a marched flare is worth
In short: A flare through the method says what HPR Sim does with a flare. It marches the shock-expansion method through the flare’s corner while the shock there stays attached. This section says how close that comes to a measured flare, which nothing had before M1.8e18, the milestone that did this work.
One flared body in the sources has its normal force and pitching moment printed. It is NASA TN D-4865’s model 2 ([J68]), a blunt 2.75° cone with an 18.5° flare. It was tested in the Langley Unitary Plan tunnel from Mach 1.50 to 4.63. Against it HPR Sim reads the normal-force slope −1.9% at Mach 1.90, +7.0% at 2.30 and +13.4% at 2.96. At 3.95 and 4.63 it reads +51.5% and +50.4%. The center of pressure is within 0.05 calibers through Mach 2.96 and within 0.088 at 3.95. The report’s own shadowgraphs show that flare’s boundary layer separated ahead of the juncture from Mach 2.96 up. The cost only shows in the two fastest rows, and why is not settled here. Below Mach 1.5289 there is no reading at all, and a flared body falls back to slender-body theory instead.
One body, one flare angle, six speeds, three of them separated: that is the whole of the evidence. It is not enough to call the model right, only enough to say where it is not obviously wrong. The decision record is ADR-048.
The body. Two things about it bear on the comparison. Its nose is blunter and more compound than model 1’s. So HPR Sim had to learn to hand a blunt tip’s cap over on a later piece of a nose. The report’s own drawing also does not quite close, so which printed numbers to keep had to be chosen. Neither is worth much (the closure is worth 0.76 points at most, measured three ways), but both are choices.
Fig. 3(b) (printed p. 91) draws model 2 in base diameters, = 0.583 ft (0.178 m). Its nose is not a sphere-cone. It is a 0.257 sphere from the tip, then a second arc of 0.429 whose center sits 0.135 below the axis. Then come the 2.75° cone and the 18.5° flare. Those three printed radii fix everything else. The two arcs are internally tangent, so their centers are 0.429 − 0.257 = 0.172 apart. With the 0.135 offset, that puts the second center 0.3635786 aft of the tip. Its tangent to the 2.75° cone then falls at 0.3429960 aft of the tip, matching the drawing’s printed 0.343 to four figures. That tangent is at diameter 0.5870, which misses its printed 0.586 by 0.001 of a diameter. A fourth printed dimension checks the same derivation from the other end. The 0.722 runs from the arc’s center to the flare juncture, and 0.3635786 + 0.722 = 1.08558 against 0.343 + 0.743 = 1.08600, a residual of 0.0004. HPR Sim draws that blend arc as a circular arc (the tangent ogive’s shape with its radius ratio solved for a 0.429 arc). The profile it builds misses the drawn circle by 8.3e−17 of a diameter.
The printed dimensions do not quite close, and the gap is the flare’s. Nose, cone and flare come to 0.3429960 + 0.743 + 0.523 = 1.6090, the printed length exactly. The cone closes on its own numbers too:
against the printed 0.657. The flare does not:
against a base that is 1.000 by definition, and 1.0084 with the nose taken from its three radii rather than from its printed 0.586. So either the flare is shorter than 0.523, or it is shallower than 18.5°.
HPR Sim keeps both half-angles, because they are the report’s text and not only its drawing. Its text reads “a blunted cone with a 2.75° half-angle and a flare afterbody having an 18.500° half-angle” (printed p. 8). It states them to three decimals, along with the nose, the length 1.609 and the base 1.000. These are the numbers the measured coefficients are divided by. What gives is the split of the length between the cone and the flare: a 0.7576199 cone and a 0.5083841 flare. That puts the juncture 0.0146 diameters aft of the printed one, at diameter 0.6598 against 0.657.
Two other closures are computed and published beside it, so the choice can be checked. Keeping the printed lengths and scaling the whole body to a 1.000 base moves the error by −0.12 to −0.17 points. Points here and below are percentage points of error. Keeping the printed lengths and the base, and giving up the flare’s stated angle instead (18.5° becomes 18.0864°), moves it by +0.06 to +0.64 points. Over all three the spread is 0.76 points or less in the slope and 0.0043 calibers or less in the center of pressure. Mach 1.50 is refused in every one of them, so nothing below turns on which closure is flown.
What it is compared with. Fig. 8(b) (printed p. 102) plots normal force , pitching moment and axial force against . The angles are 0°, 4°, 8° and 12°, for each of six Mach numbers. All three are coefficients, about the nose tip on the body’s own length. The circles are the report’s experiment: the surface pressures of its tables VII to XII integrated over the forebody (printed p. 12). No base pressure is in them. Every circle was read off the page’s 300-ppi scan by pixel analysis, the method written for model 1 in M1.8e7. The circles come out at −0.0039 to +0.0043 where they should read 0, which is what the plotting itself is worth. is not read, because HPR Sim’s supersonic drag is a separate model this comparison does not touch. HPR Sim’s slope and center of pressure are fitted the way that section fits model 1. A straight line is fitted through HPR Sim’s own at those same four angles, body lift included. So the two sides are the same quantity.
| Mach | measured , per radian | HPR Sim, per radian | HPR Sim’s error | measured CP, calibers aft of the tip | HPR Sim CP, calibers | HPR Sim − measured, calibers |
|---|---|---|---|---|---|---|
| 1.5 | 1.650 | none | none | 0.810 | none | none |
| 1.9 | 1.800 | 1.766 | −1.9% | 0.888 | 0.934 | 0.046 |
| 2.3 | 1.667 | 1.784 | +7.0% | 0.921 | 0.926 | 0.005 |
| 2.96 | 1.594 | 1.807 | +13.4% | 0.948 | 0.935 | −0.013 |
| 3.95 | 1.270 | 1.923 | +51.5% | 1.046 | 0.958 | −0.088 |
| 4.63 | 1.303 | 1.960 | +50.4% | 0.998 | 0.975 | −0.023 |
A positive number in the last column means HPR Sim puts the center of pressure further aft than the tunnel did. That reads as more stable than the rocket is. A negative one reads as less stable. The half-caliber the rest of this page uses as a target is the scale to hold them against.
The flare is most of what is being compared. Its own share of the body’s slope is 52.1% at Mach 1.90 and 60.8% at 4.63, and never below 51.5% (at Mach 2.30) in between. That share acts 1.382 to 1.390 calibers aft of the tip, on the flare itself, which runs from 1.101 to 1.609. So this is a test of the flare and not of a body that happens to have one.
How much of the miss is the flare’s. The same report, the same tunnel, the same figure and the same reading and fit also give model 1, a sphere-cone with no flare. Blunt tips already checks that body. Putting the two side by side separates what the flare costs from what the rest of the body costs:
| Mach | HPR Sim’s error, model 1 (no flare) | HPR Sim’s error, model 2 (flared) | the flare adds | the report’s own method, model 1 | the report’s own method, model 2 |
|---|---|---|---|---|---|
| 1.5 | −1.2% | none | none | −3.3% | +28.6% |
| 1.9 | +0.0% | −1.9% | −1.9 points | +2.0% | +24.8% |
| 2.3 | +7.5% | +7.0% | −0.5 points | +8.5% | +31.6% |
| 2.96 | +12.5% | +13.4% | +0.9 points | +5.2% | +12.1% |
| 3.95 | +29.7% | +51.5% | +21.7 points | +11.3% | +28.8% |
| 4.63 | +32.1% | +50.4% | +18.3 points | +13.6% | +20.3% |
They are not one body with and without a flare. Model 1 is an 11.5° cone on a 0.175-diameter nose radius, 1.755 diameters long. Model 2 is a 2.75° cone on a 0.257-diameter one, 1.609 long. So the flare adds column bounds what the flare costs rather than measuring it. Read it as a signed difference and nothing more: it is not a verdict on which body HPR Sim reads better. At Mach 1.90 the unflared model 1 is almost exact (+0.011%), while the flared one is 1.9% low. So in size of error the flare is the worse row, not the better one.
Taken that way, the column still says something clear. Through Mach 2.96 the flare moves the error by −1.9 to +0.9 points. That is less than the rest of the body already misses by. At Mach 3.95 and 4.63 the flare moves it by 21.7 and 18.3 points, an order of magnitude more. There the measured itself falls away (from 1.594 at Mach 2.96 to 1.270 at 3.95). By contrast, both attached-flow methods on the figure, the report’s own and HPR Sim’s, stay between 1.57 and 1.96.
The obvious explanation is the flow. From Mach 2.96 the report’s shadowgraphs show the laminar boundary layer separating ahead of the juncture and reattaching behind it (printed p. 10). Nothing in an attached-flow method describes that. The report blames the separated flow for its own method’s disagreement with the measured pressures at the high Mach numbers (printed p. 10). It blames the same flow for its over-prediction of axial force (printed p. 12). It says nothing about what separation does to the normal force or the pitching moment. Nor does its method carry a separation signature on this body. It reads +24.8% at Mach 1.90 and +31.6% at 2.30, both attached rows, against +12.1%, +28.8% and +20.3% at the three separated ones. The report’s method is uniformly high on model 2 and near the tunnel on model 1. This is a large offset this milestone has not explained. So read the separation as consistent with the two fast rows rather than measured by them. Nothing here settles why separation costs 0.9 points at Mach 2.96, where the report says it has already begun, or twenty times that at 3.95.
Where the method has no reading. At Mach 1.50 HPR Sim refuses model 2 outright. The refusal is worth following, because it is not the rule the section above describes. Two limits decide what the march does with a flare’s corner. One is the steepest surface angle whose shock stays attached there, which is the rule that section sets. The other is the steepest the march itself can turn the flow through. Both are in the table below as surface angles of the flare, so they can be read against its 18.5° and against each other:
| Mach | the flow reaching the corner | the steepest angle its shock holds | the steepest the march takes | the flare is read |
|---|---|---|---|---|
| 1.5 | Mach 1.5241 | 15.4885° | 15.3647° | drawn out, then refused |
| 1.9 | Mach 1.9354 | 24.5773° | 27.3345° | as drawn |
| 2.3 | Mach 2.3072 | 30.0000° | ≥ 30° (the tables) | as drawn |
| 2.96 | Mach 2.8966 | 30.0000° | ≥ 30° (the tables) | as drawn |
| 3.95 | Mach 3.6913 | 30.0000° | ≥ 30° (the tables) | as drawn |
| 4.63 | Mach 4.1636 | 30.0000° | ≥ 30° (the tables) | as drawn |
The turn the corner makes is each of those angles less the 2.75° of the cone ahead. From
Mach 2.3 up the third column is clipped at the cone tables’ 30° (past that an element has no
tangent cone to relax toward). The search behind the fourth column
stops at the same place. Neither is a measured edge there, and the fourth says so rather than
printing the cap as though it were one. At Mach 1.50 the flare is steeper than the 15.4885° its
corner’s shock holds, so ADR-047’s rule draws it out to 15.4885°. The march then refuses
that body too, because the steepest flare it can march there is 15.3647°, a tenth of a degree
shallower. The two limits are different things. One is where the corner’s shock detaches, the other
where the corner’s isentropic turn runs out (Where a flare’s march
stops, ADR-045). Which is the tighter one changes with
speed. Below where they cross, drawing a flare out to the shock’s limit lands past what the march
can do. Swept every 0.005 Mach from 1.05 to 4.63, the reading turns on exactly once. Bisecting that
one crossing to f64 resolution puts HPR Sim’s first reading of model 2 at Mach 1.5288696.
Just below it the two limits agree to five parts in 1e14, both 16.2844275°, so the reading begins
exactly where they cross. (The fixture keeps the whole f64. Seven figures are printed because those
are what the three operating systems CI runs agree on. Each regenerates the bisection to within a
part in 1e12 of the others.) That is a different number from the Mach 1.5552
the section above quotes for the same 18.5° flare, and it should
differ. The body ahead of the corner is different, so the flow it delivers there is different, and
the crossing moves with that flow. Below that a flared body takes slender-body
theory instead, carried up over 0.3 Mach by the
join. The join is continuous, but it means the method is not used at
the low end of what a flight flies. The report says the same about its own method: “at , the shock wave produced by the flare is not theoretically attached”
(printed p. 10). Its method reads +28.6% there against −3.3% on model 1.
The rows above are in
validation/fixtures/aero/marched-flare.json,
written by cargo xtask aero; the readings in
tn-d-4865-flared-cone.json,
with how each circle was read. A test holds every table here to the fixture, cell by cell. The
reading is HPR Sim’s own rule and not a second copy of it. hpr-design has no spherical-cap nose,
so model 2 cannot be flown through a Rocket. The test the_flare_is_read_as_the_model_reads_it
pins the fixture’s reading against the model’s own shares, share by share, to a part in 1e12. It runs on another flared body, one the design route can express, at angles the corner’s shock holds and at angles it does not. That pins the arithmetic, not the physics: an error in the
rule itself would be in both and pass.
What it leaves out.
- Three of the six rows are a separated flare. From Mach 2.96 the report’s shadowgraphs show the boundary layer separating ahead of the juncture. Nothing in HPR Sim models that. The +51.5% and +50.4% at Mach 3.95 and 4.63 are what those rows cost on this body. The report’s own words make that consistent with separation rather than caused by it, since it never says what separation does to the normal force. No source here says how a separated flare scales with the flare’s angle, its length or the boundary layer’s thickness. So those two numbers do not transfer to another flare.
- One body and one flare angle. 18.5°, on a 2.75° cone, at six speeds. Nothing here measures a shallow flare, a steep one, a flare behind a cylinder rather than a cone, or a flare on a pointed nose. A reader with a different flare has no measured error to apply. What this section supports is that HPR Sim’s flare is not obviously wrong where the flow stays attached. It does not support calling it good to 7% on some other body.
- The drawn-out reading past the limit is measured against nothing at all. The one row where it would have applied is the row the march then refused. So the rule above the corner’s limit is still a construction chosen for continuity.
- The measurement is the forebody only. Its and are integrated surface pressures with no base term, which is what HPR Sim’s body model computes too. It also means the tunnel’s own balance never weighed this body. A reading error of about 0.004 in sits under every circle.
- is not compared. The same figure plots axial force, and the report notes its own method reads it high where the flare separates. HPR Sim’s supersonic drag is a different model with its own checks; this milestone did not touch it.
- The drawing is 1% inconsistent and one closure had to be chosen. The spread over the three closures is small (0.76 points, 0.0043 calibers), and the flare’s own angle is inside it. It is the drawing’s disagreement with itself, not an error bar on the measurement.
- No target was set, and none is met or missed here. M1.8e18 asked what a marched flare is worth, not that it reach a number. The tables above are the answer.
A near-flat flare
In short: a very shallow flare turns the flow so little that the second-order shock-expansion method’s own pressure curve has nothing left to describe. The march then falls back on the older generalized method for that one element. Until M1.8e19: the near-flat flare HPR Sim refused to read such an element at all behind the nose. That took a rocket with a flare of about a third of a millimeter’s rise off the method entirely. It now reads it. This section says which flares those are, what the change was worth, and the one small step that is left. The two angles that bound them are solved from two equations about the corner’s own flow, not found by bisecting the model’s refusal.
That body is a pointed 2.75° cone and five calibers of tube, whose radius is nearly four times as large.
What a flare that small does to the method. The march is the walk along the tangent body’s straight elements, from the nose tip aft, that the method makes. It fixes the pressure just behind each corner from the Prandtl-Meyer turn there. It then lets the pressure relax along the element toward the pressure on that element’s tangent cone, as
(NACA TN 3527 eqs. 8 and 9), where is the distance back from the corner. The same exponent written as a rate per meter is the of What a crossing is, and what it costs. The symbols are the method’s own, listed under Bodies faster than sound. is an element’s angle to the axis, the pressure over the free stream’s and distance along the surface. is the radius at the corner, a stream tube’s widening and . Below, is the flare’s own turn through its corner. Subscript 1 is the state the body ahead delivers, and 2 the state just behind the corner.
That is a curve that starts at and walks one way, toward . It can only do that if the gradient just behind the corner points at . The report keeps the form only for (p. 13). At , it says, “all equations reduce to those given by the generalized shock-expansion method”, whose pressure is constant along the element.
On a near-flat flare the two disagree. The flow arrives at the flare along a long tube. There the pressure is still climbing back toward the free stream’s after the nose let it down. It is below the free stream and rising. The flare’s corner compresses it a little. Turn far enough and the pressure lands well above the tiny cone’s, and the gradient behind the corner turns downward with it. So everything agrees and the method runs. Turn less and the pressure stays below the cone’s, still rising toward it, so again everything agrees. In between there is a band where the compression has already carried the pressure just past its cone’s value. There the tube’s own climb still pushes it further away. It has to rise, overshoot and come back, and one exponential cannot rise and fall. So is negative there. The element is reduced to the generalized method (issue #81: the method’s limit near a sharp tip is the same reading on a nose).
The region’s two edges are solved from the corner, not searched for. Each of the two quantities whose signs must agree is a smooth function of the flare’s turn. On every corner state checked here each has a single zero. So the signs disagree on the open interval between those two zeros and nowhere else:
| the turn | what is zero there | what it means |
|---|---|---|
| the crossing | the compression lands the pressure exactly on its tangent cone’s, and has a pole | |
| the balance | the corner’s own compression exactly cancels the climb the tube delivers, and is zero |
Single zero is not a promise, and a corner that breaks it exists. On a 25° cone with 20 mm (0.79 in) of tube behind it at Mach 7, the pressure meets its tangent cone’s three times. The crossings
are at about 0.91°, 7.3° and 24°. A flare there is reduced from 0.91° to 3.88° and again from
7.3° to 24°. flare_reduction_turns_rad sweeps the widening turns at a hundred stations before it
brackets. So it reports that corner rather than handing back whichever of the three roots it
walked to (a_corner_whose_gap_has_three_zeros_is_refused_rather_than_guessed_at). A pair of roots
inside one station would still slip through and be reported as one band when they are two.
Which of the two is the shallower is not fixed either. On this rocket the crossing is below the balance from Mach 1.5 up, and below that the order swaps.
Both are properties of the flow the body hands to the corner. Those are its Mach number, its
pressure, the gradient it carries, the radius there, the angle ahead and the free stream it was
read in. flare_reduction_turns_rad takes exactly that and nothing else. The balance is TN 3527’s
eq. 4 set to zero and rearranged,
which iterates on itself. The crossing is : an isentropic turn on one side, a cone solution on the other. It is bracketed over the turns a widening corner can make at all. The range runs from a surface lying along the axis up to the isentropic turn running out or the cone tables’ 30°, whichever comes first. The root is then found by false position from the turn that would bring the pressure back to the free stream’s.
On the tests’ flared rocket they are these:
| Mach | crossing | balance | a flare between them rises, over 0.3 m (0.98 ft), by |
|---|---|---|---|
| 2.00 | 0.000403337° | 0.000454464° | 2.1 to 2.4 µm |
| 2.20 | 0.000901825° | 0.001041403° | 4.7 to 5.5 µm |
| 3.00 | 0.006619249° | 0.008121929° | 35 to 43 µm |
| 4.00 | 0.023088893° | 0.029499725° | 0.12 to 0.15 mm (0.0047 to 0.0059 in) |
| 4.70 | 0.038161270° | 0.049811274° | 0.20 to 0.26 mm (0.0079 to 0.010 in) |
| 5.00 | 0.044649637° | 0.058820517° | 0.23 to 0.31 mm (0.0091 to 0.012 in) |
The test the_turns_a_reduced_element_lies_between_come_from_the_corners_own_state, in
shock_expansion.rs,
runs at eight Mach numbers. It checks that an angle a millionth either side of each edge falls on
the right side of the march’s own reduction. It also checks that the midpoint between the edges is
reduced. That is a spot check at each edge, not an exhaustive sweep of the angles in between.
These are the numbers that issue #117: the near-flat band the march used to refuse reported after bisecting the model’s own refusal. The band it quoted, 0.03816127° to 0.05882052°, is the crossing at Mach 4.70 and the balance at Mach 5. The 0.00090182° it quoted is the crossing at Mach 2.20. What the table shows and that band hides is that the region is not one interval in the angle. It moves with the Mach number, so a 0.04° flare is reduced at Mach 4.70 and marched at Mach 2.
Divided by how fast the gap closes with the turn, that is about 2e-10°. That is close to the 2.6e-10° the band’s lower edge was seen to spread over on the three operating systems CI runs. So that spread was the cone’s and not the bisection’s.
Neither residual is promised to be zero, and on a body whose cone flow is harder it is
larger. A residual of 4e-9 of the free stream’s pressure has been seen on a fatter body at Mach
2.6. So flare_reduction_turns_rad returns both of them beside the turns, and a caller who needs
the digits should read them.
What HPR Sim does now, and what changed. A reduced element is read by the generalized method wherever it has a tangent cone of its own. That means constant pressure and loading along it, which is what the report says the equations become. Before M1.8e19 that reading was allowed only on the nose, and anywhere behind it the march refused. HPR Sim builds a body’s table of the method’s shares downward from Mach 5 and needs the whole 0.3 Mach of the join inside it. So one refused row near the top took the table away and dropped the whole body to slender-body theory at every speed. Two switches came of that, and both are gone:
| drawing this | was worth | is worth |
|---|---|---|
| a flare of 0.05882052°, the band’s steep edge, at Mach 3 and 4° | −8.30% of the normal force and 1.16 calibers | nothing |
| a flare of 0.00090182°, which lifted the table’s start from Mach 1.2 to Mach 2.2, at Mach 2 and 4° | −4.62% and 0.75 calibers | nothing |
The middle column’s sizes are still measured, because they are the size of the fallback the
model used to drop to. a_near_flat_flare_marches_every_row_and_the_fallback_is_still_measured,
in model.rs, reads
the same rocket on SupersonicFlare::SlenderBody and finds them again. The table’s start is now
Mach 1.2 at fifteen flare angles from 0° to 1°. These include 0.00024°, 0.00025° and 0.0003°,
three angles a hair apart that used to give three different answers.
What is left is the crossing, and here is how big it is. At the crossing itself has a
pole. That leaves a step, not in the pressure, which rides through because the gap it multiplies is
zero there, but in the loading. On the side the method still owns, runs to as
the turn approaches the crossing. So the element sheds its corner’s loading onto its tangent
cone’s within its own length. On the reduced side it holds the corner’s. The two differ, so the
reading steps. The step is measured on the whole rocket at 4°, either side of that Mach number’s
own crossing, with a ±1e-9° probe. a_near_flat_flare_reads_through_and_leaves_only_the_corners_crossing,
in model.rs,
does the measuring (Mach 4.95 rather than 5 because the body’s normal force stops at Mach 5):
| Mach | at a flare of | normal force | center of pressure |
|---|---|---|---|
| 2.00 | 0.000403337° | +0.00032% | −0.0000016 calibers |
| 3.00 | 0.006619249° | +0.011% | +0.00018 calibers |
| 4.00 | 0.023088893° | +0.055% | +0.0017 calibers |
| 4.95 | 0.043584193° | +0.129% | +0.0051 calibers |
A step, not a slope, except on the first row. Widening the probe a hundredfold, to ±1e-7°, leaves the figure where it is at Mach 3, 4 and 4.95. That is what says it is a step rather than the reading’s ordinary movement. At Mach 2 it does not. +0.00032% is already about what the reading itself moves over a ±1e-7° probe there. So that row is an upper bound on the step, not a measurement of one.
Those four numbers are one rocket, and they are not a bound. The step is the loading’s gap at
the pole, so it grows with the length of the element that holds it. Where the region sits
depends on the body ahead. Read on the body alone at Mach 5, either side of that body’s own
crossing (what_the_crossing_costs_is_the_loading_gap_times_the_element_that_holds_it, in
shock_expansion.rs):
| the body | its crossing | steps by | its center of pressure by |
|---|---|---|---|
| the tests’ rocket’s body: ogive nose, 0.7 m (2.3 ft) tube, 0.3 m (0.98 ft) flare | 0.044650° | +0.40% | 0.064 calibers |
| the same, with a 2 m (6.6 ft) flare | 0.044650° | +2.61% | 0.761 calibers |
| the same, with the tube cut to 0.1 m (0.33 ft) | 1.387993° | +4.34% | 0.186 calibers |
| a 10° cone and a 0.3 m (0.98 ft) tube, 0.3 m (0.98 ft) flare | 0.695840° | +3.82% | 0.251 calibers |
Read the third and fourth rows twice. With a short shoulder the region is not near-flat at all: it sits between 0.7° and 4.6°, which is where real flares live.
But there is a bound, and it is exact: you can work out your own. At the crossing the two sides take the two constants the method relaxes between. The side it still owns sheds the corner’s loading onto its tangent cone’s at once, . The reduced side holds the corner’s, . Along a conical flare both are constant, so eq. 19’s integrates a constant and the whole step is
for a flare of length between those radii. flare_reduction_turns_rad returns beside
the turns, as crossing_loading_gap_per_rad. On the tests’ rocket’s body at Mach 5 that gap is
6.116195e-4 per radian. The formula reproduces the measured step to a part in 1e5 at flare
lengths of 0.3, 1, 2 and 5 m (16 ft). So the four rows above are an illustration of that formula,
not the claim. The claim is the formula, and it holds for any conical flare.
The worst of the whole-rocket rows is a 64th of the switch it replaced in the force, and a 227th in the center of pressure. The step in that row is at Mach 4.95, and the switch was measured at Mach 3. So that compares sizes, not the same flight condition. The body-alone numbers above are not that small.
And the same pole is crossed in the Mach number. At a fixed flare angle the corner’s crossing sweeps past it as the speed changes. The table’s rows are 0.05 Mach apart, so a flight reads it as a step between two neighboring rows. On the short-shouldered body above with a 1° flare, the rows from Mach 2.90 to 2.95 step −2.77% and 0.14 calibers. The neighboring rows move by a fifth of that or less. Before M1.8e19: the near-flat flare those lower rows were refused, so the table began above them and the join covered the pole. The pole is now inside the table. That is the milestone’s trade. Two switches in shape were removed, and one pole was exposed in both shape and speed. On a body whose reduced rows sit at the bottom of its table, what is given up is a continuous join. What is bought is that an arbitrarily small change of shape no longer moves the whole body between two models.
It is not a new question, though. It is the loading through a tangent-cone crossing, which is what a crossing costs inside a segment. It is open as issue #108: the loading through a crossing. This part of it, at Mach 2.90 to 2.95, is inside the operating envelope’s extended band. So it is part of M1.14h: the extended band. Only #108’s part above Mach 4 is deferred (ADR-143). The region’s other edge, the balance, has no step at all. There is zero, so the exponential form and the generalized method are the same reading, and the two branches meet.
What it leaves out.
- A cylinder’s and a boattail’s reduced elements are still refused, and still take the whole body off the method. Not because a flare relaxes toward something and they do not. A reduced element does not relax at all, on a flare exactly as on a cylinder. It holds the pressure and the loading behind its corner for its whole length. What differs is what it is read against. A widening element’s and are a real cone’s at the flow’s own Mach number. So the two readings either side of the region are two readings of one picture, and they meet at the balance. A cylinder’s is identically zero and its is the free stream’s, so there is no cone there to meet. A boattail’s is footnote 8’s constant (a stand-in, not a solution of that element’s own flow). Nothing here measures what that would be worth, so the refusal stands: issue #123: a cylinder’s or a boattail’s reduced element. How near is it? An ogive nose on a tube marches every row from Mach 1.2 to Mach 5 with nothing reduced. The nose is 0.25 m (0.82 ft) on a 27 mm (1.1 in) radius. The tubes are 0.7 m (2.3 ft), 3 m (9.8 ft) and 6 m (20 ft). So it is not something a plain rocket walks into. What does hit it is TN D-4865’s own Newtonian start on the Arcas Robin’s nose from Mach 3.96. That is a reason HPR Sim does not use that start (The two starts).
- The generalized method is the older, rougher one. Reading an element with it is a real choice, not a formality, and TN 3527 does not say it is what it would have done. What is checked is that the choice joins the second-order reading continuously at the balance and makes the reading smooth in the flare’s angle. Whether it is closer to a measured flare is not checked. No measured flare in this band exists.
- Below about a millionth of a radian the flare is not drawn at all. Corners turning by less than that are merged into the element ahead of them, because two tangents that nearly coincide meet at an ill-conditioned point. That covers every flare shallower than about 0.00006°, which at the bottom of the table’s range swallows both turns. At Mach 1.2 the crossing is 0.00000023° and the balance 0.00000018°. So there is no corner there to reduce and nothing the reading could switch on.
- Only the flare’s own element was measured. The two turns are solved for a corner behind a body. Where a body has several corners that could be reduced at once, nothing here says how their readings combine. Nor does anything here say whether the generalized reading or the slender-body fallback it replaced was the nearer of the two to the air. What is claimed is that one of them moves smoothly with the shape and the other jumps.
- There is no rule of thumb for “is my flare one of these?”. The region belongs to the corner,
so the only way to ask is to run the model. Call
ShockExpansionBody::aft_flowon the body ahead of the flare, at the Mach number you care about, thenflare_reduction_turns_radon what it returns.
A step in radius
In short: a step is a joint where one part’s radius does not match the next one’s, so the rocket’s outline jumps rather than bending. Examples are a 54 mm (2.1 in) tube butted straight onto a 75 mm (3.0 in) one, and a coupler standing proud of the airframe. That stops HPR Sim’s second-order shock-expansion method, the march, which walks a chain of straight elements, the tangent body, from the nose tip aft. The march needs an outline without a jump in it. HPR Sim drops the whole body to slender-body theory, at every speed. A rocket with a step reads as though the method did not exist. M1.8e15 measured what that costs and tried the obvious fix; the fix was worse, so the behavior is unchanged and the cost is published instead. The decision record is ADR-049. The work left over is issue #87: a step takes the whole body off the method, open and not on the roadmap. Nothing measures a stepped body faster than sound, so neither the present reading nor any replacement has a reference.
What it costs. These numbers are for the tests’ straight rocket at Mach 3 and 4°. Its nose is a tangent ogive 0.25 m (0.82 ft) long. Three tubes of 0.7, 0.05 and 0.3 m (0.98 ft) follow, all 27 mm (1.1 in) in radius. The reference diameter is pinned at 54 mm (2.1 in) so that every row is divided by the same area. With no step it reads , its center of pressure 16.9492 calibers aft of the nose tip. Each row is the change from that. Down means the body narrows from that joint aft, up that it widens:
| the step and its joint | normal force | center of pressure, calibers |
|---|---|---|
| down 2.8e−11 m, the first size past the threshold, at any joint | −8.65% | +1.0285 |
| down 1 mm (0.039 in), at the nose’s joint | −10.62% | +1.1938 |
| down 1 mm (0.039 in), at the last joint | −10.29% | +0.9949 |
| down 2 mm (0.079 in), at the nose’s joint | −12.55% | +1.3593 |
| down 2 mm (0.079 in), at the last joint | −11.89% | +0.9597 |
| up 2.8e−11 m, at any joint | −8.65% | +1.0285 |
| up 1 mm (0.039 in), at the nose’s joint | −6.72% | +0.8674 |
| up 1 mm (0.039 in), at the last joint | −7.05% | +1.0644 |
| up 2 mm (0.079 in), at the nose’s joint | −4.75% | +0.7064 |
| up 2 mm (0.079 in), at the last joint | −5.41% | +1.0987 |
At the threshold the shape is flush to a part in a billion either way. So the whole difference there is the method itself, the same wherever the step sits and whichever way it goes. Past that the shape starts to matter, and the two directions part. A step down takes area off the body and costs more. A step up adds area that carries slender-body normal force of its own and costs
less. The center of pressure moves aft in every row, so a rocket that trips this reads more
stable than the same rocket drawn flush. That extra margin is more likely optimistic than real. The model it falls back to reads 15% to 50% below the wind tunnel on the Arcas Robin’s body faster than sound. See The body faster than sound in a flight. If you
can draw the joint as a short transition instead of a butt joint, the body keeps the method. HPR Sim’s own radius_step warning (the design model’s checks) tells you a design has tripped this.
a_step_takes_the_whole_body_off_the_method pins every figure in this section and the flush
rocket’s own readings with it; Checking a claim says how to run a named
test.
Where the threshold is. It is a pair, not one number, and which of the two binds depends on the joint:
| the joint | what binds | on the tests’ bodies |
|---|---|---|
| radius changes, slope does not (tube to tube), either direction | the tangent body merges two elements whose radii agree to a billionth of the radius | 1e−9 × 27 mm = 2.7e−11 m |
| slope changes too (a step up at a boattail’s fore end) | the elements’ corners have to stay in order along the body | 1e−12 × 1.3 m × 0.1 = 1.3e−13 m |
Both are bisected. The second is 208× finer. It depends on the body’s length and the change of slope rather than on its radius. So it is not a property of the step at all. It bites on the commonest high-power shape. Take the tests’ finned rocket with a boattail whose fore radius is 27.0000000000002 mm (1.062992125984 in) rather than 27 mm (1.1 in). The whole body loses the method, worth −11.34% and 1.0951 calibers, larger than the tube-to-tube switch above.
Neither number is a judgment about steps. They are the widths of the rounding the tangent body can absorb. Every step anyone could build or draw is far past both, so a step always takes the body off the method. (A third, much looser test is what actually refuses every step bigger than a millionth of the fore area, or 13.5 nm of radius here. That test, the run’s own coverage gate, asks how much of the body the method can cover. It gives the same reading, and the test pins which of the two owns which range.)
What a fix has to handle. The obvious fix is to stop the march at the step. The body ahead of it would keep the method, the way the run already ends at a flare. That was built and measured, and it failed three ways. The numbers in this list were taken on that prototype, which was not kept. Unlike the tables above, no committed test reproduces them. ADR-049 records how each was measured and where the prototype lives.
- What is behind the step. ADR-034, the decision that the method covers a body or nothing, rejected mixing the two models on a measured case. A step’s remainder is supposed to be a plain tube, but “the run stopped at a step” does not make it one. With a boattail behind the step, the mixture’s center of pressure lands at 16.7209 calibers, forward of both pure models. These are the method’s 16.7286 and slender-body theory’s 17.8237. A reading outside the envelope of both models it is made of is the pathology ADR-034 measured.
- It does not close the band it was meant to close. The prototype removes the step’s switch at a tube-to-tube joint. At a joint whose slope changes, it is the corner ordering that refuses the body, at 1.3e−13 m. So a boattailed rocket still loses the method, worth −11.34% and 1.0951 calibers. The commonest shape it was supposed to help is the one it does not.
- Which shape stopped the run, not whether the joint was flush. The prototype keyed off the joint. Any reason the run closed (a non-conical flare, a lip out of its wake) kept the forebody marched. That happened as soon as the closing element’s fore radius was a picometer off. That is a new jump of +7.2% and 0.69 calibers where today the reading is continuous. That one is a property of how the prototype was built rather than of the idea. A fix keyed off the shape would not have it. It is listed here because it is what a fix has to get right, not as evidence the idea cannot work.
What it leaves out.
- The step’s own force is slender-body theory’s, at any speed. at the joint, the limit of a transition whose length goes to zero. [B67] p. 18 assumes no discontinuities, so this goes beyond its source. There is no compressibility term. A forward-facing step at supersonic speed stands a detached shock with a separated pocket ahead of it; none of that is modeled.
- No source gives a stepped body’s normal force faster than sound. MIL-HDBK-762 treats a rearward-facing step only as base drag, TN 3527 ([SD56]) needs a continuous profile, and nothing else pinned here covers one. So “take the whole body off the method” is not known to be right either. It is the reading that does not mix two models, which is the only argument for it.
- One body, one placement sweep. Three joints on one rocket at one Mach number and one angle, and the large steps up carry a moving reference diameter with them.
Blunt tips
What this covers: the body faster than sound when the nose’s tip is blunt or vertical. Examples are power-series noses with below 1, Haack series (the von Kármán and L-V Haack) and elliptical noses. Their profile leaves the tip at 90°.
Against the smooth secant ogive fitted to the same nose the body reads lower at every Mach number. It is closer to the tunnel at nine of the eleven rows, by 0.7 to 5.8 points. Past Mach 4 it crosses into under-prediction and lands 0.6 to 1.5 points further out.
Why a cap. The shock-expansion method replaces the nose by straight elements, short cones and frustums each tangent to the profile. It starts at a pointed tip, where the air flows as it does over a cone. A vertical tip has no such cone: the shock stands off the nose, and the air just behind it is slower than sound. Jackson, Sawyer and Smith ([J68]) handled blunt noses by giving the tip’s cap Newtonian pressures. They handed over to the method where the flow behind the cap is fast again, the handover. HPR Sim does the same.
The cap. Newtonian theory takes the pressure from the angle between the surface and the
wind: ([J68] eq. 1, p. 5). is the pressure coefficient at the
stagnation point, the tip, where the air comes to rest behind a normal shock. It follows from the pitot pressure a probe would read there, the Rayleigh pitot formula ([R1135] eq. 100). At a small angle of
attack the windward side meets the wind a little more steeply. So the cap carries of loading in the method’s terms. A hemisphere then carries its Newtonian drag turned into the body’s axes, , as it must (test a_hemisphere_carries_its_drag_turned).
The handover. The method takes over where the surface’s slope falls to the largest angle a wedge can turn the flow through with its shock attached. That angle is 12.1° at Mach 1.5 and 22.97° at Mach 2 ([R1135] eqs. 138 and 168). The report chose this point “simply because it gave the best agreement with the available data in the low supersonic-speed range” ([J68] p. 5). HPR Sim caps the handover at 24°, which the wedge’s angle passes at Mach 2.06. The cap is there because the method needs the normal-force slope of a cone tangent to the body. TN 3527’s chart of that slope stopped at 24° ([SD56] Fig. 2). Those slopes now reach 30° (ADR-042) and the cap has not followed, because the method’s march does not carry it that far. What the cap is worth measures what moving it would buy and what it would cost.
How much of the nose the cap covers depends strongly on speed. Where it ends, as a share of the nose’s length and of its base radius:
| nose | Mach 1.25 | Mach 1.5 | Mach 2 | Mach 3 |
|---|---|---|---|---|
| arcas robin, the committed nose | 59.1% / 0.72 | 5.8% / 0.16 | 0.9% / 0.05 | 0.8% / 0.05 |
| von Karman, five calibers | 47.8% / 0.69 | 4.1% / 0.12 | 0.3% / 0.02 | 0.2% / 0.01 |
| power series n = 0.5, five calibers | 29.2% / 0.54 | 5.4% / 0.23 | 1.4% / 0.12 | 1.3% / 0.11 |
| elliptical, two calibers | 65.3% / 0.94 | 34.9% / 0.76 | 13.9% / 0.51 | 12.8% / 0.49 |
| TN D-4865’s sphere-cone (model 1) | past the sphere: the method doesn’t hold | 7.8% / 0.34 | 6.0% / 0.32 | 5.9% / 0.32 |
Near the join’s start a slender nose leans on Newtonian pressures over far more of itself than anything the report checked. By Mach 2 the cap is a percent or so of the nose, less than the report’s own. The join’s weight rises from 0 at its start to 1 over the next 0.3 Mach, which damps that. But read a vertical tip’s numbers between the join’s ends as the blend they are.
A power-series nose meets its base at a slope of , with its length over its diameter. The cap can’t end on the nose while that slope is steeper than the handover’s angle. So such a nose
takes the method no earlier than the Mach number where the handover’s angle passes its base’s. Its join to slender-body theory starts there rather than at Mach 1.2. For that is Mach 1.23 at 3 diameters long and 1.49 at 1.2 diameters; the Arcas Robin’s from 1.22. One shorter than
diameters (0.56 for ) never takes it, since the handover stops at 24°, and keeps slender-body theory. HPR Sim doesn’t warn, and
AeroModel::supersonic_body
returns None. Haack and elliptical noses end level, so the cap always ends on them.
A blunt nose can be more than one shape, and the cap may end on any of them. Since M1.8e18, a nose that starts with a sphere carries on through the curved, widening shapes behind that sphere. HPR Sim looks for the handover along all of them rather than in the sphere alone. TN D-4865’s own model 2 needs it. Its nose is a sphere blended into a 2.75° cone by a second arc. The sphere is still at 38.3° where the arc takes over, steeper than the 24° cap at any speed. So the handover always falls on the arc (What a marched flare is worth).
Everything else reads exactly as it did before, on purpose. A pointed nose is one shape however many curved shapes follow it, so a curved transition behind one is still the afterbody. And the search stops at the first shape that is straight or narrows. A cap that reached a cylinder or a boattail would hand the flow over at no angle at all. It would do so with none of the total pressure the tip took out of it. So a nose steeper than the handover all the way to one is still refused. That is the case in the paragraph above, and its numbers are unchanged.
Behind the handover. HPR Sim starts the method there as it starts at a pointed tip. The flow is on the tangent cone, the cone that touches the body at the handover. The report starts it from the Newtonian pressure instead. What that choice is worth is set out in The two starts, after the checks below.
A worked example. The report’s sphere-cone at Mach 1.5: a nose radius of 0.175 base diameters on an 11.5° cone. The pitot pressure is 3.413 times the free stream’s, so
The wedge’s largest angle is 12.11°, reached on the sphere diameters behind the tip. On a sphere, with the angle from the tip, the loading integrates over the cap to on the sphere’s own cross-section. To that is 0.700, and 0.086 on the base (times ). The cone behind it, marched from the flow on a 12.11° cone, carries the other 1.595 of HPR Sim’s 1.681.
How it was checked. HPR Sim is checked against the report’s own model 1, measured at Mach 1.50 to 4.63. Its points are read from [J68] Fig. 8(a), p. 101, by pixel analysis of the scan, to about ±0.003. The plotting itself is good to about ±0.01. The comparison is made as ADR-036 compares the Arcas Robin. HPR Sim’s is taken at the plotted 0° to 12°, with the method’s slope including body lift. The body lift is Jorgensen’s, for a body of fineness 1.75, shorter than his Fig. 4 covers. The fit is a straight line, as for the measured and and for the report’s own method. Slopes are per radian on the base; the center of pressure is in base diameters from the tip:
| Mach | measured, per rad | the report’s method, per rad | vs measured | HPR Sim, per rad | vs measured | CP measured, diameters | HPR Sim CP, diameters |
|---|---|---|---|---|---|---|---|
| 1.5 | 1.908 | 1.844 | −3.3% | 1.885 | −1.2% | 1.00 | 1.03 |
| 1.9 | 1.926 | 1.964 | +2.0% | 1.926 | +0.0% | 1.03 | 1.02 |
| 2.3 | 1.833 | 1.989 | +8.5% | 1.971 | +7.5% | 1.03 | 1.02 |
| 2.96 | 1.786 | 1.878 | +5.2% | 2.009 | +12.5% | 1.06 | 1.02 |
| 3.95 | 1.618 | 1.800 | +11.3% | 2.099 | +29.7% | 1.05 | 1.03 |
| 4.63 | 1.550 | 1.762 | +13.6% | 2.048 | +32.1% | 1.09 | 1.03 |
Past Mach 2.3 HPR Sim reads high twice over. At Mach 3.95 and 4.63 its slope at is 13% to 21% above the measured one. There its body lift lifts its fitted slope 25% to 27% above that, where the measured curve rises only 9% to 16% above its own. The slopes at follow, beside it and not judged. The measured one is fitted with a curve two ways, as the decision record on comparing with a wind tunnel, ADR-036, asks:
| Mach | measured, fit, per rad | measured, fit, per rad | HPR Sim, per rad | HPR Sim from the report’s start, per rad |
|---|---|---|---|---|
| 1.5 | 1.741 | 1.810 | 1.681 | 3.392 |
| 1.9 | 1.979 | 1.952 | 1.711 | 1.960 |
| 2.3 | 1.657 | 1.717 | 1.713 | 1.792 |
| 2.96 | 1.646 | 1.684 | 1.702 | 1.700 |
| 3.95 | 1.433 | 1.484 | 1.678 | 1.625 |
| 4.63 | 1.339 | 1.419 | 1.613 | 1.484 |
The Arcas Robin’s committed design follows: its power-series nose, cylinder and boattail with the lip left off, to show the cap’s own effect. The lip itself carries nothing (A lip in a boattail’s wake). The readings run through a flight’s path and are fitted at the tunnel’s plotted angles as Checking the shock-expansion method fits them. They sit beside the secant ogive fitted to the same nose:
| model | Mach | measured, per rad | committed nose, per rad | vs measured | fitted ogive, per rad | vs measured | cap to radius ratio |
|---|---|---|---|---|---|---|---|
| short | 1.5 | 2.192 | 3.007 | +37.2% | 3.090 | +41.0% | 0.163 |
| short | 1.8 | 2.613 | 3.289 | +25.9% | 3.312 | +26.8% | 0.070 |
| short | 2.3 | 3.078 | 3.597 | +16.9% | 3.651 | +18.6% | 0.045 |
| short | 2.96 | 3.284 | 3.837 | +16.8% | 3.936 | +19.8% | 0.045 |
| short | 3.96 | 3.884 | 3.944 | +1.5% | 4.168 | +7.3% | 0.045 |
| short | 4.63 | 4.149 | 3.948 | −4.8% | 4.288 | +3.4% | 0.045 |
| long | 1.8 | 3.159 | 3.769 | +19.3% | 3.792 | +20.0% | 0.070 |
| long | 2.3 | 3.525 | 4.070 | +15.4% | 4.124 | +17.0% | 0.045 |
| long | 2.96 | 3.868 | 4.398 | +13.7% | 4.497 | +16.3% | 0.045 |
| long | 3.96 | 4.455 | 4.426 | −0.7% | 4.655 | +4.5% | 0.045 |
| long | 4.63 | 4.615 | 4.424 | −4.1% | 4.777 | +3.5% | 0.045 |
The rows are in
validation/fixtures/aero/blunt-tips.json,
written by cargo xtask aero; the readings in
tn-d-4865-sphere-cone.json.
A test holds these tables to the fixture, cell by cell. The committed nose reads within 3.8
points of the fitted ogive up to Mach 2.96 and 5.1 to 8.2 points below it past Mach 3. Below it is not always closer: past Mach 4 its error changes sign. So at Mach 4.63 it reads −4.8% where the
ogive reads +3.4%, 1.5 points further from the tunnel. Below Mach 3 both read high, most at Mach 1.5, for
the reasons in Checking the shock-expansion method.
What the cap is worth
A nose with a blunt or vertical tip flies Newtonian pressures over the tip. It hands the rest of the body to the shock-expansion method where the surface’s slope falls far enough, the handover (Blunt tips above). That handover is never steeper than a cap, 24°. Nothing here changes what a rocket flies: the cap is where it was, and no committed number moved.
The cap could move because the cone slopes the method reads now reach 30° (ADR-042),
where they once stopped at 24°. Moving it would follow the report’s own rule further. The wedge’s largest deflection passes 24° at Mach 2.06 and 30° at Mach 2.52. So a 30° cap keeps TN D-4865’s
([J68]’s) rule over that whole band, where 24° cuts it short from Mach 2.06 up. Where a cap binds at
all, going all the way to 30° reads nearer the report’s own sphere-cone at every row. Not every step along the way reads nearer, though. And on the Arcas Robin’s committed nose it breaks the march above Mach 4. The march steps the method element by element down the body from the handover. HPR Sim keeps 24° until that is settled (ADR-043). The cap is a parameter of the method rather than a
constant to argue over
(with_handover_cap_rad).
Each cap starts to bind at its own speed (Mach 2.06, 2.19, 2.34 and 2.52), and below that it costs nothing. The fit is the one in How it was checked. It uses HPR Sim’s at the tunnel’s plotted 0° to 12°, body lift included, fitted with a straight line. HPR Sim’s error against TN D-4865’s sphere-cone under four caps:
| Mach | error at 24°, as flown | at 26° | at 28° | at 30° |
|---|---|---|---|---|
| 1.5 | −1.2% | −1.2% | −1.2% | −1.2% |
| 1.9 | +0.0% | +0.0% | +0.0% | +0.0% |
| 2.3 | +7.5% | +7.3% | +7.1% | +7.1% |
| 2.96 | +12.5% | +12.2% | +11.9% | +11.5% |
| 3.95 | +29.7% | +28.9% | +28.3% | +28.0% |
| 4.63 | +32.1% | +31.2% | +30.9% | +31.3% |
Below Mach 2.06 no cap binds, which is why the first two rows are one reading four times. At Mach 2.3 only 24° and 26° bind, so the last two columns agree. Read the first two binding rows with care for another reason. The cone slopes are tabulated from Mach 3 up and held at that row below it (Bodies faster than sound). So at Mach 2.3 and 2.96 a steeper cap’s gain is read off a slope that is not itself a function of Mach there. Where a cap does bind, the whole step from 24° to 30° reads nearer the tunnel by 0.4 to 1.7 points, most at Mach 3.95. The one place a steeper cap reads further out is the last step at Mach 4.63, where 28° reads +30.9% and 30° +31.3%.
Now the cost, told by two counts. A reduced element is one where the method’s
exponential law would run the wrong way. The pressure behind the corner then heads away from the tangent cone’s instead of toward it, in the method’s own terms
([SD56] p. 13). So HPR Sim holds the pressure along it instead,
issue #81’s open question. A crossing is the rarer and worse thing. It is the marched surface pressure passing through its own tangent cone’s, either
way, within one part of the body. Where a nose meets a cylinder, a boattail or a flare the cone’s own pressure steps. That is not the same thing and is not counted. Both counts are per march, not
per element.
What a crossing is, and what it costs says how they
differ and how far either one can be trusted
(tangent_cone_crossings).
Here are two of the four caps on the Arcas Robin’s committed power-series nose and the short
model’s cylinder, nothing aft. The values are per radian on its cross-section at , read with the flown 10 elements per curve and with 160:
| Mach | 24° cap, 10 elements, per rad | 24°, 160 | 30°, 10 elements | 30°, 160 |
|---|---|---|---|---|
| 1.5 | 2.531 | 2.532 | 2.531 | 2.532 |
| 1.8 | 2.697 | 2.702 | 2.697 | 2.702 |
| 2.3 | 2.873 | 2.881 | 2.851 | 2.862 |
| 2.96 | 3.021 | 3.029 | 2.943 | 2.955 |
| 3.5 | 3.071 | 3.079 | 2.953 | 2.964 |
| 3.96 | 3.073 | 3.080 (1 of 160 reduced) | 2.919 | 2.927 (1 of 160 reduced) |
| 4.63 | 3.030 | 3.034 (2 of 160 reduced) | 3.047 (5 of 10 reduced, 2 crossings) | 3.260 (109 of 160 reduced, 2 crossings) |
| 5 | 2.980 | 2.984 (2 of 160 reduced) | 3.400 (9 of 10 reduced, 1 crossing) | 3.454 (145 of 160 reduced, 1 crossing) |
Through Mach 3.96, cutting the nose into sixteen times as many elements moves the answer by under 0.01 per radian under the flown cap. Under the 30° cap it moves by under 0.013. So the answer is the model’s, not the mesh’s. Above Mach 3.96 the 30° cap’s march crosses its tangent cone, twice at Mach 4.63 and once at Mach 5. It reduces most of the nose too: 5 of 10 elements at Mach 4.63 and 9 of 10 at Mach 5. The 10-element counts are what HPR Sim would fly; at 160 they are 109 and 145. The answer follows the element count instead, and not even in order. It is 3.047 at 10 elements, 2.928 at the 40 the fixture also holds, and 3.260 at 160. That is a spread of 0.33 per radian, 11%, where the flown cap moves by 0.1%. The crossing is the cause and the reductions travel with it, which the next section takes apart.
What a crossing is, and what it costs
Here is the surface pressure just behind a corner and its tangent cone’s. is the lift per unit length (the loading) and the tangent cone’s. All are as the method’s equations define them.
The steeper cap starts the march from a steeper cone at a higher pressure. From there the tangent cone’s own pressure falls away faster than the marched pressure does as the nose flattens. So the surface pressure catches its tangent cone’s and passes through it. At Mach 4.63 under the 30° cap, that is about a tenth of the way back. The surface pressure stays above the cone’s until the nose flattens enough for the cone to catch up again. That is two crossings: one out, one back.
Why that hurts has nothing to do with . Write the exponent in as , so that
is a relaxation rate per meter: the gradient just behind the corner divided by how far the pressure has to go. A crossing closes that gap while the gradient carries on, so has a pole: it runs to infinity. The pressure itself doesn’t mind, because is only the gradient again, and that stays finite. The loading does mind, because it relaxes toward at the same ([SD56] eq. 19). Its own gap is set by something else entirely.
Follow that gap through the Mach 4.63 march under the 30° cap. Between the two crossings nearly
every element is reduced, so its loading is held where it was and never relaxes. By the second crossing stands about a quarter above . The element at that second crossing is back inside the method. How much of that quarter it sheds in its own length is whatever
happens to be for the step the mesh gave it. On the 40-element march it sheds 98% of
the gap in one step; on the 160-element march, 12%. That is the answer moving with the mesh, in one
number (test a_crossing_is_a_pole_in_the_rate_the_march_relaxes_at).
The counts say the same thing over the whole sweep. Of its thirty-two readings (four caps at eight Mach numbers on this one nose), twenty-seven never cross and five do:
| readings | most the answer moves over 10 → 160 elements | |
|---|---|---|
| no crossing | 27 | 0.012 per radian |
| a crossing | 5 | at least 0.035, up to 0.69 |
No overlap, and nearly three times (2.9×) between the two groups. The five are 30° and 28° at Mach
4.63 and 5, and 26° at Mach 5 (fixture
blunt-tips.json,
test over_the_sweeps_meshes_a_crossing_separates_the_readings_that_move).
A crossing is a flag, not a verdict, and it has to be read carefully. Three limits, all measured:
- A crossing does not prove an answer never settles. 28° at Mach 5 crosses at every mesh, and
its 0.69 spread is all in the coarse end. From 60 elements to 640 it holds to 0.005 per radian,
tighter than the worst reading in the sweep that never crosses. Compare 30° at Mach 4.63, which
moves by more than 0.2 per radian over that same range. The sweep shows that across its three meshes the crossings and only the crossings mark the readings that move (test
a_crossing_says_the_answer_moved_not_that_it_never_settles). - A count of zero does not prove one settled. Whether a crossing is seen depends on the mesh. 26° at Mach 5 and 28° at Mach 4.63 show none at the flown ten elements per curve. They show two at forty and a hundred and sixty, and both move. Read zero as “not proven”.
- HPR Sim does not count crossings while it flies, and everything here is one nose. The count is a tool for studying a body, not a guard. Another blunt nose above Mach 4 could cross under the flown 24° cap without saying so.
Reduced elements, on their own, do not move an answer. TN 3527’s own fineness-3 ogive reduces 27 of
160 elements at Mach 5.05 and 50 of 160 at Mach 6.28. Its answer settles to 0.002 per radian
from 10 elements to 160. There comes from the gradient changing sign, with the surface
pressure below its tangent cone’s the whole way down. The gap never closes, so there is no pole.
That ogive never crosses at either Mach number where it can be checked against the report. This is why the report could state its condition ([SD56] p. 13) and stop: it never had to say what a crossing
does (test a_reduced_element_settles_where_tn3527s_own_bodies_never_cross).
The two questions are tangled, though. The quarter-wide loading gap the second crossing sheds was opened by the reduced stretch behind it. That reduction is HPR Sim’s reading, not the report’s rule. So a different reading of would change the size of the step as well, and neither question can be judged without the other. What has changed is that the step itself is taken by an element the method still owns. So a rule for alone is not obviously enough.
The disorder under the steeper cap is not rounding. Nudge the Mach number by eight units in its last place (about a part in ) and the same elements reduce. The answer follows to a part in a billion (test a_steeper_handover_moves_the_march_out_of_its_range).
The break is not at 30°, and it is not orderly. It sits between the flown cap and the next step, and 28° is the worst of the four. At Mach 5 its answer moves 0.69 per radian over the element count, twelve times the 30° cap’s 0.055. No cap above the flown one holds its answer to Mach 5:
| cap | Mach 4.63, 10 elements | 160 elements | Mach 5, 10 elements | 160 elements |
|---|---|---|---|---|
| 24°, as flown | 3.030 | 3.034 (2 of 160 reduced) | 2.980 | 2.984 (2 of 160 reduced) |
| 26° | 2.961 | 2.965 (2 of 160 reduced) | 2.900 | 2.946 (40 of 160 reduced, 2 crossings) |
| 28° | 2.892 | 2.926 (33 of 160 reduced, 2 crossings) | 2.923 (4 of 10 reduced, 2 crossings) | 3.612 (140 of 160 reduced, 1 crossing) |
| 30° | 3.047 (5 of 10 reduced, 2 crossings) | 3.260 (109 of 160 reduced, 2 crossings) | 3.400 (9 of 10 reduced, 1 crossing) | 3.454 (145 of 160 reduced, 1 crossing) |
Below Mach 4 the four agree to 0.013 per radian, so nothing here says a cap between the two ends is a middle ground.
Settled is not the same as right. Under the flown cap HPR Sim still reads +29.7% and +32.1% against the sphere-cone at Mach 3.95 and 4.63, as the first table says. The cap chooses between an answer that is high and one that is high and moves with the mesh.
So the cap HPR Sim flies is set by the march’s range rather than by a chart’s edge. It moves when
the method has a rule for what the loading does where the surface pressure crosses its tangent cone’s. Such a rule is one whose answer stops changing as the nose is cut finer. It is judged together with the reading of that sets the gap it sheds. TN 3527 does not state either, because its own bodies never cross. So this is a modeling decision rather than a measurement to look up (issue #108: a steeper handover crosses the tangent cone above Mach
4). The milestone that would then move the
cap, M1.8e16, the blunt tip’s handover past 24°, waits on that (ADR-044 records the measurement behind this section). Both are deferred
as beyond the operating envelope, since the crossing bites above Mach 4. The vertical-tip switch’s error below that is part of
M1.14d: supersonic accuracy, and of
M1.14h: the extended band above Mach 2.5
(ADR-143).
All three tables are held to
blunt-tips.json
by a test, cell by cell. The second shows the two ends of the sweep, and the fixture holds 26° and
28° and a 40-element reading too. Its numbers are stored to six decimals, three more than the tables quote. Where most of the nose is reduced the march is not reproducible past about 1e-11 from one machine’s maths library to another’s. So pinning more would only break the build
(ADR-043).
The two starts
HPR Sim starts the march from the tangent cone at the handover, the report from the Newtonian
pressure there. Read at a small angle, the report’s start fails on
the Arcas Robin’s nose from Mach 3.96. There the march reduces the element at the nose’s end on the cylinder behind it (holding its pressure). The cylinder’s tangent cone is the free stream rather than a cone of its own. HPR Sim therefore refuses a reduced element there (issue #123: a cylinder’s or a boattail’s reduced element). From Mach 2.96 the answer from the report’s start drifts as the nose is cut into more elements. The reason is the same (issue #81, the method’s open question there). A flight’s table is built from Mach 5
down, so that failure would leave such a rocket no method at all. The tangent cone’s start holds to Mach 5 and settles. The Arcas nose moves under 0.01 per radian from 10 elements to 40. A five-caliber elliptical or von Kármán nose moves under 0.02 from 10 to 160. On the report’s sphere-cone, against the
measured slope at , the report’s start reads closer than HPR Sim’s at Mach 1.9, 3.95 and
4.63. It reads about the same at 2.96 and further at 2.3, and 95% high at Mach 1.5. That last is HPR Sim’s
reading of the report’s start at , not the report’s method, which reads 1.844 there at its own angles. The two differ because the handover sits 0.6° above the cone, so its linear range is that small. HPR Sim
takes the start that holds and settles everywhere over one that fits one body better where it
holds. Both are kept:
HandoverStart selects the report’s
for comparison (ADR-038). Slopes per radian on the body’s cross-section, at , for
the committed nose and the short model’s cylinder, nothing aft:
| Mach | the tangent cone’s start, 10 elements, per rad | 40 elements | the report’s start, 10 elements | 40 elements |
|---|---|---|---|---|
| 1.5 | 2.531 | 2.532 | 2.866 | 2.770 |
| 1.8 | 2.697 | 2.701 | 2.676 | 2.635 |
| 2.3 | 2.873 | 2.880 | 2.641 | 2.635 |
| 2.96 | 3.021 | 3.028 | 2.544 | 2.583 (6 of 40 reduced) |
| 3.5 | 3.071 | 3.078 | 3.361 (9 of 10 reduced) | 3.418 (39 of 40 reduced) |
| 3.96 | 3.073 | 3.080 | fails | fails |
| 4.63 | 3.030 | 3.031 (1 of 40 reduced) | fails | fails |
| 5 | 2.980 | 2.982 (1 of 40 reduced) | fails | fails |
What it means for a rocket. Mostly more force, barely any change of balance. Calisto’s von Kármán nose now takes the method past Mach 1.2. On Calisto the whole rocket’s normal-force slope rises 17% to 31% from Mach 1.5 to 2 (Normal force through Mach 1). The rocket’s center of pressure moves by under 0.15 calibers (forward at Mach 1.5, aft at Mach 2). So the stability margin moves by under a sixth of a caliber. The force that holds the rocket into the wind grows by about a quarter.
What it leaves out.
- No measurement checks a tip that isn’t spherical. The report tested spherical caps only. Newtonian theory on the cap and the tangent cone’s start are both approximations, and the method’s reduced elements (issue #81) still apply behind them.
- A cap that shrinks to nothing doesn’t reach the cone it sits on (issue #101). The march carries its start cone’s total pressure the whole way, as the method does from any vertex. Nothing makes that fade as the cap shrinks. A power-series nose of is a 7.1° cone but for a tip 1e-55 calibers across. Yet at Mach 4 its cylinder carries 1.21 per radian where the cone’s carries 1.37, 12% less. This is because the march runs on the 24° cone’s total pressure rather than the 7.1° cone’s. The shapes a rocket uses have caps that are small but not vanishing. At Mach 1.5 the table above puts their ends at 0.12 to 0.76 of the base radius, where that nose’s is 1e-55. How much of this bias they carry is unknown.
- At the handover is held where it sits on the body, as TN 3527 holds every other point. The report’s equivalent bodies turn the body about the sphere’s center, which slides the handover along the surface instead; HPR Sim leaves that term out. How much it is worth is not measured here. The two starts in the tables above differ by more than it alone, since their pressure and total pressure differ too. That is 2.53 against 2.87 per radian on the Arcas nose at Mach 1.5, and 1.70 against 1.70 on the sphere-cone at Mach 2.96.
- Two switches in shape, of the family issue #87 tracks. A vertical-tip nose steeper than the cap’s handover all the way to its base gets no method at all. A pointed tip steeper than the cone tables’ 30° is refused where a vertical one flies. The pointed tip’s edge was Fig. 2’s 24° until M1.8e11. The vertical tip’s edge is the handover’s cap, which stands at 24° for the reason above. Moving the cap waits on issue #108: a steeper handover puts the march into above Mach 4, which is deferred. The switch’s error itself is part of M1.14d: supersonic accuracy (and of M1.14h above Mach 2.5).
- Elements that merge, merge with Mach. Behind the cap, a tangency point whose tangent turns by under a microradian is folded into the element before it. This is because its corner can’t be placed in floating point. Which points merge changes with the handover, so the method’s answer takes a step of about a millionth of a per-radian slope as it does. That step is far below anything measured here, but there.
- Drag is unchanged: the nose’s wave drag already covers blunt shapes (Drag through Mach 1).
Fins, pods and overrides
The normal force of fin sets, pods and tube fins, and how a flight can take RASAero II’s normal force instead of HPR Sim’s own.
Fins
A fin set is identical fins spaced evenly around a body tube. For one fin of the set:
| symbol | meaning | unit |
|---|---|---|
| span: the fin’s height from the body surface to its tip | m | |
| height above the root, from 0 to | m | |
| , , | chord: the fin’s length along the airflow at height ; at the root and at the tip | m |
| , | how far the leading edge sits aft of the root’s leading edge, at height ; at the tip (the sweep length) | m |
| one fin’s area, one side (written inside the integrals) | m² | |
| the mid-chord sweep: the angle by which the line joining the chords’ midpoints leans aft from square to the body | rad | |
| the Prandtl-Glauert factor , the classic correction for the air’s compressibility below Mach 1: 1 at rest, falling to 0 at Mach 1 | none | |
| , , | the mean aerodynamic chord (MAC), an average chord that weights long chords more; its height; and its leading edge, aft of the root’s | m |
| the fin set’s CP, aft of the root leading edge | m | |
| the angle between fin and the direction the air crosses in (set by the flow roll ) | rad | |
| the fin-count factor, for five to eight fins | none | |
| the body tube’s radius at the fins | m | |
| the interference factor: how much the body raises the fins’ normal force | none |
One fin ([B67] eq. 3-4–3-6, [N09] eq. 3.38–3.40):
The mean aerodynamic chord (MAC; [N09] eq. 3.30–3.32):
The CP, aft of the root leading edge ([B66] eq. 76a, [N09] eq. 3.34):
fins ([N09] eq. 3.51–3.53, [TD] eq. 3.54):
The interference ([B66] eq. 77, [N09] eq. 3.56):
-
Trapezoids. , and the closed forms give [B66] eq. 57 and 76a exactly.
-
Ellipses on the root chord. , , and
Loft replaced the ellipse with an equal-area trapezoid, whose sweep made the slope 1.3% low (Loft lesson L10).
-
Freeform outlines. runs from the leading edge to the trailing edge. So a jagged edge’s gap counts toward the CP but not toward ([N09] pp. 27–28). is the span average of the mid-chord angle ([N09] p. 29), which gives the natural angle for trapezoids and ellipses. The integrals are exact. Between vertex heights the edges are straight, and a three-point Gauss rule per band (quadrature, a weighted sum of samples) is exact. Bands thinner than 1e-12 of the span (vertex heights a few rounding steps apart, as when a tip is converted from inches) are skipped.
-
A root along a nose cone or a transition (ADR-166, fins on a nose cone). There the root (where the fin meets the body) follows the curved surface. Its points are part of the fin’s outline. So , and the CP are those of the region between the outline and the surface. Heights run from the surface at the root’s leading edge. The body radius in the interference factor above is the radius there. No measured fin on a nose cone checks the model; against OpenRocket, the one example is the cockpit of Pods--airframes and winglets:
- Across the airflow at Mach 0.3, its normal-force slope is 0.2784 per radian in HPR Sim and 0.2117 in OpenRocket, 31.5% more. The CPs there are 0.13 mm (0.0051 in) apart. Closed straight along its chord, HPR Sim’s would be 0.2802, so the curved root isn’t the cause (#326).
- OpenRocket takes its margin with the air crossing at 0° roll. There the single fin lies in the airflow’s plane, and neither code counts it. HPR Sim’s margin is the weakest direction’s since #329 (Stability margin).
- Above Mach 1, the tip-cone correction still mirrors the flow at a level line through the root’s leading edge, an approximation on a rising root.
-
Prandtl-Glauert enters through in the fin slope only, up to Mach 0.8. The CP stays at the quarter chord, a quarter of the way along the MAC, through that range ([B67] p. 6). Past Mach 0.8 the fins follow Fins through Mach 1, below.
-
Fin count. A fin at angle to the lateral airflow adds in the plane of the flow. The sum is for three or more evenly spaced fins, at any roll. For one or two fins it changes with the direction the air crosses. So the margin differs with direction. HPR Sim reports the weakest (Stability margin). is 1 up to four fins, then 0.948, 0.913, 0.854 and 0.810 for five to eight ([TD] eq. 3.54). Those factors make six and eight fins 1.37 and 1.62 times four ([762] p. 5-24), and interpolate five and seven (Loft lesson L8). More than eight fins are refused: [TD]’s 0.750 has no data behind it. [N09]’s roll-dependent 15% and 6% reductions for three and four fins were dropped in [TD].
-
Side force of one- and two-fin sets. Each fin sees ([N09] eq. 3.50) and pushes along its own normal. Eq. 3.51 keeps the in-plane share . The share across the plane is , which cancels for three or more fins but not for one or two. [N09] pp. 31–32 drops it, arguing that it cancels for two or more fins; for two fins the pushes add. HPR Sim reports it as at the fins’ CP (derived here from eq. 3.50, not taken from a source).
-
Interference is Barrowman’s straight-line fit to NACA TR-1307, justified for ([B66] p. 36).
-
Not modeled.
- The body lift the fins induce, ([B66] p. 36 neglects it; [B67] eq. 3-98 has it).
- The roll moment of a single fin’s normal force at an angle of attack: its force acts at along the fin’s normal. Two or more even fins cancel it; one fin doesn’t. Roll from cant and against the roll rate is modeled (Roll: forcing and damping).
- Interference between fin sets at the same station.
- Damping coefficients for pitch and yaw. They would replace the local-flow damping below, not
add to it, or it would be counted twice; HPR Sim keeps the local flow:
- In a flight, pitch and yaw damping come only from evaluating each component in its own local flow. That flow includes the speed the rocket’s rotation adds there (Rigid-body flight).
- Only components with a slope give it: nose cones, transitions and fin sets. A boattail’s slope is negative, so it takes some away.
- Body tubes give none at small angles. Their own slope is 0, and their body lift grows with , so it adds nothing there.
- Tube fins, which have their own section (Tube fins). Any part kind the model doesn’t know is refused. Pods have their own section (Pods).
- Launch lugs and rail buttons add drag only.
Fins through Mach 1
Faster than sound, air can’t flow around a fin’s edges ahead of it. The fin’s lift comes from the pressure behind the shock and expansion waves at its surfaces, and a different theory applies. HPR Sim uses Barrowman’s subsonic method to Mach 0.8, supersonic linear theory from where that theory holds, and a straight-line join between them. Below Mach 1.2 the body terms don’t change with Mach: slender-body theory’s slope and CP hold at any speed ([B67] p. 18). Past it, a body that takes the shock-expansion method gains lift with Mach (The body faster than sound in a flight). How well this agrees with a wind tunnel and with RASAero II is under Verification.
Supersonic linear theory. Past Mach 1, is redefined as , which grows from 0 as the speed passes that of sound. At a small angle to a supersonic flow, a thin flat plate has the pressure coefficient on the side facing the flow. The other side has . Both are the first term of Barrowman’s pressure series ([B67] appendix A, p. 82). So every part of the fin carries the same load, per unit area. Each strip (a narrow slice of the fin along the airflow) carries it at its middle. MIL-HDBK-762 finds linearized theory accurate for the supersonic stability of thin fins ([762] p. 5-15). Two things change the load near the tip:
- The tip’s Mach cone. The tip disturbs the flow only inside the cone that spreads inboard from its leading edge at the Mach angle, . Barrowman halves the load inside it ([B67] appendix A, p. 84). For a rectangular tip that is exactly linear theory’s loss.
- The body as a mirror. At the root the body stands in for the fin’s mirror image. A cone that reaches the root continues into the mirror image. The part of it there counts too, as the mirror fin’s cone crossing onto this one.
One fin ([B67] appendix A):
The CP, aft of the root leading edge, is the centroid of that load: the fin’s area centroid, less half the cone’s ([B67] appendix A). A rectangle, , in exact linear theory ([TN2114], [N09] eq. 3.35):
is the part of the fin (and of its mirror image) inside the tip’s Mach cone. The fin-count factor, the sum over fins and apply as above.
Where it starts. Linear theory’s strips need four things, so it starts at
where and are the leading- and trailing-edge sweeps and is the tip chord. is the aspect ratio of the fin and its mirror image:
- Mach 1.2, the bottom of the supersonic region ([N09] Table 3.1, p. 19);
- supersonic edges, each with its Mach number square to the edge, , past 1, the case [TN2114] covers;
- , where linear theory’s tip loss holds; a rectangle’s slope peaks there, at ;
- , so the mirror fin’s tip cone stays off this fin’s tip, which matters for a tip chord longer than the fin’s average.
Calisto’s and the Arcas Robin’s fins start at their leading edge’s 1.2806 and at 1.2.
The transonic join. From Mach 0.8 to , the slope and the CP are each a straight line in between their values at the two ends. No source gives this region in closed form. MIL-HDBK-762 reads it from charts of transonic similarity (the way thickness and Mach number combine near Mach 1, [762] pp. 5-104–5-105). The join keeps both continuous. For most fins the slope peaks at (a leading edge swept forward can make it fall across the join instead). For most fins the CP also moves aft from the quarter chord toward the middle of the chord.
Worked example. Calisto’s 2018 fins: root chord 0.12 m (0.39 ft), tip chord 0.04 m (0.13 ft), span 0.10 m (0.33 ft). The sweep length is 0.08 m (0.26 ft). The example uses (). The leading edge is swept 38.66°, so . At Mach 2, . The tip cone is a triangle 0.04 m (0.13 ft) along the tip and down the unswept trailing edge. Its area is 0.000462 m², 5.8% of the fin’s 0.008 m². So, per rad,
HPR Sim gives, per fin:
| Mach | slope , per rad | CP aft of the root leading edge, m |
|---|---|---|
| 0 | 1.853 | 0.0550 |
| 0.8 | 2.170 | 0.0550 |
| 1.0 | 2.499 | 0.0632 |
| 1.2806 | 2.960 | 0.0747 |
| 1.5 | 2.158 | 0.0753 |
| 2.0 | 1.416 | 0.0758 |
| 3.0 | 0.877 | 0.0761 |
What it leaves out.
- Thickness. Linear theory is for thin plates; a thick fin or a blunt leading edge detaches the bow shock near Mach 1.
- Exact linear theory for a tapered fin. The strip method’s constant load outside the tip cone runs above it. Against [TN2114] eq. A7 (printed p. 18), a fin with a taper ratio of 0.5, an unswept trailing edge and gets 4.5% more slope.
- Subsonic leading and trailing edges, which the join covers without a method of its own. A curved edge counts by its span-averaged sweep. So an elliptical fin, whose edge is swept 90° at the tip, keeps a subsonic stretch past . So does a freeform fin with a raked outboard edge.
- Leading edges swept forward. The tip then sits ahead of the root, and its Mach cone covers much of the fin. There the half-load overstates the loss, so the slope rises past instead of falling. The rise is up to +7.7% for fins swept 40° to 50° forward, peaking up to 0.37 Mach later (issue #64). Such fins are rare on rockets. A property test covers every trapezoid whose leading edge is straight or swept aft (to 65°), tapered either way. Each is held to a slope that falls with Mach from .
- The fins’ lift carried onto the body behind them, , as below Mach 1.
Other choices, and why not.
- Niskanen’s supersonic slope ([N09] eq. 3.48–3.49) multiplies the fin’s area by one strip’s pressure coefficient, with : the pressure on one face. A plate is pushed by the difference between its faces, twice that. His thesis finds its simulated for the Arcas Robin “notably lower than the experimental values” (p. 91). The cause is unknown, and the comparison runs to Mach 4. HPR Sim counts both faces.
- RocketPy 1.13.0 flies Diederich’s subsonic slope at every Mach number, with held at 0.6 from Mach 0.8 to 1.1. Past Mach 1 that tends to , about times linear theory’s . Its fin CP doesn’t move with Mach.
- Tuning the join to the wind tunnel below would shrink its misses by fitting the model to its own check. The join’s ends come from the sources’ speed regions, set before measuring.
Roll: forcing and damping
Fins set at a small angle to the rocket’s axis, cant, each push sideways as a wing at that angle would. Each push acts off the axis, so together they twist the rocket and spin it up: the roll forcing. Once the rocket rolls, each fin also moves sideways through the air and meets it at an angle of its own. The fin pushes back against the spin: the roll damping. The two balance at a steady roll rate. HPR Sim takes both from Barrowman’s thesis ([B67] §3.13–3.14, appendix A), by strip theory. Each narrow strip of a fin, running with the flow, lifts in proportion to the angle it meets the air at.
Below Mach 1.5 only two committed checks apply: the flight’s agreement with the closed-form balance and Barrowman’s own computed damping at Mach 0.07. Measured sets there, not yet committed, put the damping 24.5% to 200% high, most near Mach 1.1 (research note, §3). Strips that each lift at the fin’s average slope ignore how the flow at one strip changes the next. For short fins that likely overstates the damping, so a subsonic spin may read low.
Other symbols follow Fins: the body’s radius at the fins, the span, and the root and tip chords. is one fin’s area and the mean aerodynamic chord’s distance from the root.
| Symbol | Meaning | Unit |
|---|---|---|
| cant: the angle each fin is turned about its own span, positive turning fin 0’s (the fin along ) leading edge toward (Mass properties) | rad | |
| roll rate about (Frames) | rad/s | |
| a strip’s distance from the rocket’s axis, | m | |
| rolling moment about over , with the reference diameter | none | |
| one fin’s rolling moment per radian of cant, in the sense its lift turns the rocket | per rad | |
| one fin’s rolling moment per unit of : the damping, negative | none | |
| the whole rocket’s rolling moment from cant at no roll rate | none | |
| , | the body’s effect on the forcing and on the damping | none |
The moment. A fin set of fins adds
The minus sign is the cant’s direction. A positive cant turns fin 0’s leading edge toward , so its lift pushes toward . That turns the rocket about (a negative ), clockwise seen from ahead of the nose, looking aft. Its first term, summed over the sets, is . In flight the cant’s forcing is scaled by . The cant meets the air as it runs along the axis. So there is none broadside, and it reverses tail first, as the fins’ normal force follows (Rigid-body flight). Bodies of revolution add nothing, and fin-fin interference is left out, as in [N09] eq. 3.66.
Below Mach 0.8. The cant is an angle of attack for each fin, so its lift is the fin’s own normal force. It acts at its mean aerodynamic chord: ([B67] eq. 3-35, [N09] eq. 3.66). For the damping, a strip at meets the air at . The strip lifts by the fin’s slope per unit of its area, : ([B67] eq. 3-40–3-49, [N09] eq. 3.67–3.70). For a trapezoid
for any outline HPR Sim takes it from the polygon.
From , where supersonic linear theory starts (Fins through Mach 1), each strip carries the load , halved inside the tip’s Mach cone:
with ([B67] appendix A, first order). Between Mach 0.8 and each is a straight line in , as the fin’s slope is.
The body. The body reshapes the flow the fins meet. Barrowman’s factors from slender-body theory ([B67] eq. 3-95 with 3-105, and 3-123 with 3-122) use . They scale the forcing by , 0.940 at , and the damping by , 1.33 at for a rectangular fin. Both are 1 without a body. [N09] leaves both out. is for a chord that falls linearly from root to tip. Another outline takes it at its tip-to-root chord ratio. So an elliptical fin is taken as a triangle, about 5.5% too much damping.
The steady roll rate is where the two cancel: . Below Mach 0.8 the fin’s slope cancels between them, and for one fin set
It grows with the airspeed and the cant, and not with the air’s density or the number of fins.
A worked example: Valetudo with its fins canted 1°. Valetudo, one of RocketPy’s example rockets, has three fins on a body of radius 40.45 mm (1.6 in). Each has root chord 58 mm (2.3 in), tip chord 18 mm (0.71 in) and span 77 mm (3.0 in). One fin has , , , and , so and . At 100 m/s (328 ft/s),
2.7 turns a second. With no drag and no gravity, HPR Sim’s flight settles on it within 1e-6 (1e-11 measured). It spins up with a time constant of 0.48 s (canted_fins_spin_to_the_analytic_balance). That test also checks this example’s rate and time constant.
Why these choices:
- The fin’s own slope in the damping. Barrowman’s text writes the airfoil’s slope there
(eq. 3-40, ), as does [N09] eq. 3.69. His own computed curve for the Basic Finner reads
−34.21 at Mach 0.07 (Fig. 5-7). That is the fin’s slope spread over its strips, −33.53 (
the_basic_finner_damps_as_barrowman_computed). The airfoil’s gives about −81, 2.4 times as hard. His curve’s rise toward Mach 1, about 20% read from the figure, follows the fin’s slope too, where the airfoil’s would grow without bound. Stubby fins lift far less than an airfoil. - The body factors. Barrowman has them and [N09] doesn’t. For the Arcas Robin’s fins they lower the forcing 6.5% and raise the damping 20%. His is a ratio of forces (eq. 3-116, 3-120) applied to a moment (eq. 3-123). Weighted by the moment it would be 3.4% to 4.2% smaller for the fins here. HPR Sim keeps his, which his computed curve seems to use too. is reference 23’s factor for fins turned together; for cant, whose load turns the other way on the opposite fin, it isn’t derived.
- Moments about the body’s axis. Faster than sound Barrowman’s appendix A takes each strip’s moment about the fin’s root. HPR Sim takes it about the axis, , as his subsonic eq. 3-27 and 3-35 do. About the root the Arcas Robin’s forcing would be about half. Its load sits 25 mm (0.98 in) from the root and 53 mm (2.1 in) from the axis.
- Limits on the input. HPR Sim refuses a cant beyond 15°, where a fin stalls and the linear model means nothing. It also refuses a cant on a single fin, whose sideways push it doesn’t carry.
- Pitch and yaw keep the local-flow damping. A flight’s pitch and yaw damping come from each part’s own local flow (ADR-011); coefficients would count it twice.
- No target was set for the comparisons. The roadmap asked for the forcing to be compared with the measured roll effectiveness, and set no bar. The numbers are reported as they are (ADR-031).
What it leaves out:
- The roll forcing near Mach 1.5 reads high: linear theory’s load rises as toward Mach 1, and the Arcas Robin’s measured forcing doesn’t. Barrowman found the same for the Tomahawk sounding rocket (“the theoretical value at is no good”, [B67] p. 66).
- The damping reads high faster than sound, most near Mach 1.5 (+27.5% against NOL’s wind tunnel). Near Mach 1.5 the likely cause (an inference, not shown) is that linear theory’s load rises as toward Mach 1 faster than the fins’ does, as the forcing does. The fins’ thickness, 8% of the diameter, is unlikely to be the cause: what evidence there is says a thickness term would raise the damping.
- No committed measurement checks roll below Mach 1.5. Measured sets there put the damping 24.5% to 200% high (research note, §3); #1033 adds one at Mach 0.22.
- A fast spin at low airspeed meets the fins at angles past stall, where the linear damping no longer holds. Valetudo spinning at 17 rad/s at 5 m/s (16 ft/s) meets the air 23° off at its fin tips.
- The angle of attack: the measured roll effectiveness changes by up to 13% between 0° and ±4° (TN D-4014 Fig. 14). HPR Sim’s is the same at every angle. A single fin’s roll from its normal force, the body’s own roll, and fins’ airfoil sections are not modeled.
Pods
A pod is a body beside the airframe: a side pod, or an outboard motor pod (the design page’s Pods). HPR Sim gives each pod the forces its parts would have on the airframe, once per pod, and adds them to the airframe’s. No measured flight checks it. The formulas are checked against hand-worked numbers. They are also checked against OpenRocket 24.12 on six probe designs, small designs written only to test pods (pod designs against OpenRocket). Five carry pods of bodies, fins, a tail cone, winglets or motors, and one is the same airframe without pods. Below Mach 0.81, HPR Sim’s apogee is within 0.92% of OpenRocket’s, and its stability margin within 0.0014 calibers. What the pods change agrees to 0.32 percentage points of apogee (table below). That shows the two codes compute the same thing, not that either is right. Both leave out how the pods and the body disturb each other’s flow, whose size is given below. Faster than sound a pod keeps slender-body theory’s slope, which nothing checks.
The rule. A pod’s nose cones, transitions and tubes are Barrowman’s bodies, as on the airframe ([B67] eq. 3-65, [N09] eq. 3.19). A part whose cross-section grows from to has the slope , on the rocket’s reference area . Bodies of revolution gives its center of pressure. Each pod adds that once:
- Normal force. pods add times one pod’s slope and moment, at the part’s station along the rocket. The pod’s first part steps up from nothing, as the airframe’s nose does. So a pod that starts with a tube gets no slope from its flat front. Faster than sound, a pod keeps slender-body theory’s slope, since the shock-expansion method (Bodies faster than sound) covers the airframe alone.
- Body lift. Each pod’s body lift, Jorgensen’s crossflow term, uses the pod’s own planform and fineness (its length over its largest diameter), not the airframe’s.
- Fins on a pod. A pod’s fin set is turned with its pod: pod at roll angle holds fin at . Each fin takes its share of the flow as an airframe fin does (Fins). The fin-fin factor (how a set’s fins shade each other) counts one pod’s fins. The body’s interference with the fins, , is the pod tube’s: 1 for the tube of no radius a pod of winglets hangs from.
- Drag. Each pod adds its own drag buildup (Drag): friction on its surface, with the body form factor at its own fineness. It has its nose’s or shoulder’s pressure drag, its steps, its boattails and its own base, the last part’s aft area. A pod’s fins, lugs and buttons drag once per pod too. The Reynolds number stays the rocket’s, as for every part ([N09] §3.4).
- Motors in pods. A burning motor’s cross-section comes off the base of the body it sits in. The airframe’s motors come off the airframe’s base, and a pod’s off its own pod’s
([N09] pp. 50–51 for the base). This is worked out per pod set. Each pod set that holds motor
mounts has its own total of thrusting motor area
(
DragConditions::thrusting_pod_motor_areas_m2, in the order ofLayout::motor_pod_sets). Each of its pods takes an even share of that total. A base smaller than its motors has no base drag left, never less. Up toMOTOR_POD_SETS, 4, pod sets may hold motor mounts; a rocket with more is refused by name. Until M4.5i, motor mounts in two different pod sets were refused (ADR-168). Worked example: two pod sets of one pod each, both holding a burning 18 mm motor (2.54 cm² each). Each pod’s own base loses 2.54 cm²; the airframe’s base keeps its own motors’ relief alone. - Roll. In HPR Sim a pod adds no rolling moment of its own (but see A single pod’s moments below); it damps a roll. Rolling at , a part at distance from the axis crosses the air at , so it meets it at the angle . Its normal force acts about the axis with the arm . That gives, for each pod’s body part, a roll damping (Roll: forcing and damping) of , on the reference diameter . A pod’s fins damp as the airframe’s fins do, with each strip’s distance taken from the rocket’s axis. A fin whose root is out along its span has its strips at .
Where the forces act. The flight engine applies each pod part’s force on the rocket’s axis at its station. For two pods or more, spaced evenly, the pods’ offsets add to zero. So the forces on the axis turn the rocket in pitch and yaw as they would at the pods. What an offset adds, to first order, is roll damping, which HPR Sim adds as above, and a pitch damping from the pods’ drag. Pitching at , a pod off the pitch plane meets the air faster or slower on either side. So its drag changes by as much and pitches back. That is (the pitch moment per unit pitch rate, one pod’s drag coefficient, the sum over the pods). is about −0.15 on the worked example below. HPR Sim leaves it out. The airframe’s own pitch damping from its fins is , with the fins’ distance from the center of gravity. It is of order on such a rocket.
Worked example. The tests’ rocket is the finned_rocket of hpr-aero’s tests. It has a 0.25 m (0.82 ft) ogive nose and 0.7 m (2.3 ft) of tube 27 mm (1.1 in) in radius. A 0.05 m (0.16 ft) boattail leads to a 22 mm (0.87 in) tail tube 0.3 m (0.98 ft) long. Its four fins have 0.12 m (0.39 ft) root chord, 0.05 m (0.16 ft) tip chord and 0.06 m (0.20 ft) span. The sweep is 0.07 m (0.23 ft). It carries three pods 40 mm (1.6 in) from its axis, starting 0.35 m (1.1 ft) aft of the nose tip. Each is a cone 0.05 m (0.16 ft) long on a tube
0.2 m (0.66 ft) long, both 10 mm (0.39 in) in radius. So each pod’s fineness is . At Mach 0.3,
Reynolds number per meter:
| rocket | one cone’s slope, per rad | its CP, m | rocket’s normal-force slope, per rad | rocket’s CP, m aft of the tip | zero-lift drag coefficient | pods’ share of drag coefficient | roll damping coefficient |
|---|---|---|---|---|---|---|---|
| without pods | 12.374 | 1.0662 | 0.5051 | −35.215 | |||
| with three pods | 0.2743 | 0.3833 m (1.258 ft) | 13.197 () | 1.0237 | 0.6386 | 0.0074, 0.0127, 0.0592, 0.0542 | −36.118 (−0.903) |
One cone’s slope is per radian and its center of pressure . The pods’ share of drag is the cones’ friction and pressure, then the tubes’ friction and base. Their share of roll damping is .
The pods move the center of pressure about 43 mm (1.7 in), 0.79 calibers,
forward, and add 26% to the drag. The test the_aero_page_s_pod_example holds this table to the
digits printed. The tests a_pod_adds_its_bodies_slopes_once_per_pod,
a_pod_s_body_lift_takes_its_own_fineness, a_pod_drags_once_per_pod,
a_pod_s_base_takes_its_own_motors_area, a_pod_s_bodies_damp_the_roll,
a_pod_s_fins_turn_with_their_pod and a_pod_s_fins_are_the_pod_s_turned_with_it hold the rules to hand-worked values. They hold the fins’ damping to Barrowman’s strips summed by hand over two pods with a
fin pointing each way. In the flight engine’s tests,
pods_damp_the_spin_of_canted_fins_by_their_cones flies Valetudo
with three pods and canted fins: it spins to the balance the pods’ damping predicts, to 1e-6.
Against OpenRocket. The six probe designs are written by
pod_probes.py.
Each is an airframe with a 0.2 m (0.66 ft) conical nose on 0.6 m (2.0 ft) of tube 60 mm (2.4 in) across. It has three fins, an AeroTech H128W and one set of pods. The pods are about 0.3 m (0.98 ft) long and 20 mm (0.79 in) to 32 mm (1.3 in) across. They stand 5 mm (0.20 in) to 10 mm (0.39 in) off the airframe. The winglets hang from pods of no length at its surface. Every
outside part is set to OpenRocket’s regular paint finish, 60 µm roughness. OpenRocket 24.12 flies
them straight up in calm air, and HPR Sim flies the same files
(HPR Sim’s flights against OpenRocket’s). In
such a flight the apogee and the largest speed test the drag and the mass. The normal force enters
only through the margin, which both codes take as the rocket leaves the rod. Pods’
change is the difference from pods-none, the same airframe with no pods, so it shows the pods’
own share in each code:
| probe | its pods | apogee, OpenRocket | HPR Sim’s apogee, % from OpenRocket | pods’ change of apogee in OpenRocket, % | pods’ change of apogee in HPR Sim, % | margin, OpenRocket | margin, HPR Sim |
|---|---|---|---|---|---|---|---|
pods-none | none | 776.1 m (2,546 ft) | +0.81% | 2.757 cal | 2.759 cal | ||
pods-bodies-3 | three: a cone and a tube | 663.3 m (2,176 ft) | +0.48% | −14.53% | −14.81% | 2.360 cal | 2.362 cal |
pods-fins-2 | two: a cone, a tube, three fins | 613.7 m (2,013 ft) | +0.49% | −20.93% | −21.18% | 2.653 cal | 2.654 cal |
pods-fins-tail-4 | four: a cone, a tube, four fins, a tail cone | 533.3 m (1,750 ft) | +0.91% | −31.28% | −31.21% | 2.470 cal | 2.471 cal |
pods-winglets-2 | two of no length, two fins each | 699.8 m (2,296 ft) | +0.71% | −9.84% | −9.92% | 2.622 cal | 2.623 cal |
pods-motors-2 | two: a cone, a tube, three fins and an H128W each | 876.9 m (2,877 ft) | +0.53% | +12.98% | +12.66% | 2.990 cal | 2.991 cal |
pods-motors-2 flies an H128W in each of its two pods and none in the airframe, twice the impulse. It has 0.35 kg of nose ballast instead of 0.15 kg, so its change is not its pods’ alone. HPR Sim’s
largest speed is 0.73% to 1.24% above OpenRocket’s, its margin 0.0011 to 0.0014 calibers larger. The pods’ change of margin agrees to 0.0004 calibers. The launch masses agree within 0.0001%.
The test pod_designs_are_within_5_percent_of_openrocket holds every probe within 5% of
OpenRocket’s apogee and largest speed, the bar every flight against OpenRocket is held to
(ADR-076). It also holds each margin within 0.005 calibers, and the pods’ change within
1 percentage point of apogee and 0.005 calibers. Those bounds were set after these numbers were
measured, tight enough to catch a broken pod rule. A pod fin’s body interference taken on the
airframe’s radius would move a margin by some 0.04 calibers. The whole table is in the
committed report.
The first probes stated no surface finish. HPR Sim flew them 6.0% to 7.3% high because the two programs’ defaults differ. OpenRocket reads a part with no finish as regular paint, 60 µm. HPR Sim’s reader gave it HPR Sim’s own default, 20 µm, and now reads it as OpenRocket does (issue #216, which gives the run). The probes now state their finish.
One private design flies with pods too: C02, an anonymized design of the library
(HPR Sim’s flights of the private designs).
Its pods hold only a launch lug each, on a tube of no length, so they add the lugs’ drag and
nothing else. Over its 5 configurations HPR Sim’s apogee is −0.94% to +2.15% from OpenRocket’s. 3 of them are compared with an OpenRocket flight whose parachute opened before apogee, including the +2.15%. Of OpenRocket’s own pod examples, Pods--airframes and winglets flies, its cockpit fin
read on the nose cone
(fins on a nose cone). Every apogee is within 0.5% of OpenRocket’s, with the margin 0.071 to 0.076 calibers above it, the flattering side
(#325,
#326). Pods--powered with recovery deployment
flies since M4.5i, as saved since M4.5k. As saved, the design weighs its rail buttons’ screw heads and takes each of its two pod sets’ motors off that set’s own pods (ADR-168). With
only the sustainer’s motor it reads 0.36% below OpenRocket’s apogee, and with only the booster’s
motors 1.86% below. Its staged flight reads 37.93% low because its sustainer is unstable when the air
crosses it edge-on to its two-fin strake set. In the conditions of OpenRocket’s record it turns over before apogee in both codes. That record’s site is at 28.61° N, where the Earth’s
rotation tips HPR Sim’s flight. HPR Sim’s angle of attack passes 90° at 2.25 s
(HPR Sim’s flights against OpenRocket’s).
What neither code models. OpenRocket documents no pod model of its own. On the probes its answer is HPR Sim’s. Neither code
turns the flow around the body, then. On pods-fins-2 the upwash beside the body (below) would add
about a third to the pod fins’ force. So the limits below are both codes’ limits, and the agreement
above cannot size them. The probes do not test a single pod (each has two or more) or a pod faster than Mach 0.81. Nor do they test a rocket flying at an angle of attack, so not a pod’s body lift, which is zero straight into the air. Nor do they test airframe and pod motors burning together, or a roll: none has canted fins,
and neither code’s roll is compared.
Left out, and how large it may be.
-
The body’s flow around the pods, and theirs around it. The airframe turns the crossflow around itself, so a pod beside it meets the air at a different angle. In potential flow past a cylinder of radius , consider a point at distance , at the angle from the crossflow’s direction. It meets the crossflow at along it and across it. At the first is NACA Report 1307’s upwash ([PNK57] p. 4 eq. 15). For three pods or more, spaced evenly, both average to zero, and the first-order change cancels. For one or two they do not. On the worked example’s pods, . So a pair’s cones lift up to 46% more or less, by roll angle, and push sideways by up to as much. HPR Sim leaves this out. Interference drag is left out as well. Barrowman leaves it out for fins ([B67] p. 62, “No interference drag effects are considered”) and Niskanen for the whole rocket ([N09] §3.4).
-
A single pod’s moments. One pod’s drag acts off the axis and pitches the rocket; its normal force, and its fins’, act off the axis and roll it. HPR Sim applies them on the axis, so it drops those moments (issue #213). The worked example with one pod has drag coefficient 0.0445 at 40 mm (1.6 in). With a one-caliber margin, the pitch moment would trim the rocket at about
Which way that moves the flight turns with the pod’s side against the wind and the rail’s tilt. So the apogee or the drift may read low. A flight with one pod off the axis warns of it (the flight-path warnings). Two or more pods stand evenly round the axis, so their moments cancel.
-
The interference on a pod’s fins’ roll damping. HPR Sim takes the pod tube’s roll-damping factor on the whole sum. The part that comes from the pod’s offset is the pod moving sideways, whose factor is closer to the normal force’s . For a fin whose span equals the tube’s radius (), is 1.5 and a rectangular fin’s 1.33 (Fins, Roll: forcing and damping). So that part may be some 10% too small; no test sizes it. On a pod of no radius, winglets’ usual pod, both are 1 and nothing is lost.
-
A pod inside the airframe. Nothing checks that a pod clears the airframe (#206); a pod sunk into it still gets its whole slope, friction and base.
-
Canted fins on a pod are refused: their roll forcing about the rocket’s axis is not modeled. So is a pod’s tube of no length with a radius, a flat disc the drag buildup has no term for.
Tube fins
A tube fin set is a ring of short open tubes around the airframe, in place of flat fins. HPR Sim flies each tube as an annular wing (a ring wing). That is a wing bent round into a tube, which lifts when the air meets it at an angle.
Only its parts are validated: no tube fin rocket has been checked against a wind tunnel or a measured flight. The ring wing’s slope is within 3% of five rings measured in a wind tunnel, which were thick and cambered, not paper tubes. What the tubes do to each other and to the body is not modeled. Nothing measures it, and theory predicts more lift than HPR Sim gives (#234).
The model came with M2.2e9 (ADR-099, tube fins flown as ring wings).
On OpenRocket’s Tube fin rocket HPR Sim’s center of pressure is 1.07 calibers forward of OpenRocket’s. That misses the quarter caliber Loft lesson L19 asks for, and nothing measured says which code is nearer (below).
The normal force. A ring wing of diameter and length lifts about twice as much as a flat wing of span and chord . A long, thin ring lifts twice what a solid body of its diameter would. This is because it turns the air inside it as well as the air around it. Hoerner (1965, p. 7-13) gives for a ring of small aspect ratio. HPR Sim takes Weissinger’s formula for a thin ring (1955, as quoted by Wagner 2021, eq. 15). It runs from the short-ring limit to that long-ring limit. With , its lift slope reads as below. At small angles that is its normal-force slope, here on the area , not the reference area, per radian:
is the tube’s mean diameter, its outer and inner radii added. For a paper tube it is within a few per cent of the inner diameter the other choice would give. Fletcher’s rings run from to 3. A longer tube rests on the formula alone, which the tests hold to its long-ring limit. A set of tubes takes times one tube’s slope, on the rocket’s reference area. Faster than Mach 0, it takes Göthert’s rule, the same idea as the fins’ Prandtl-Glauert factor. The slope is the one a ring times longer would have, over . That leaves the long-ring limit unchanged and scales the short-ring limit by .
The center of pressure. Fletcher measured where the lift of five rings acts (NACA TN 4117, 1957, Fig. 8, at Mach 0.13). HPR Sim reads it against the ring’s aspect ratio , interpolated in straight lines:
| aspect ratio | aerodynamic center, fraction of aft of the leading edge |
|---|---|
| 0 | 0 (theory) |
| 1/3 (thick ring) | −0.11 (left out) |
| 2/3 | 0.143 |
| 1 | 0.203 |
| 1.5 | 0.253 |
| 3 | 0.355 |
The table ends at , Fletcher’s shortest ring. Below the line runs to the leading edge at . That end point comes from slender-body theory, in which a long, thin ring’s lift all appears at its front edge. Hoerner and Borst assume the same of the air turned inside an open tube. They say it turns “at or near the rim of the inlet” (Hoerner and Borst 1985, p. 19-16). They write that they “do not have suitable experimental results at hand” on how an axial duct changes a slender body’s lift and moment.
Fletcher’s ring is left out, a judgment. Its center sits ahead of its leading edge. Fletcher puts that down to its low aspect ratio: such a ring behaves more like a slender body of revolution than the others (p. 4). That this would not carry over to a paper tube is HPR Sim’s inference, untested. His rings had a Clark Y section 11.7% of the chord thick, all of it outside a straight bore. At a chord of three bores that wall is 0.35 of the bore thick, so about two thirds of the ring’s frontal disc is wall. A paper tube’s is a few per cent. His thinner rings may carry some of the same forward shift. On the worked example below, the margin at rod clearance is:
| center rule | margin (calibers) |
|---|---|
| Fletcher’s point taken | 0.29 |
| the line to the leading edge (HPR Sim’s) | 0.79 |
| OpenRocket | 1.87 |
The 0.29 holds Fletcher’s −0.11 below , as the model’s first version did; it comes from a one-off run, not kept in the report.
The drag. Friction takes the inside and the outside of every tube, per tube, at the rocket’s skin-friction coefficient (Drag). The wall’s front ring, per tube, takes a square fin edge’s pressure drag. That is a blunt face at the front and base drag behind (Drag, eqs. 3.90 and 3.92).
Refused. HPR Sim refuses these cases rather than guess:
- Mach 0.8 and faster. No source covers tube fins near the speed of sound, where the flow through a tube can choke. A flight that reaches it stops with the tube-fin model’s error, even on an override table, which still takes the model’s tube stations and roll.
- Fewer than three tubes. The body’s own flow cancels in the sum only around three or more evenly spaced tubes.
- Solid tubes, with a wall as thick as the radius.
- Tube fins on a pod.
- A ring shorter than a third of its diameter (), past Fletcher’s rings.
- Tubes that overlap each other.
A tumbling airframe with tube fins stays refused too (Recovery).
Worked example. OpenRocket’s Tube fin rocket has six tubes 76.2 mm (3.0 in) long, of radius 12.395 mm (0.49 in) with a 0.330 mm (0.013 in) wall. They sit on a body of the same radius. Its tubes are just longer than Fletcher’s longest ring, and their center falls on the line below his , the judgment above.
| quantity | value |
|---|---|
| mean diameter | 24.46 mm (0.96 in) |
| 3.115 | |
| Weissinger’s on | 0.990 per radian, 98.1% of the long-ring limit |
| one tube’s slope, on the reference area 4.827 cm² | 3.82 per radian |
| the set’s, six tubes, at Mach 0 | 22.93 per radian |
| at Mach 0.35, its fastest | 22.96 per radian |
| center, at | , 5.2 mm (0.20 in) aft of the leading edge |
| friction area, six tubes inside and out | 145.6 times the reference area |
| wall area | 0.315 times the reference area |
| drag at Mach 0.2, friction and wall | 0.741 and 0.310, of the rocket’s 1.654 |
| OpenRocket 24.12’s slope for the set, at every Mach number | 37.85 per radian |
| OpenRocket’s center, to Mach 0.5 | , 19.05 mm (0.75 in) aft of the leading edge |
Against OpenRocket. The Tube fin rocket is in the flight report. Flown on HPR Sim’s own drag, its apogee is 6.95% above OpenRocket’s, 302.5 m (992 ft) against 282.8 m (928 ft). On OpenRocket’s recorded drag, HPR Sim’s apogee is within 0.03% of OpenRocket’s (ADR-097). So the net gap is the drag’s, though parts of it could cancel, and the rest of the flight agrees. OpenRocket’s per-component drag, read through its public API but not kept as a record, points to where. These are leads for #228, not measurements the repository reproduces:
- The nose, the body and the lug agree within 0.005.
- The tube fins take 1.18 in OpenRocket’s total and 1.05 in HPR Sim’s.
- Keeping the whole base while the motor burns, as OpenRocket does, closes 2.3 of the 6.95 points. This one is in the report: HPR Sim flew it. That rule is not specific to tube fins (#222).
HPR Sim’s tube-fin drag probably reads low. OpenRocket refined its tube-fin drag against measured flights of two tube-fin rockets. A table in a comment on the change that last revised it (openrocket#2066) has seven flights in five motor cases. OpenRocket’s apogee is within −2% to +5.2% of the measured one, and high in four of the five. HPR Sim has checked itself against no measured flight, and a code-to-code gap is not a measurement. Still, that is evidence OpenRocket’s drag is the nearer of the two here. #228 holds the search for a measured source.
The center of pressure against OpenRocket. The stability margin differs more. At rod clearance, the moment the rocket leaves the launch rod, HPR Sim’s margin is 0.79 calibers and OpenRocket’s 1.87. Almost all of that gap is the center of pressure: HPR Sim’s is 1.07 calibers forward of OpenRocket’s. The two centers of mass differ by 0.002 calibers. The tube fins’ center of pressure against OpenRocket is recorded in ADR-102.
OpenRocket 24.12’s answers for tube fins are kept as a
fixture,
openrocket-tube-fin-aero.json,
written by
tube_fin_aero.py.
It holds OpenRocket’s slope and center for the tubes and for the whole rocket, at five Mach
numbers. It covers the Tube fin rocket and 14 probe designs, each
changing one thing: the tubes’ length, count, radius or wall. The test
tube_fin_cp_against_the_oracle_measured_and_pinned
reads the same probes with HPR Sim and pins all 70 gaps. The record shows:
- The two codes agree on the probes’ geometry and on the nose and body. Given OpenRocket’s slope and center for the tubes, HPR Sim’s rocket has OpenRocket’s center of pressure within 0.01 calibers. So the whole gap is the tubes’.
- OpenRocket’s tubes lift 1.26 to 1.86 times what HPR Sim’s ring wings do, at every Mach number.
- Its lift per tube is the same whatever the number of tubes, so it models no interference that changes with the count. Slender-body theory with the body included predicts one, and it falls as tubes are added. An estimate is taken 0.005 tube radii from the body and still rises as that gap closes. The theory gives at least 1.96 times the lift of the same number of isolated rings for three tubes of 6 mm (0.24 in) radius. Six tubes of that radius give at least 1.57 times the lift of six isolated rings. Six touching each other give at least 1.13 (the estimate, #234) (evidence row G27). OpenRocket’s lift on the 6 mm (0.24 in) probes is 1.73 times the long-ring limit of isolated rings: below the estimate for three tubes. For six, the same estimate taken closer, and carried on to contact, is about 1.65, a little below OpenRocket’s.
- An independent solve reproduces that estimate, but nothing has measured it. A source-panel solve gives 1.971 for the three 6 mm (0.24 in) tubes against the estimate’s 1.96, and is within 1% on all six tube sets the estimate gives (the research note). No measured tube set beside a body was found, so the size isn’t bounded. For the three tubes, the solve’s factor falls from 1.971 at a gap of 0.005 tube radii to 1.40 at 0.25. HPR Sim leaves the interference out. If the rise is real, that keeps the stability margin cautious: applying it would move the center of pressure aft and raise the margin. Evidence row G27 waits on a measured tube fin (#679).
- OpenRocket puts the tubes’ center a quarter of their length aft of the leading edge up to Mach 0.5. Its maintainers describe that as the subsonic rule its flat fins and tube fins share (openrocket#3262).
On the probe built like the Tube fin rocket, six tubes 75 mm (3.0 in) long touching the body and each other:
| Mach | HPR Sim’s center of pressure less OpenRocket’s, calibers |
|---|---|
| 0.05 | −1.04 |
| 0.3 | −1.05 |
| 0.5 | −1.06 |
| 0.6 | −0.36 |
| 0.75 | −0.39 |
The Tube fin rocket itself, at rod clearance (Mach 0.056), gives −1.07. Its tubes are 76.2 mm (3.0 in) long and its nose and body differ a little from the probe’s.
From Mach 0.6 the gap shrinks only because OpenRocket 24.12 moves the tubes’ center to the leading edge. Its maintainers call that jump a bug and fixed it after 24.12 (openrocket#3235). The jump moves OpenRocket’s own center of pressure on the Tube fin rocket 0.73 calibers forward between Mach 0.5 and 0.6. It probably accounts for the five probe results, of 28 from Mach 0.6, that come within the lesson’s quarter caliber.
On that probe at Mach 0.05, giving HPR Sim’s tubes OpenRocket’s center but keeping their slope moves HPR Sim’s center of pressure 0.50 calibers aft. Giving them OpenRocket’s slope but keeping HPR Sim’s center moves it 0.53 calibers aft. Up to Mach 0.5, every probe’s gap is between 0.42 and 3.0 calibers.
HPR Sim keeps its model. Fletcher’s measured center moves forward, as a share of the ring’s length, as a ring gets longer. Nothing measured supports OpenRocket’s quarter length or its extra lift. HPR Sim’s own center for this rocket is unmeasured too: its tubes () are longer than every ring Fletcher measured. With his ring left out, their center comes from HPR Sim’s line from to the leading edge. Placed as his thick ring’s instead, it would give a margin of 0.29. Neither code has been checked against a measured tube-fin rocket, so which margin is nearer is open (#228). Until then, check a tube-fin design in both programs and treat the smaller of the two margins as the more cautious estimate. It is not a bound: the thick-ring reading above gives a smaller one still.
What it leaves out:
- How the body and the tubes change each other’s flow. Slender-body theory predicts that they raise each other’s lift, but HPR Sim applies no interference factor (#234).
- The gaps between tubes and body, and the drag where they meet.
- How the flow through a tube develops, or chokes.
- A thin tube’s measured center of pressure.
The rocket’s own crossflow, around a tube from its axis, turns with twice the roll angle. It sums to zero over three or more tubes evenly spaced, which is why the model takes three or more. That is a first-order derivation, not a measurement. It takes the body’s flow at each tube’s center and leaves out the rest of their effect on each other.
The normal force from RASAero II
A flight can use another program’s normal force and center of pressure in place of HPR Sim’s own. Today it is RASAero II, read from the table it exports. Use it to fly two programs on the same aerodynamics, so a difference between them comes from something else. Or use it to fly RASAero II’s numbers faster than sound, where HPR Sim’s own normal force is less tested (Fins through Mach 1).
The 0° column, which HPR Sim works out, agrees at 15 Mach numbers with the reading made for M1.8a. A rocket on a table swings in pitch and yaw as the small-angle equations of motion predict for the table’s slope and center of pressure. The assumptions past the export’s last angle and at 0° fit RASAero II’s viscous part through Mach 1.3. Faster, that part grows much more slowly with the angle.
Three parts are HPR Sim’s choices, not RASAero II’s:
- the damping, which stays HPR Sim’s own;
- the normal force past the export’s largest angle of attack (4° in the one export tested);
- the slope at 0°, where the export’s normal force is zero.
In code, two calls take a file to a flight:
NormalForceTable::from_rasaero_csvreads the text.Simulation::with_normal_force_tableflies it. Its documentation has a worked program.
The decisions are in the record on normal-force overrides, ADR-032. The milestone is M1.8d.
What the export holds
RASAero II’s Aero Plots screen exports a table to CSV (File, Export, To CSV File; [RAS] p. 76).
There is one row for each Mach number and angle of attack
(Alpha, in degrees). The Calisto export has rows at 0°, 2° and 4°. HPR Sim reads five of the
columns:
| column | what it is |
|---|---|
Mach, Alpha | the Mach number, and the angle of attack in degrees |
CN | the normal-force coefficient at that angle |
CN Potential | the part of CN from potential flow (the air treated as smooth and without friction), which grows in step with the angle |
CP | the center of pressure, in inches ([RAS] p. 13) measured from the nose tip (p. 114) |
CN also holds a viscous part, CN Viscous. It is the extra push, from the air’s friction, of
the air flowing sideways across the body. RASAero II takes it from Jorgensen’s method ([RAS] p. 55). RASAero II adds it from Mach 0.91 in Calisto’s export, and moves the center of pressure forward with
the angle. HPR Sim’s own model has neither. From Mach 0.91 through Mach 1.3 the viscous part grows
exactly as : at 4° it is times its value at 2°. Faster, it grows
more slowly: 3.90 times at Mach 1.5, 3.16 at Mach 2, 1.73 at Mach 3 and 1.05 at Mach 4. The export’s CNalpha (0 to 4 deg) and CP (0 to 4 deg) columns
repeat its 4° values on every row; HPR Sim doesn’t read them.
How the simulator reads it
HPR Sim builds one column for each angle in the export. Each column holds (the normal force over the angle, per radian) and the center of pressure, both against Mach number.
- At a positive angle, is
CNover the angle in radians. - At 0°,
CNis zero, so it can’t be divided. HPR Sim takesCN Potentialat the smallest positive angle, over that angle. The potential part grows in step with the angle: in Calisto’s export its is the same at 2° and 4° to 2e-15. Through Mach 1.3 the viscous part grows as , so it adds no slope at 0°. Faster, the export doesn’t show how it starts from 0°, and leaving it out of the slope is an assumption. - The center of pressure is converted from inches to meters at 0.0254 m (0.083 ft) to the inch. It stays measured from the nose tip, as HPR Sim’s stations are (station). So the design must start at the same nose tip as the RASAero II file. A table is refused if its center of pressure lies outside the rocket, ahead of its nose or behind its tail. The check runs at each of its Mach numbers up to 5 (where a flight stops). Such a center is the sign of a length in the wrong unit.
- Reference area. RASAero II’s coefficients are on the body’s largest cross-section ([RAS] p. 72). HPR Sim records that and rescales them to the rocket’s own reference area, when that is something else. For a rocket of several stages, export the whole stack (“Sustainer plus Booster” or “All Stages”): HPR Sim flies the whole stack.
A flight looks up the table at its Mach number and angle of attack:
- Within one column, the values are linear in Mach number. Outside a column’s range the end values hold, and the lookup says so.
- Between two columns, and the center of pressure are linear in the angle. Then comes back exactly at each column’s angle. Between them it is a part in step with the angle plus one in its square. That is RASAero II’s own shape through Mach 1.3 ( is within 0.2% of to 4°), and an assumption faster than that.
- Past the largest angle , the normal force splits in two. The linear share is the slope at 0° times , at the 0° center of pressure. The share grows as , as HPR Sim’s own fins do (Aerodynamics in flight). The rest of the force, with the rest of the moment, grows as . This is the form of the air crossing the body that HPR Sim’s body lift also takes ([G] p. 1; [N09] eq. 3.26). The force and center of pressure are continuous at , and the force is zero when the air comes from the tail. Two limits keep this sensible for any table. The rest’s center of pressure is held within the rocket. And a table whose falls with the angle has no rest: its whole force grows as , so the force never turns round. Neither limit makes a jump as the Mach number changes. Either way this is an assumption, and the lookup reports it.
A worked example. Take an export with invented numbers. At Mach 1, CN Potential is 10 per radian times the angle. CN Viscous is 0.03 at 2° and 0.12 at 4°. The center of pressure is
50, 49 and 48 inches at 0°, 2° and 4°. These are the numbers in the CSV reader’s unit test,
reads_a_rasaero_export_by_angle_of_attack.
| angle | normal-force coefficient CN | , per rad | center of pressure |
|---|---|---|---|
| 0° | 0 | 10.000 (CN Potential at 2° over 2°) | 1.2700 m (4.167 ft) |
| 2° | 0.37907 | 10.8594 | 1.2446 m (4.083 ft) |
| 3° (looked up) | 0.59110 | 11.2892, halfway between 2° and 4° | 1.2319 m (4.042 ft) |
| 4° | 0.81813 | 11.7189 | 1.2192 m (4.000 ft) |
| 10° (past the table) | 2.4815 | 14.2180 | 1.1662 m (3.826 ft) |
At 10°, is 2.4893. The linear share, 10 × 0.069813 = 0.69813 at 1.2700 m (4.167 ft), grows to 1.7379. The rest, 0.12 at 0.9237 m (3.031 ft, the station that gives the 4° moment), grows by to 0.7436. Together they make 2.4815 at 1.1662 m (3.826 ft): the center of pressure moves forward with the angle, as RASAero II’s does. The first draft scaled the whole 0.81813 by 2.4893 at 1.2192 m (4.000 ft) instead. That gave 2.0366, 18% less force, with the center of pressure 5.3 cm (2.1 in) further aft. That reads the rocket as more stable than the viscous part makes it.
In a flight
The flight takes the table’s normal force at the center of mass’s airflow and applies it at the table’s center of pressure.
The export has no damping, so HPR Sim keeps its own (Rigid-body flight). The table gives the force as if the rocket weren’t turning. When it turns, each part meets the air at a slightly different angle, and HPR Sim adds that difference: it is the damping. When the rocket isn’t turning, the difference is exactly zero.
The flight still stops at Mach 5, where HPR Sim’s own parts, which give the damping, end. The table gives no side force: RASAero II’s rockets are symmetric.
How it was checked
| check | result | where the numbers are |
|---|---|---|
| Calisto’s export, every row at 2° and 4° read again apart from the library | 4,999 rows; CN within 2.2e-16 relative, CP exact; columns at 0°, 2° and 4° of 2,500, 2,500 and 2,499 Mach numbers, from Mach 0.01 to 25 (24.99 at 4°) | normal-force-override.json |
The 0° column at 15 Mach numbers against the reading of the export made for M1.8a, the normal force through Mach 1, which normal-force-vs-mach.json holds | the same to 1e-12 relative. That reading applies the same 0° rule, so this checks the reading, not the rule | both files |
| Valetudo at 100 m/s (328 ft/s) on a table of 1.5 times HPR Sim’s slope with the center of pressure 5 cm (2.0 in) further aft, against the small-angle equations of motion, in pitch and in yaw | period 1.104077 s against 1.104073 s, within the test’s 3e-5 (1.44965 s on HPR Sim’s own); the decay within 0.03%, the test’s bound 1% | hpr_sim::tests::pitch_oscillation_follows_a_normal_force_table |
| Tables of HPR Sim’s own normal force flown in a crosswind: every 0.5° and every Mach 0.01, and at 0°, 2° and 4° only, where the flight uses the continuation past 4° | apogee within 7.8 mm (0.31 in) and 5.5 cm (2.2 in) of HPR Sim’s own flight, the test’s bounds 5 cm (2.0 in) and 10 cm (3.9 in) | hpr_sim::tests::a_table_of_hpr_s_own_normal_force_flies_as_hpr_does |
| The continuation past the last angle: a table shaped as RASAero II’s (a part linear in the angle, one as ), and random tables | the part continues to 1e-12; the force never turns round, the center of pressure stays within the rocket, and nothing jumps as the table’s values change with Mach number | hpr_aero::table::tests |
| Calisto from a 5.2 m (17 ft) rail at 85° in a 5 m/s (16 ft/s) crosswind, up to Mach 0.747: on the export, on HPR Sim’s own normal force, and on HPR Sim’s own as a table at the export’s angles | the export: apogee 2,827.09 m (9,275.2 ft) against 2,828.21 m (9,278.9 ft), 12.6 m (41 ft) further into the wind. HPR Sim’s own as a table moves it 0.02 m (0.066 ft): the table’s method, apart from its numbers. Each flight spends 2.2 to 2.3 s past 4° before apogee | normal-force-override.json |
The Calisto flights show how much the change matters. They are not a check of accuracy: nothing
measured flew. cargo xtask aero writes the fixture from the export, which isn’t committed, and
checks it again wherever the export is present. CI has no copy of the export. There, a test checks
that the fixture’s 0° values agree with the ones committed for
M1.8a, and flies the 15-point table again.
What it leaves out:
- No real export has been flown through Mach 1. Calisto peaks at Mach 0.75. The reader’s unit tests cover the transonic columns.
- Past the export’s largest angle, the split continuation is HPR Sim’s assumption. In a 5 m/s (16 ft/s) crosswind Calisto flies past 4° for about 0.3 s just after leaving the rail (up to 7.9°). In that crosswind it flies past 4° again for the last 1.9 s before apogee, as it slows below 30 m/s (98 ft/s). Its export has no viscous part below Mach 0.91, so Calisto’s flights use only the linear share. The flights on tables of HPR Sim’s own normal force are the ones that grow a rest as . From Mach 3, where RASAero II’s viscous part grows far less than does between 2° and 4° (1.73 times at Mach 3, 1.05 at Mach 4), the share probably gives too much force.
- The nose tip can’t be checked from the export beyond the refusal above. A design that starts somewhere else gets a shifted center of pressure, with no warning.
- Only RASAero II’s layout is read. A table from anywhere else can be built in code with
NormalForceTable::new.
Drag
Code: hpr_aero::drag (the terms),
AeroModel::drag and
AeroModel::buildup_components
(their sum over a rocket), hpr_aero::table (override tables),
hpr_design::Finish (roughness).
Decisions: ADR-009 (drag buildup, surface finishes and override tables). Extra sources:
- [B67] ch. 4 (pp. 43–62): the friction, roughness and leading-edge formulas Niskanen adopts, and Table 4-1 of roughness heights (p. 46, after Hoerner p. 5-3).
- [N09] §3.4 (pp. 41–53) and appendix B (pp. 106–110). [TD] reprints the same drag equations and tables unchanged.
On this page is the zero-lift drag coefficient: the drag with the air straight along the axis, divided by . Recovery uses the same symbol for something else: a parachute canopy’s drag coefficient on its nominal area.
Drag is built up term by term. Skin friction acts over the whole surface. Pressure drag acts on noses and shoulders (here, a transition that widens toward the tail) and on boattails (one that narrows). Base drag acts on the flat aft end and fin pressure drag on the fins’ edges. Parasitic drag acts on launch lugs and rail buttons ([N09] eq. 3.75, 3.97). Each pressure, base and parasitic term acts on its own area:
The axial coefficient is .
| symbol | meaning | unit |
|---|---|---|
| the zero-lift drag coefficient: the drag with the air straight along the axis, divided by | none | |
| its skin-friction part | none | |
| , | the area one pressure, base or parasitic term acts on (a nose’s base, the fins’ front edges), and its coefficient on that area | m², none |
| , | the axial coefficient (the drag along the axis at an angle of attack), and the factor that turns into it | none |
| , , , | the Reynolds number, the airspeed, the rocket’s length and the air’s kinematic viscosity | none, m/s, m, m²/s |
| , | the surface’s roughness height, set by its finish; the Reynolds number above which roughness, not , sets the friction | m, none |
| , | the skin-friction coefficient, before and after its correction for Mach number | none |
| the body’s fineness ratio: its length over its largest diameter | none | |
| , | the areas friction acts on (see Friction on the axial projection) | m² |
| a fin’s thickness | m | |
| (nose and shoulder row) | the joint angle between the surface and the axis where a nose or shoulder meets the next component: 0 for a smooth joint, for a step. Not the flow roll | rad |
| , , , | a boattail’s length over its drop in diameter, from at its fore end to at its aft end | none, m |
| the base drag coefficient (the base row) | none | |
| the pressure rise where the air comes to rest on a blunt face, over ; 1 at low speed | none | |
| a fin’s leading-edge sweep | rad | |
| the fins’ frontal area: fin count × thickness × span | m² | |
| , , | a launch lug’s outer and inner radii, and its length over its outer diameter | m, none |
| square, rounded, airfoil | a fin’s cross-section: constant thickness with square edges; semicircular leading and trailing edges; or a NACA four-digit symmetric airfoil |
| term | formula | area | source |
|---|---|---|---|
| Reynolds number | , nose tip to aft end of the last body component | [N09] eq. 3.12, p. 42 | |
| skin friction | for ; to ; from it | [N09] eq. 3.78–3.81, [B67] eq. 4-4–4-8 | |
| roughness limit | [N09] eq. 3.79, [B67] eq. 4-7 | ||
| compressibility | for ; turbulent and rough (not below turbulent) above | [N09] eq. 3.82–3.84 | |
| friction drag | below the table | body: ; fins: both sides | [N09] eq. 3.85 |
| nose, shoulder | at rest, the joint angle at the aft end; through Mach 1 as under Drag through Mach 1 | base area; increase in area | [N09] eq. 3.86–3.87, appendix B |
| boattail | to Mach 0.8, × 1 (), , 0 (); ; faster, as under Boattails faster than sound | decrease in area | [N09] eq. 3.88; [762] Fig. 5-122 |
| base | below Mach 1, above; behind a boattail, times its base-pressure ratio: to Mach 0.8, then Boattails faster than sound | aft base less thrusting motors | [N09] eq. 3.94, p. 50; [S61] p. 11; [762] Fig. 5-141 |
| fin leading edge | square: ; rounded, airfoil: (to 0.9), (to 1), ; times | [N09] eq. 3.89–3.91, B.2 | |
| fin trailing edge | square: base; rounded: half base; airfoil: 0 | [N09] eq. 3.92–3.93 | |
| stagnation pressure | below Mach 1; above, below the table | [N09] eq. B.1 | |
| launch lug | below the table | below the table | [N09] eq. 3.95–3.96 |
| rail button | (a rail pin) | side profile | [N09] p. 52 |
| angle of attack | , ; , ; past 90° | [N09] §3.4.7 (conditions only) |
The friction drag, on the areas in its row:
The stagnation pressure above Mach 1:
A launch lug’s coefficient, then the area it acts on:
- Roughness.
hpr_design::Finishnames the fifteen rows of [B67] Table 4-1 (0 to 1,000 µm; [N09] Table 3.2 reprints ten) or takes a custom height. The default is “paint in aircraft mass production”, 20 µm. Each component has its own finish; the Reynolds number and use the whole rocket’s length, as [N09] does (Loft lesson L12). Loft cited none of its values. Its 60 µm is OpenRocket’s “regular paint” ([N09] p. 83), and its 2 µm is [B67]’s sheet-metal row, which [N09] leaves out. Its is Raymer’s aircraft fuselage form factor, not [N09]’s. - Fully turbulent. The boundary layer (the thin layer of air the skin drags along) is taken as turbulent everywhere, never laminar (smooth and layered). [N09] p. 43 found laminar runs changed apogee by under 5% and dropped them. Eq. 3.81’s branch applies first, even on surfaces rough enough that .
- Friction jumps where [N09] does. Eq. 3.79 is not where eq. 3.78 and 3.80 cross, so eq. 3.81 jumps at . The jump is +9% for 60 µm on a 1 m (3.3 ft) rocket (0.00419 to 0.00458). The subsonic and supersonic corrections also differ at Mach 1 (0.900 against 0.922 turbulent). HPR Sim keeps the published forms, and the tests pin both jumps (Loft lesson L90).
- Friction on the axial projection (a departure). Wall shear (the air’s drag on the skin, per unit area) acts along the surface. So on an element of area at an angle to the axis, its axial share is . The body’s friction area is rather than the slant surface in [N09] eq. 3.85. On slender noses the difference is small: a tangent ogive loses 1.1% of its own friction area at fineness 3 and 2.4% at fineness 2. On a short, steep shoulder it removes friction on what is nearly a flat face. So a shoulder’s drag tends to a bare step’s as its length goes to zero (Loft lesson L15). With the slant surface it would stay about above it. The OpenRocket comparison (M2.2) will measure the difference.
- Steps in radius. Where one body component meets the next with a different radius, a step up is a zero-length shoulder. It is a flat face ( at rest, rising with Mach as under Drag through Mach 1). A step down is a zero-length boattail, the base drag of the uncovered area. A body with no nose cone gets the same flat face on its front. Each is the limit of the transition it replaces (Loft lesson L15), and it is reported with the aft component. A step up just behind a step down is sheltered by the step’s corner at every speed. An example is a motor retainer behind the step to the motor tube. The shelter depends on how far the step up rises and how much motor tube shows ahead of it. It is gone once the motor tube showing ahead of the step is as long as the step’s drop in diameter. This is unmeasured. For a 98 mm (3.9 in) airframe with a 62 mm (2.4 in) retainer, 12 mm (0.47 in) of a 54 mm motor tube shows. There the shelter lowers the rocket’s 12% to 23% from Mach 0.3 to 2.5 (Boattails faster than sound).
- Boattails. [N09] eq. 3.88 writes without defining the areas, and p. 48 says a zero-length boattail drags like “the total base drag”. Taking as the aft base would count that base twice and leave out the uncovered ring (annulus). So HPR Sim reads both as the boattail’s decrease in area (Calisto’s boattail: 0.052, against 0.046 the other way). The joint angle is at the aft end, where a curved transition ends in a blunt tip. A lip (a short step up or flare) just behind a boattail or a step down is in its wake at every speed. From Mach 0.8 a boattail’s drag rises to its supersonic wave drag (Boattails faster than sound).
- Base drag under power subtracts the thrusting motors’ cross-section from the aft base, down to zero ([N09] pp. 50–51; Loft lesson L13). Eq. 3.94 is on p. 50. On p. 51, “if the base is the same size as the motor itself, no base drag” is Niskanen’s rule from Fleeman’s Tactical Missile Design. On the Hermes A-3A’s measured flight below
Mach 0.8, whose motor case is wider than its base, this rule leaves no base drag under power and
reads low; given only the nozzle exit it reads high, as OpenRocket’s below does. The jet more
than doubled the base drag, where this rule lowers it
(Base drag under power against the Hermes A-3A’s flight). On one private design’s supersonic flight,
C06/1, the choice moves HPR Sim’s apogee difference from OpenRocket’s from +13.60% to −10.71%. That is about 24 percentage points, more than any other known cause (#222, open on both this and the supersonic pressure drag).DragConditions::thrusting(reynolds_per_m, motor_area_m2)takes the cross-section of the burning motors from the flight engine (zero when unknown: no relief). The base belongs to the last body component.- OpenRocket’s rule, for comparisons. OpenRocket 24.12 does not take the motor off. While a
motor burns, its base drag is the whole base’s. A committed probe measures this.
validation/oracles/openrocket/base_drag.pyrecords OpenRocket’s base drag on its own example designs, the rows while a motor burns against the rows after, invalidation/fixtures/ork/openrocket-base-drag.json. A test inhpr-validateholds it (ADR-097, the decision on sizing a drag cause). On all 42 of its flights of one data branch (nothing separating), the base drag under power is exactly the whole base’s, to 1e-12. Their motors cover 9% to 94% of the reference area, and one flight’s motors are in pods. On a rocket whose motor fills most of the base, the rule is a large difference under power. OnC06/1, switching HPR Sim to OpenRocket’s base rule alone lowers its apogee from +13.60% to −10.71%, 24.3 percentage points. Switching the rest of the drag to OpenRocket’s then raises it to +1.11%, 11.8 percentage points. The second number is by subtraction, and the split depends on which change is made first (a supersonic flight).AeroModel::with_full_base_drag_under_power()andSimulation::with_full_base_drag_under_power()fly OpenRocket’s rule. A sustainer lit after a powered separation keeps it. They exist to size a difference from OpenRocket, not as a better model. HPR Sim keeps Niskanen’s rule of taking the motor’s area off the base by default. - Supersonic pressure drag against OpenRocket. Faster than sound, the pressure on the nose, the fins’ edges and any step is mostly wave drag. On that flight HPR Sim’s supersonic pressure drag is about twice OpenRocket’s. OpenRocket gives the nose almost none well above Mach 1, and the fins about a quarter of HPR Sim’s. Which is right is open, since neither has been checked against a measurement on that shape (#222). A public probe has since recorded the nose’s part: OpenRocket 24.12’s is a confirmed defect (a tangent ogive past Mach 1).
- OpenRocket’s rule, for comparisons. OpenRocket 24.12 does not take the motor off. While a
motor burns, its base drag is the whole base’s. A committed probe measures this.
- Fins. Each fin set is its own term with its own thickness, chord and cross-section, so their order doesn’t matter (Loft lesson L11). is the mean aerodynamic chord and the leading-edge sweep. The sweep is for a trapezoid and the span average for freeform outlines ([N09] p. 50). For an ellipse it is , (the closed-form average, with its form for ). The drag goes as , whose span average is 6% lower than of the average angle for an ellipse of . Fin-body interference drag and tip vortices are neglected ([N09] p. 41).
- Launch lugs. in eq. 3.95–3.96 is taken as the outer diameter. [N09] p. 52 treats a solid
rail pin as a lug “with a length equal to its diameter”. That fits only the outer diameter (Loft lesson L14). A row of
countlugs iscountlugs. Rail buttons follow [N09]’s rail-pin rule on their side profile (base and flange at the outer diameter, waist at the inner). - Angle of attack (derived coefficients). [N09] §3.4.7 describes, without an equation, a two-part polynomial taking 1 at 0°, 1.3 at 17° and 0 at 90°, with zero slope at each. HPR Sim uses the unique cubic on each part that meets those four conditions. is positive toward the tail. Past 90° the flow meets the tail, and HPR Sim mirrors with the sign reversed, , an assumption that keeps drag opposing the motion. The planned OpenRocket comparison (M2.2) will check it against OpenRocket, whose polynomial may differ.
- Refusals, not clamps (Loft lesson L16). Geometry the terms can’t use is an error naming the component. Examples are a lug wall
thicker than its radius and a button’s base and flange taller than the button. Another is a negative roughness,
which
Rocket::layoutalready refuses. A coasting condition (no motor burning) with a motor area is an error, and so is a non-finite result. Large coefficients are returned as they are. - Override tables (
DragTable) replace HPR Sim’s own with curves of against Mach number from another tool, power-off and power-on. They are read from CSV text in one of two layouts. One is two columns, optionally under a header (RocketPy’s curves;\r\n, a byte-order mark and01.05accepted). The other is a header naming the column, with rows at non-zeroAlphaskipped (RASAero II’s export:Mach, Alpha, CD, CD Power-Off, CD Power-On, …). An identical repeated row is skipped; a Mach number repeated with another value, or out of order, is refused with its line, not sorted. Tables interpolate linearly and hold their end values;Drag::tablereports any extrapolation.DragConditions::thrustingselects the power-on curve. A table’sreference_diameter_m, when set, rescales it to the rocket’s reference area. The angle-of-attack factor still applies, and an override accepts any Mach number.AeroModel::buildup_componentsalways reports the buildup, table or not. The normal force has a table of its own (The normal force from RASAero II).
A part’s stated drag coefficient
A part’s or stage’s stated drag coefficient flies as OpenRocket 24.12 flies it. The change it makes to the rocket’s drag is within 0.0059 of OpenRocket’s on 25 probe designs. The exceptions are lugs and buttons, up to 0.072, HPR Sim’s own lug and button drag being higher. Faster than Mach 0.6, a nose or a boattail is an exception too. This checks the rule, not the rocket’s whole drag, and the stated number itself is the designer’s.
OpenRocket lets a part say its own drag coefficient, in place of the drag its shape gives (the
Override tab’s drag coefficient, saved as <overridecd>). Designers use it for a part whose
drag they measured, and for “hacks”. One is OpenRocket’s Base drag hack example, which hangs a
weightless, dragless cone behind the rocket to make OpenRocket count a second
base. HPR Sim reads the setting from a .ork into
DragOverride, a part’s or stage’s
drag_override. OpenRocket’s documentation names the checkbox but not what it replaces. So the rule below was measured on 25 probe designs
(drag_override.py;
ADR-167, a part’s drag override as OpenRocket flies it).
- The coefficient is on the rocket’s reference area, the same at every Mach number. It is counted once per instance: per fin of a fin set, per lug or button.
- It replaces all of the part’s own drag: friction, pressure drag, and the base drag of its aft face. That covers the rocket’s base and a step down to a narrower part behind it. A step up at its fore end is its own face too. A step down just ahead of it stays: that is the aft face of the part in front.
- With override for all subcomponents (the design’s
include_children), the parts attached to it have no drag of their own. - On a part inside the body (an inner tube, a ring, a mass) it does nothing; such a part has no drag anyway. On a stage it is added to the rocket’s drag, or, covering its children, it is all of the stage’s drag.
- HPR Sim refuses by name what OpenRocket wasn’t measured on. Those are a coefficient on a pod set, on a part in a pod, on a tube fin set, or covering a pod set.
A worked example. OpenRocket’s Base drag hack (short-wide) is a nose, a body tube 78.7 mm (3.1 in) across, and a cone behind it. The 247 mm (9.7 in) cone widens from a point back to the tube’s diameter. The cone is stated at 0. HPR Sim’s at Mach 0.3, from the example file:
| term | drag coefficient (without the setting) | drag coefficient (with it) |
|---|---|---|
| the cone’s friction | 0.030 | 0 |
| the cone’s pressure drag, as it widens | 0.020 | 0 |
| the cone’s own base, a second base | 0.132 | 0 |
| the tube’s base, the step down to the cone’s point | 0.132 | 0.132 (the tube’s aft face, so it stays) |
| the nose’s and tube’s friction | 0.062 | 0.062 |
| fins and lug | 0.015 | 0.015 |
| total | 0.390 (rounded terms sum to 0.391) | 0.209 |
Checked against OpenRocket. On every probe, the change in the rocket’s drag from the same
airframe with nothing stated is held to OpenRocket’s
(a_stated_drag_coefficient_moves_the_drag_as_openrocket_s).
The stated number is the same in both, so what differs is each code’s own drag of the parts it
replaces.
| probes | held to | a wrong rule would move it by |
|---|---|---|
| bodies, at every Mach number | 0.0065 (largest 0.0059) | 0.043 or more: a step charged to the wrong part |
| a nose or a boattail stated | 0.0065, up to Mach 0.6 | the same |
| lugs and buttons stated | 0.075 | 0.5: one counted once, not per instance |
| a tube covering its children | 0.0065, less the lugs’ and buttons’ own gaps | 0.03 or more: a lug or button left uncovered |
| a stage covering its children | exactly 0.5 in both | anything left uncovered |
| fins | 1e-4 | 1.0: three fins counted once |
| a stage alone, an inner part | 1e-9 | none |
Faster than Mach 0.6, the two codes’ own drag of a nose and a boattail differs by up to 0.21 and 0.061. That is the drag buildups’ difference, not the setting’s.
What it leaves out. When an aft part is stated, OpenRocket also raises the friction of the parts left. On the Base drag hack example the rise is 6.8% of their friction (about 1% of its ), as though the body were shorter. HPR Sim keeps each part’s friction as its shape gives it: the parts are all still there.
On the example’s flights. With recovery in both, Base drag hack reads +1.95% and +4.52% on OpenRocket’s apogee on C11-5 and D12-3 motors, and +7.80% on an E12-4 (the report’s descent.apogee_m, tabled). Flown on OpenRocket’s
own drag curve, HPR Sim comes within 0.1% of OpenRocket’s flight with nothing deployed. So what is
left is the drag coefficient: by OpenRocket’s breakdown, the stubby ellipsoid nose (0.58 calibers long). OpenRocket gives it 0.064 at Mach 0.3. HPR Sim gives it 0.0008, read off a straight line
between Hoerner’s two measured round heads. These are a hemisphere at 0.01 and a longer head at −0.05
(blunt ellipsoids). A one-off probe, not committed, found that
about 0.013 to 0.015 would bring the E12-4 within 5%, more than the hemisphere’s 0.01. The gap
stays, and the 5% bar is not met. Nothing here measures which program’s nose drag is nearer the truth. But the measurement puts a head this long at or below the hemisphere’s (ADR-173,
a blunt ellipsoid’s measured drag; #177).
Drag through Mach 1
Near the speed of sound a nose starts to push shock waves ahead, and the pressure on its
surface climbs: the transonic drag rise. Past Mach 1 this pressure drag, called
wave drag, settles
to a value set mostly by the nose’s shape and how slender it is. HPR Sim follows Niskanen’s method
([N09] §3.4.3 and appendix B, pp. 47–48 and 106–110) for noses, shoulders and steps. The other
terms already had faster-than-sound forms in the table above. These are friction’s Mach correction,
base drag’s , the fins’ leading and trailing edges, and the stagnation pressure on blunt
faces. The code is hpr_aero::nose_drag; the decision
record is ADR-028. How far it holds against a wind tunnel is under
Verification. In the tunnel HPR Sim’s drag reads high at every row: least with fins on at Mach 1.0, most with fins on past Mach 1.2.
A nose’s or shoulder’s pressure-drag coefficient, on the area it adds, has three parts:
- At rest, eq. 3.86’s , with the joint angle at the aft end (the table above). A step, or a bare front face, has no length, and takes the flat face’s at every Mach number instead (below).
- From , the Mach number where the transonic formula takes over, a transonic and supersonic value . is 0.8 or 1 by shape, in the table below. An ellipsoid has its own curve at every Mach number. depends on the shape and the fineness ratio . For a nose, is its length over its base diameter. For a shoulder, it is its length over its rise in diameter, so a conical shoulder drags like the cone with the same surface angle.
- Between rest and , eq. 3.87: , with and chosen so the curve meets and its slope at : and . Here . Niskanen asks for a curve that doesn’t fall and is flat at rest, which needs and ; otherwise HPR Sim uses a quadratic (below). With near 10, as for slender cones, the curve stays close to its value at rest until about Mach 0.8.
| shape | source | ||
|---|---|---|---|
| step up in radius, or a bare front face | a flat face: , at every Mach number | n/a | [N09] eq. B.1–B.2 |
| cone | at Mach 1 with slope ; from Mach 1.3; a cubic between, meeting both ends’ values and slopes; | 1 | [N09] eq. B.3–B.6 |
| ogive | the cone of the same length and diameter, times , the tangent ogive’s arc radius over this one’s (0 for a cone, 1 for a tangent ogive) | 1 | [N09] eq. B.8 |
| power series, parabolic series, Haack series | Stoney’s measured curve at fineness 3, , scaled to the nose’s fineness by , , with the flat face’s | 0.8 | [N09] eq. B.7, B.9; [S61] Fig. 12 |
| elliptical | below Mach 0.8, Hoerner’s low-speed forebody drag, interpolated in fineness; from Mach 1.2, Stoney’s ellipsoid scaled as above; a straight line between (blunt ellipsoids, below) | none: its own curve throughout | [H65] p. 3-12, Fig. 20; [N09] eq. B.9; [S61] Fig. 12; ADR-173 |
Here is the ratio of specific heats of air and the stagnation-pressure ratio of the table above. The fineness scaling is the curve through a flat face at fineness 0 and the measured nose at fineness 3 (eq. B.7). Stoney’s report suggested that fineness and Mach number act separately ([N09] p. 108).
Stoney’s curves. Stoney’s 1961 NASA report collected the drag of about 200 bodies flown on
rockets at NASA Langley ([S61]). Its Figure 12 plots the pressure drag of noses of fineness 3
against Mach number. Panel (a) is from flight models, Mach 0.8 to 2.0; panel (b), from a wind tunnel (his ref. 30), to Mach 3.6. No table prints them, so HPR Sim carries them as points read off
a 600-dpi scan of the figure, to about ±0.0015. Each panel’s grid is calibrated where the curve runs.
HPR Sim takes panel (a) for the seven shapes it has, and panel (b) for the and the ellipsoid,
which only it has. Where (a) and (b) overlap, (b)’s von Kármán reads 0.004 to 0.011 higher from
Mach 1.2. Past a curve’s last point HPR Sim holds its last value. Panel (b) checks two of those holds. Its von Kármán reads 0.079 to 0.086 from Mach 2.4 to 3.59, against panel (a)’s held 0.079. Its falls to 0.073 by Mach 3.2, 8% under the held 0.079. Panel (a)’s is still
rising at its end. The and the ellipsoid, which panel (b) starts at Mach 1.2, are joined by a
straight line to 0 at Mach 0.8. Every smooth 3:1 nose of panel (a) reads 0 there, so every measured
shape starts at Mach 0.8. An elliptical nose of another fineness draws its own line, after the
scaling, from its low-speed value, held to Mach 0.8
(blunt ellipsoids). The points and where each was read
are in the code (StoneyNose). A sample of the pressure
drag coefficient, on the nose’s base area (panel (a)’s values at Mach 3.0 are its held end values):
| Mach | von Kármán coefficient | L-V Haack coefficient | parabola coefficient | ¾ parabola coefficient | ½ parabola coefficient | coefficient | coefficient | coefficient | ellipsoid coefficient |
|---|---|---|---|---|---|---|---|---|---|
| 0.9 | 0.000 | 0.000 | 0.000 | 0.000 | 0.015 | 0.013 | 0.000 | n/a | n/a |
| 1.0 | 0.025 | 0.025 | 0.037 | 0.069 | 0.094 | 0.085 | 0.046 | n/a | n/a |
| 1.2 | 0.076 | 0.100 | 0.116 | 0.104 | 0.114 | 0.109 | 0.080 | 0.141 | 0.111 |
| 1.5 | 0.089 | 0.116 | 0.108 | 0.082 | 0.088 | 0.093 | 0.086 | 0.181 | 0.151 |
| 2.0 | 0.079 | 0.112 | 0.107 | 0.081 | 0.086 | 0.079 | 0.090 | 0.216 | 0.158 |
| 3.0 | 0.079 | 0.112 | 0.107 | 0.081 | 0.086 | 0.079 | 0.090 | 0.246 | 0.160 |
Stoney’s model numbers: von Kármán 58, L-V Haack 60, parabola 59, ¾ parabola 62, ½ parabola 57, 61, 63.
A shape between two measured ones interpolates between their curves in its parameter, before the fineness scaling ([N09] p. 108). The parameter is the exponent , or of Shapes. A power series runs through a flat face (), , , and the 3:1 cone (). A parabolic series runs through the 3:1 cone () and the ½, ¾ and full parabolas. A Haack series runs between von Kármán () and L-V Haack ().
Worked example. A 5:1 von Kármán nose at Mach 1.5. Stoney’s 3:1 von Kármán gives 0.0893. The flat face gives
The exponent is , so the nose drags
on its base area. A 5:1 cone drags 0.0653 there, from
eq. B.4, so the von Kármán’s wave drag is 38% lower. The test
nose_drag::tests::the_guides_worked_example pins these numbers.
Where HPR Sim departs from, or adds to, the source (ADR-028):
- Short cones and ogives. Below fineness 1 the cone formula runs past a flat face’s drag. As the cone flattens, eq. B.4 tends to 2.39 at Mach 2 against the flat face’s 1.41. So below fineness 1 HPR Sim scales between a flat face at fineness 0 and the whole curve of the cone at fineness 1. It does so at every Mach number, as eq. B.9 scales the measured shapes. A shoulder then tends to a bare step as it shortens (Loft lesson L15), and above fineness 1 Niskanen’s cone is unchanged.
- Steps. A step up in radius, or a body with no nose cone, is a flat face, the blunt cylinder’s at every Mach number. The value is 0.85 at rest, 0.9947 at Mach 0.8, 1.0888 at Mach 1 and 1.4118 at Mach 2. Eq. 3.86 “does not take into account the effect of extremely blunt nose cones (length less than half of the diameter)” ([N09] p. 47). A step has no length, so eq. 3.86 does not cover it. Before M1.8b1 it was eq. 3.86’s 0.8 at every speed.
- Blunt ellipsoids. An elliptical nose has its own curve below Mach 1.2, from Hoerner’s measurement (blunt ellipsoids).
- Where eq. 3.87 has no solution. An nose meets its tube at a small angle, so it has some drag at rest. But Stoney’s measured curve is still at 0 at Mach 0.8, so no can rise from the first to the second. Eq. 3.87 needs the transonic value above the value at rest and . Where either fails, HPR Sim goes from the value at rest to along instead. That curve is continuous, flat at rest, with a kink at . Falling, as here, it follows Stoney’s measurement rather than Niskanen’s assumption that the curve doesn’t fall; the coefficients are below 0.01. Rising, it serves near-flat noses. A power series has almost nothing at rest by eq. 3.86, which leaves bluntness out, and rises along it to 0.80 at Mach 0.8.
- Refused shapes. A bulged secant ogive (its arc radius below the tangent ogive’s) is outside eq. B.8. A Haack series past is outside Stoney’s data (Niskanen limits it the same way, p. 103). The drag buildup refuses both, naming the component, when asked for drag. The model still builds, so the normal force, the center of pressure and a drag table work.
Blunt ellipsoids below Mach 0.8
This covers an elliptical nose’s pressure drag below Mach 1.2 (ADR-173, a blunt ellipsoid’s measured drag). Stoney’s ellipsoid curve is 0 at Mach 0.8, and eq. B.9 keeps it 0 at any fineness. So before, an ellipsoid nearly as blunt as a flat face got no drag below Mach 0.8, though a flat face gets 0.85. Hoerner measured the forebody pressure drag of round heads on a cylinder at low speed, from their pressure distributions ([H65] p. 3-12, Fig. 20). HPR Sim now uses it:
- A hemisphere (0.5 calibers long) reads 0.01, and a round head about one caliber long −0.05. The suction on its shoulder outweighs the stagnation pressure at its tip.
- Between them, a straight line, falling 0.12 per caliber past the hemisphere. It crosses 0 at 7/12 caliber, and HPR Sim holds it there, since it never charges a negative pressure drag.
- Blunter than a hemisphere, eq. B.9’s form between the flat face (, 0.85 at Mach 0) and the hemisphere’s 0.01. This is HPR Sim’s interpolation: nothing in Fig. 20 measures an ellipsoid between the two.
- From the hemisphere up, the value holds to Mach 0.8, and blunter heads follow the flat face’s rise with Mach number. That is HPR Sim’s assumption. The measurement is at low speed, and the drag rise begins near the critical Mach number, about 0.65 to 0.7 for a hemisphere.
- From Mach 0.8, a straight line to Stoney’s curve, scaled to the nose’s fineness, at Mach 1.2, its first point. This is HPR Sim’s join, not data. The scaling comes first, then the line; scaling the line instead, as before, made the drag rise with an infinite slope at Mach 0.8.
Worked example. A ¼-caliber ellipsoid at Mach 0: , where 1.25 is 1 + ¼ and 1.5 is 1 + ½ (the hemisphere), is . Base drag hack’s 0.577-caliber nose lies on the line:
The test
nose_drag::tests::a_blunt_ellipsoid_takes_hoerners_measured_forebody_drag pins both.
Cross-check against a measured cone. Stoney’s Figure 12(a) also has a 3:1 cone. Niskanen’s
closed form reads high through the whole rise. It reads +87% at Mach 0.8 and +105% at 0.85, where eq. 3.87
carries its Mach 1 value down. It reads +49% at Mach 1 and +48% at 1.1, where the cubic join is near its
peak, 0.234 against the measured 0.158. Then it reads +15% at Mach 1.5 and +4% at Mach 1.94, the curve’s end
(nose_drag::tests::niskanens_cone_against_stoneys_measured_cone). Ogives inherit this. So a
stubby cone or ogive gains the most drag at high subsonic speeds. Bella Lui’s 1.55:1 tangent ogive
takes its whole rocket’s at Mach 0.9 38% above the model before
M1.8b1. That model held the nose at its value at rest. That change moves under 1% on Calisto and Prometheus, with
von Kármán noses (ADR-028).
Boattails faster than sound
A boattail narrows the body toward the tail, usually to shrink the flat
base behind it. Below Mach 0.8 HPR Sim keeps Niskanen’s boattail rule from the table above, a share
of the base drag, and the base behind an attached boattail keeps of the flat-base drag,
the base’s diameter over the boattail’s fore diameter: 0.6 for a 4.8 in base behind an 8 in body
(Stoney’s rule from tunnel data, held to one measured flight; ADR-362 and
the base against a measured flight).
Faster than sound two more things happen. The air turns inward around the
boattail’s shoulder and expands, as in a Prandtl-Meyer expansion.
It speeds up, its pressure falls below the free stream’s, and it pulls back on the boattail. That
is a wave drag, and on a short, steep boattail it can be the largest
drag term on the rocket. Behind the boattail, the base’s pressure is higher than behind a plain
cylinder, which lowers the base drag. Code: hpr_aero::afterbody.
Decision: ADR-030.
None of the Arcas Robin’s 11 fins-off readings from Mach 1.5 is within 10%. Of Calisto’s 17 supersonic rows against RASAero II, 8 are. Theory that leaves out the air’s viscosity (inviscid theory) reads such boattails up to about 20% high ([CS51] p. 17). The rules for a boattail drawn in parts, a lip in its wake and the gaps between apply at every speed. The last three rows of the table are judgments that no measurement checks but the Arcas Robin’s lip.
In the table, a boattail runs from diameter to over its length . is its area ratio, its half-angle (the cone through the same ends; curved boattails are taken as that cone). Coefficients are on its fore area , the cross-section where it starts. is the pressure coefficient after the Prandtl-Meyer turn, and the base drag coefficient of the table above. is the base’s area over and a cylinder’s base pressure over a boattail’s. “Jet off” means the measurements were made with no motor exhaust.
| piece | what HPR Sim does | source |
|---|---|---|
| wave drag, attached flow | MIL-HDBK-762’s chart for conical boattails, against for from 0.25 to 0.80, read into the code (±(0.005 + 2%)) | [762] Fig. 5-122, p. 5-187 |
| its upper limit | never more than the pressure after a two-dimensional Prandtl-Meyer turn through over the whole annulus, ; past the chart’s end at the drag approaches that limit, the gap shrinking as | [R1135] eq. 44, 171c |
| separation | between 16° and 30°, a straight-line blend in from the attached value to the base drag on the annulus, , where flow separates | [C57] pp. 6, 8 |
| through Mach 1 | the rule to Mach 0.8, where the buildup’s other transonic terms start; a straight line to Mach 1; from there the attached drag held at its Mach 1.2 value to Mach 1.2 | [N09] p. 47, [762] p. 5-47 |
| base behind a boattail | from Mach 2.5, , with the cylinder’s pressure from Love’s correlation of measured bases, turned into the ratio of the two base-pressure coefficients, , which multiplies HPR Sim’s own base drag; below Mach 2.5, at Mach 2.5; to Mach 0.8, , a conical afterbody’s base drag scaling with on the largest cross-section where the rule on the base’s area scales with its square; a straight line between Mach 0.8 and 1; none for a separated boattail | [762] Figs. 5-139, 5-141, pp. 5-208, 5-210; [S61] p. 11; [H65] p. 3-20, eq. 35 |
| a lip in its wake | a lip behind a boattail or a step down (a boattail of no length), drawn as a shoulder, a step up or both, in one part or several, loses its pressure drag while its top rises up to a quarter of the boattail’s drop in diameter above the boattail’s end, keeps all of it from half, and a straight-line share between; a lip in parts takes at each part the smallest share any top so far leaves; the base behind it takes the same share of the relief, less the lip’s length’s fade. A lip’s rise is its top diameter less the boattail’s aft diameter. | [D4014] p. 6, [R22] slide 2; the quarter and half are a judgment |
| a boattail in parts | a narrowing part after another drags, as its share of the boattail it continues, as the cone from that boattail’s start through its aft end less the cone through its fore end (below 0 where extending the boattail lowers its drag); so parts of one straight cone add up to one cone. Its drag is that share for a turn of up to 3° between the parts, its own drag as a boattail from 10° (a corner), and a straight-line blend of the two between (the turn is the difference of the two parts’ half-angles) | a judgment |
| gaps and steps | whatever lies between a boattail and what follows weakens its effect in a straight line, gone once the gaps add up to one of the boattail’s drops in diameter; gaps add: the lengths of tubes, lips and parts, and the drops in diameter of steps down and narrowing parts. | a judgment |
The last three rows in full.
- A lip in its wake. A motor retainer behind the step down to its motor tube loses much of its step’s drag: behind a 98 mm (3.9 in) airframe stepping down to a 54 mm motor tube, a 62 mm (2.4 in) retainer rises 8 mm (0.31 in), 0.18 of the 44 mm (1.7 in) drop, so its rise alone would shelter it wholly, and the 12 mm (0.47 in) of motor tube ahead of it fades that by 12/44: its step keeps 27% of its drag (
a_retainer_behind_a_step_down_is_in_its_wake), and the rocket’s reads 12% to 23% lower from Mach 0.3 to 2.5 than with the retainer’s step in full (the physics review’s measurement; unmeasured in any tunnel). With the exposed motor tube as long as the 44 mm (1.7 in) drop, its step keeps none. - A boattail in parts. When either part is shallower than 1°, the merge is scaled by the smaller angle over the larger (the larger taken as at most 1°), so a part narrowing by almost nothing acts as a tube and a straight cone of any angle drawn in parts merges wholly. The merge holds at every speed, so below Mach 0.8 a curved boattail in parts drags as the cones through its ends, not part by part as eq. 3.88 would.
- Gaps and steps. With several boattails ahead, the flow is shared among them: a narrowing part takes over the share it merges with, and takes what no boattail holds as its own; a step down counts as a boattail of no length. The base and each lip add the boattails’ shares. So a part narrowing by nothing drags as a tube, a part of no length as a step, and a small change in any radius or length changes the drag a little.
Why each piece is there:
- The chart is second-order theory. MIL-HDBK-762 cites no source for it. Jack computed conical boattails from Mach 1.5 to 4.5 by Van Dyke’s second-order theory ([J53]). That theory is an inviscid method that keeps the next term past linear theory’s small-disturbance approximation. The chart agrees with his 83 points inside its range within −10.4% to +8.0% for up to 0.6. First-order (linear) theory reads far higher at these angles, so the chart is not linear theory.
- The 2D limit matters for short, steep boattails. The chart plots its drag against one combined variable, , which holds only for small angles. Near Mach 1 the chart can ask for more suction than a flat (two-dimensional) turn gives. A round boattail, whose pressure recovers aft of the shoulder, cannot exceed that. Past the chart the same limit gives the curve its shape: against Jack’s 28 points beyond it, −2.7% to +8.0%.
- Near Mach 1 no method exists for boattails. [762] p. 5-47 says so and advises holding the supersonic value to a peak between Mach 1.0 and 1.2. The straight line starts at Mach 0.8, where HPR Sim’s other transonic terms start, and is half-way up at 0.9. The measured rise is later and steeper. It is half-way by about 0.89 for Compton’s 10° boattail ([C72]) and 0.92 to 0.96 for Cubbage’s ([C57]). The rise has a peak at Mach 1.0 to 1.1 that holding the Mach 1.2 value does not reach. An earlier draft started the line at Mach 0.9, a choice made after seeing the Arcas Robin, one of the targets. The validation audit caught it, and it was put back to 0.8.
- The base’s relief is the handbook’s correlation, measured at Mach 2.5 to 3.5. Used as a ratio of pressures below Mach 2.5, it over-predicts the relief of the bases measured at Mach 1.59 and 1.91 ([DN54], [CS51]). Held as a ratio of coefficients, it matches them on average. It depends on the base’s area only, where the measured relief also grows with the boattail’s angle. Behind Cortright and Schroeder’s small bases () HPR Sim keeps 0.352 of the cylinder’s base pressure coefficient at every angle. Cortright and Schroeder measured 0.60 at 5.6° and 0.26 at 9.3°, against 0.352.
- The lip. NASA’s Arcas Robin models end in a lip 1.3 mm (0.051 in) long that flares from the boattail’s end to the base. NASA found the lip lowering the force on the balance chamber inside the base at Mach 1.5 and 1.8 with the fins off. The lip’s effect was “masked” when the flow over the boattail separates or the boundary layer thickens ([D4014] p. 6). RASAero II’s own comparison with the tunnel left it out as “buried in the boattail boundary layer” ([R22]). HPR Sim used to take it as a stubby cone in undisturbed air, 0.085 of drag. The quarter and half that bound the wake were chosen knowing this lip rises 0.17 of its boattail’s drop. Every one of the 44 Arcas Robin rows depends on that choice. With the lip counted as a shoulder in undisturbed air, each would read 0.065 to 0.086 higher.
A worked example: Calisto at Mach 1.5. Calisto’s boattail is 60 mm (2.4 in) long from 127 mm (5.0 in) to 87 mm (3.4 in): , , . The chart’s is , where it gives . A Prandtl-Meyer turn of 18.4° from Mach 1.5 gives , so the limit is , and the attached boattail drags 0.211. At 18.4° it is 17% of the way from 16° to 30°. So the blend takes the drag 17% toward the base drag on the annulus, : 0.190, where the rule gave 0.066. For the base, : at Mach 2.5 Love’s cylinder gives , so
so ; after the blend
0.683, so the base’s drag falls from 0.078 to 0.053. Calisto’s at Mach 1.5 rises from
0.443 to 0.542. The module’s documentation test runs this example
(hpr_aero::afterbody).
Against measurements (drag-vs-mach.json, sections boattails,
base_pressures and second_order_theory, from the readings in
measured-boattails.json; tests::boattails_against_measurements). Every
source is a wind tunnel with a turbulent boundary layer and the jet off. Each value was read from
the report’s figure, with its reading uncertainty in the file. The last column says whether the
rows helped build the model: those check it on its own data.
| boattails | Mach | rows | HPR Sim against measured | helped build it |
|---|---|---|---|---|
| attached, 3° to 10°: [CS51], [DN54], [C72], [MJ54], [C57] | 1.2 to 3.12 | 58 | −21.9% to +28.3%, within 0.0123 | no |
| attached, 5.6° and 8° ([C57]) | 1.0 and 1.1 | 4 | −18.2% to −5.4% | partly: Cubbage’s peak was weighed in holding the Mach 1.2 value |
| attached, 3° to 10°, points near Mach 1 that Compton calls questionable (strut interference, reflected bow shock; [C72] p. 9) | 0.95 to 1.1 | 27 | −46.2% to +60.0% | no |
| attached, 3° to 10°, in the rise ([C72], [C57]) | 0.85 to 0.95 | 28 | −77.5% to +7.6% | no |
| attached, 3° to 10°, under the rule ([C72], [C57]) | 0.3 to 0.8 | 58 | −100% to −83.5% | no |
| 16°, attached, boundary layer thick ([C57]) | 1.0 to 1.28 | 9 | +26.4% to +54.2% | no |
| the same, below Mach 1 | 0.6 to 0.9 | 6 | −30.2% to +60.4% | no |
| 30° and 45°, separated ([C57]) | 1.2 | 3 | −2.8% to +6.6% | yes: the separation angles |
| the base behind 5° to 10° boattails ([CS51], [DN54]) | 1.59, 1.91 | 8 | base drag within 0.0102 of the measured on the cylinder’s area; behind small bases up to about 40% of the base’s own drag | yes: the ratio held below Mach 2.5 |
| the base behind 2.5° to 15° boattails ([Love57]) | 3.24 | 4 | within 0.003 | no |
The 0.0102 and 0.0123 are pins on these readings, not tolerances. Below Mach 0.8 Niskanen’s rule gives nothing to a boattail longer than three times its drop in diameter. It gives Compton’s and Cubbage’s long, gentle boattails 0 to 0.009, where they measure 0.011 to 0.075 (issue #73).
What it leaves out.
- Steep boattails in a thick boundary layer read high. HPR Sim reads Cubbage’s 16° boattails 26% to 54% above the measurements, though the flow is still attached. The boundary layer is a fifth of the diameter thick. The Arcas Robin’s 15° boattail sits in one thicker than its own drop in radius. The Arcas Robin’s forebody reads +13.5% to +24.1% from Mach 1.5 (below). No source here gives a correction, so none is applied (issue #72); MIL-HDBK-762 advises boattails under 8° to avoid separation ([762] p. 5-12).
- Through Mach 1 it reads low for gentle boattails: the straight line from Mach 0.8 misses the measured rise’s later, steeper climb and its peak.
- Separation’s 16° and 30° come from one report at Mach 0.6 to 1.28. Between 10° and 30° no attached boattail was measured faster than Mach 1.28. So a boattail of 12° to 20°, like Calisto’s 18.4°, rests on the least-validated part of the model, and likely reads high.
- For one length and area ratio, Jack found the cone’s wave drag the smallest of three shapes ([J53] p. 1). So a curved boattail likely drags more than HPR Sim gives. The chart’s 0.70 and 0.80 curves read up to 32% above Jack past , 0.0084 at most.
- A tube behind a boattail loses the base’s relief over one drop in diameter. The 3°, 10°, quarter and half that shape the merge and the wake are judgments, with no measurement behind them but the Arcas Robin’s lip. Its own 1.3 mm (0.051 in) length is a gap too: the base keeps 0.944 of its relief.
- A straight cone drawn in parts drags as one cone. A part’s share can be below 0, where the chart makes the longer cone drag less than the shorter: extending the boattail lowers its drag. The one exception is a cone behind a boattail that it only partly merges with (a turn of 3° to 10°). Its parts may drag a little less than the whole. An 8° cone behind a 14° part reads the same in 2 or 4 parts. It reads up to 0.45% lower in 8, and up to 2.2% lower drawn in hundreds, worst near Mach 1.
- The 1° below which a part merges only in part, and the fade of a step’s corner over one drop in diameter, are judgments too. Flow behind a backward-facing step reattaches farther downstream, so the fade likely understates a lip’s shelter.
- Nothing models the jet. Fig. 5-141 is measured with the motor off, as are the base drag it scales and Stoney’s subsonic rule. Under power HPR Sim applies them to what the motors leave of the base.
- Below Mach 0.8 the relief rests on one measured flight, the Hermes A-3A’s long 4.5° cone, and on Stoney’s tunnel rule, which gives no range of cone angles and does not allow for the negative base drags measured at subsonic speeds ([S61] p. 11). Measured bases behind cones read lower still (subsonic boattail base drag), so the rule likely reads high behind a long attached boattail (evidence row G41).
Drag limits
- The buildup covers Mach 0 to 5 and refuses Mach 5 and faster, like the normal force
(
drag::BUILDUP_MACH_LIMIT); an override table takes any Mach number. - It reads high against the one wind tunnel it has been measured against, at every reading. With the fins off, it reads 12% to 54% high, most of it the model’s steep boattail. With the fins on, past Mach 1.2, it reads far higher, from the fins (Verification). The fins’ leading edge takes [N09]’s rounded-edge formula, a blunt edge’s, for the airfoil and rounded sections alike. Nothing models the wave drag of a thin, sharp fin, which is far smaller. The Arcas Robin’s four double-wedge fins measure 0.046 at Mach 4.63, against HPR Sim’s 0.30.
- Against MIL-HDBK-762’s worked example, fins left out, the body reads high from Mach 0.9 to 1.2 (the nose and the base). The body reads 6% to 10% low from Mach 1.6 (friction and the base) (Drag against MIL-HDBK-762’s sample calculation).
- It reads low against RASAero II’s Calisto past Mach 1.6, −14.9% at Mach 2 (Drag against RASAero II through Mach 2). Part of that is the body’s lean above; plausible fin inputs bring most rows within 10%.
- Through the transonic rise, from Mach 0.8 to 1.2, the measured shapes follow Stoney’s curves. Cones and ogives follow Niskanen’s closed form, which reads 45% to 105% above Stoney’s measured 3:1 cone there (the cross-check above).
- Shoulders and boattails past Mach 1. A shoulder takes the nose method, except a lip in a boattail’s wake, which loses a share of it. [N09] calls the nose method “somewhat dubious at supersonic velocities” (p. 48). A boattail keeps eq. 3.88 to Mach 0.8, a rule “based primarily on subsonic data” (p. 49). The rule over-predicts the Arcas Robin’s 15° boattail and gives long boattails nothing (issue #73). Faster than sound its wave drag reads high for steep boattails in a thick boundary layer (Boattails faster than sound).
- Stoney’s curves end at Mach 1.94 to 1.99 (panel (a)) and 3.59 (panel (b)). Past that HPR Sim holds their last value, which panel (b) puts within 8% for two shapes (above).
- Stubby noses. Below fineness 1 a cone or ogive blends toward the flat face at every Mach number, so at rest it reads above eq. 3.86. A cone of fineness 0.5 gives 0.547 against eq. 3.86’s 0.400. Two routes to one shape disagree. A tangent ogive and an ellipse of fineness 0.5 are both hemispheres. The ogive rises from rest by that blend, which no measurement backs. The ellipse takes Hoerner’s measured 0.01 to Mach 0.8 and then rises in a straight line (blunt ellipsoids). Below Mach 0.8, trust the ellipse’s.
- Before M1.8b1 the buildup held nose and shoulder pressure drag at its value at rest and refused Mach 1.
- Nothing models laminar flow, fin-tip vortices, interference drag, fin tabs, fillets, canted fins or the flow a boattail guides into the base ([N09] p. 51).
Limits and verification
What the models leave open, and the checks that pin them against worked examples, wind tunnels and other programs.
Validity and open questions
- A flared body’s supersonic normal force rests on one measured flare. Since M1.8e17 a conical flare flies the shock-expansion method while its corner’s shock is attached. This moves a flared rocket’s center of pressure forward by a tenth to a quarter of a caliber against its earlier model (evidence row G28). The one measurement beside it is TN D-4865’s model 2, an 18.5° flare on a 2.75° cone. The results are −1.9% and +7.0% at Mach 1.9 and 2.3, and +13.4% at 2.96. They are +51.5% and +50.4% at 3.95 and 4.63, where that flare’s boundary layer is separated (What a marched flare is worth). No other flare angle, and no other body, has been checked. Two more things about that model are open. The attachment test is a wedge’s limit, not a flare’s own (A flare through the method). And a near-flat flare has its one element read by the older generalized method, which leaves a step at the corner’s crossing. The step is +0.129% of the normal force and 0.0051 calibers on the tests’ rocket. It is +4.3% and 0.19 calibers on a body whose shoulder is short. There the region sits at degrees rather than thousandths of one (A near-flat flare).
- A step in radius is unmodeled, and nothing measures one faster than sound. A mismatch of radius past a threshold takes the whole body off the shock-expansion method at every speed. The thresholds are 2.7e−11 m between two tubes and 1.3e−13 m stepping up at a boattail’s fore end, far below any tolerance anyone builds to. On the tests’ straight rocket that is worth −8.65% of the normal force and 1.03 calibers of center of pressure at the threshold. At a 2 mm (0.079 in) step down it is −12.55% and 1.36 calibers. On the boattailed one, it is −11.34% and 1.10 calibers (A step in radius). No published source gives a stepped body’s normal force faster than sound, so the present behavior is not known to be right either. Stopping the march at the step was built and rejected (ADR-049, issue #87: a step has no model of its own).
- The body alone misses the 15% target on six of eleven wind-tunnel rows, the one M1.8e set for the body faster than sound. The misses are +37.7% at worst (the short Arcas Robin at Mach 1.5). The body is within 5% at Mach 3.96 and 4.63. The likeliest cause is Jorgensen’s crossflow term reading too large at the few degrees a slope is fitted over. But the measurement cannot split its own slope from its curvature cleanly, and one row points at the method instead. Closing it needs a cited rule for how the crossflow term grows from zero over the first few degrees. Or it needs measurements at finer angles than the reports plot. Neither is in hand, so the gap is left visible (The body alone, against the 15% target).
- A center of pressure means little where the body’s normal force is near zero. A deep, steep transition can remove almost all the lift the nose and tube carry. HPR Sim still divides the moment by what is left. One test shape reports its body’s center of pressure 160 calibers ahead of its own nose tip at Mach 1.2. It is tracked in issue #104: a near-zero normal force gives a meaningless center of pressure. That body-alone figure is printed nowhere. Every center of pressure HPR Sim prints is the whole rocket’s. The flight applies each part’s moment as computed, so no number reads wrong (ADR-201).
- A blunt tip’s handover is capped where the method’s march still settles, not where its theory runs out. The cap is 24° and the cone slopes reach 30°. At 30° the committed Arcas Robin nose reads nearer the report’s own sphere-cone. But its answer starts to follow the element count above Mach 4, so the cap stays. What that is worth is measured on both sides in What the cap is worth. The way out is issue #108: a steeper handover puts the march into above Mach 4.
- A boattail steeper than 16° is worth 0.67 to 1.35 calibers of doubt, the most at the lowest supersonic speeds. Nothing measures a separated boattail’s supersonic normal force. HPR Sim holds the measured correlation at 16° rather than fading it, the conservative end (A steep boattail reads the correlation no steeper than 16°).
- These are small-angle models. is accepted over , but fin slopes stay linear in and nothing models stall. The flight engine uses them at every angle anyway (Rigid-body flight). So its results are least trustworthy where large angles occur: off the rail in a strong crosswind, and near apogee.
- Body lift in wind (measured by flying both codes, not against a real flight; ADR-026, ADR-037). A rocket that leaves the rail slowly in a crosswind meets the air at a steep angle. Juno III, one of RocketPy’s example rockets, leaves at 18 m/s (59 ft/s) in an 8.5 m/s (28 ft/s) wind, 26° off the airflow. There body lift is nearly half its normal force. Much of it acts ahead of the rocket’s center of mass, the nose’s above all. So body lift moves the center of pressure forward and weakens the moment that turns the rocket into the wind. HPR Sim turns into it less than RocketPy, whose normal force has no body term. Body lift’s sideways push alone is about a sixth of its effect on the drift. Juno III’s apogee ends 245.3 m (805 ft) from the pad in HPR Sim and 396.6 m (1,301 ft) in RocketPy. Body lift is about half of that difference, and HPR Sim’s rail release and fin slope most of the rest. Flown in RocketPy with HPR Sim’s model, Juno III’s apogee drift is 248.3 m (815 ft) with Jorgensen’s crossflow. There is about 0.91 at that speed (Body lift). With a constant across [G]’s range, the drift runs from 194.1 m (637 ft) at to 240.2 m (788 ft) at 1.0. The drift is 231.1 m (758 ft) at , the value HPR Sim used before M1.8e6. It would be 328.0 m (1,076 ft) with no body lift. Calisto, off the rail at 28 m/s (92 ft/s) and 11°, changes its drift by under 0.5% across that range. Which is nearer a real flight is open: the real flights so far compare heights, not drift.
- No airfoils. Fins use the flat-plate lift slope ( per radian in two dimensions). An airfoil lift curve, such as the one Juno III’s example gives its fins, is not modeled. RocketPy uses it, and its fin slope there is 7.6% steeper (ADR-026).
- In one measured case, fins at give 17.4 against a flat-plate estimate near 5. In the same case, at the fins still give 34.7 while every body term vanishes. That case is a 54 mm (2.1 in) four-fin rocket at Mach 0.3.
- Speed. The normal force and the drag buildup cover ; a drag table covers any
Mach number.
- The drag buildup’s transonic and supersonic terms are [N09]’s semi-empirical ones. [N09] expects them “to be reasonably accurate to at least Mach 1.5” (p. 94). Against the one wind tunnel they read high from about Mach 1.2 (Drag limits). On the one supersonic flight compared with OpenRocket, HPR Sim’s supersonic pressure drag is about twice OpenRocket’s (#222: which is right is open).
- Between Mach 0.8 and linear theory’s start , the normal force is the straight-line join of Fins through Mach 1. Against the wind tunnel its slope reads up to 27.1% high (Mach 1.2), and its CP 0.67 to 1.35 calibers aft at Mach 0.9: the flight margin reads high (#1198 warns). Past Mach 3 the normal force’s body terms read low (Normal force through Mach 1).
- Below the join, from Mach 0.6 (the slowest point of the TN D-4013 tunnel tests) to 0.8, the fins are still on Prandtl-Glauert, yet the short Arcas Robin model’s CP reads 0.117 calibers aft of the report’s curve at Mach 0.6 and 0.912 at 0.8, each beyond the reading’s ±0.055. The long model reads 0.360 calibers forward at Mach 0.6 and inside its ±0.071 at 0.8, so only one of the two models shows the error. Both misses depend on the angles they are fitted over: fitted on the tunnel’s plotted points over the same angles, Mach 0.6 reads −0.03 calibers over −2° to 2° and −0.49 over −3° to 4°, and Mach 0.8 +0.87 and +0.08 (the fit). Below Mach 0.6 the tunnel has no data. A flight from Mach 0.6 may have its margin read high (#1290 warns, quoting the report’s-curve figures, 0.11 to 0.92 calibers, the larger side, and the −3° to 4° fit’s 0.08). A flight past Mach 0.8 prints both #1290 and #1198: they quote different tunnel points, and aren’t added together.
- [N09] eq. 3.35–3.36 would start moving a fin set’s CP aft at Mach 0.5. By Mach 0.8 the CP would reach about 0.30 of the way along its mean aerodynamic chord (MAC, defined under Fins) for aspect ratio 1.6. Aspect ratio measures how long the span is against the chord. HPR Sim keeps 0.25 to Mach 0.8: the Arcas Robin’s measured CP moves forward, not aft, from Mach 0.6 to 0.8.
Verification
-
Barrowman’s worked examples (
hpr_aero::tests::barrowman_worked_examples). Inputs and printed results, with page numbers, are in the fixturevalidation/fixtures/aero/barrowman-worked-examples.json. Every printed component and total must agree within 1%. Measured:example slope , per rad: HPR Sim / printed CP: HPR Sim / printed (in) Testbed II [B66] pp. 41–45 21.397 / 21.44 (−0.20%) 16.703 / 16.7 (+0.02%) Aerobee 350 [B66] pp. 47–50 21.449 / 21.5 (−0.24%) 390.48 / 391 (−0.13%) Javelin [TIR] pp. 21–22 35.927 / 35.9 (+0.07%) 11.286 / 11.3 (−0.13%) Recruiter [TIR] pp. 23–25, HPR Sim’s model: outside 1% 36.416 / 35.4 (+2.87%) 15.665 / 15.6 (+0.42%) Recruiter with TIR-33’s six-fin rule substituted 35.415 / 35.4 (+0.04%) 15.627 / 15.6 (+0.17%) Arcon-Hi, two stages [TIR] pp. 27–29 96.163 / 96.2 (−0.04%) 20.803 / 20.8 (+0.02%) Arcon-Hi, sustainer alone 32.257 / 32.2 (+0.18%) 17.845 / 17.9 (−0.31%) - With HPR Sim’s own model, every CP agrees within 1%, and every slope but the Recruiter’s. Its six-fin slopes are +3.42% (fins) and +2.87% (total). Those are the only 2 of the 38 printed values (19 slopes, 19 CPs) outside 1%, and the test pins that list.
- With TIR-33’s six-fin rule substituted for the Recruiter, the worst is the Testbed II nose CP, −0.77%: [B66]’s fit against the integrated tangent ogive.
- CPs are compared as stations from the nose tip. Measured from each part’s own front, two printed values miss 1%. One is the Testbed II boattail (0.655 in against 0.72 in, −9%, Barrowman’s diameter ratio slip). The other is the Javelin fins (0.653 in against 0.66 in, −1.1%, rounding).
- Recruiter’s six fins. TIR-33 scales six fins by with and no fin-count factor. With HPR Sim’s own rule (0.913 and the full ), the fins are +3.42% and the total +2.87% from the print. The difference between the two rules accounts for +3.22% and +2.83% of that. The test checks the TIR-33 rule within 1% (slopes and CP weighting) and reports HPR Sim’s own values. It checks that the rules differ by more than 2%.
- The printed mid-chord lengths were measured or rounded. HPR Sim computes them from the geometry (Aerobee: 39.7 in printed, 40.50 in geometric). The fixture’s notes list each slip in the printed arithmetic.
-
Loft lessons, each with what it concerns:
- L7, a fin slope and CP that never changed with Mach:
fins::tests::fin_cna_compressibility_reduces_to_barrowman_at_m0 - L8, no correction for five to eight fins:
fins::tests::six_fin_cna_applies_fin_count_factor - L9, the conical transition’s CP formula used for every shape:
body::tests::ogive_transition_cp_uses_volume_form - L10, elliptical fins given a trapezoid’s sweep:
fins::tests::elliptical_fin_cna_uses_zero_midchord_sweep - L89, Barrowman’s values worked by hand, a check kept from Loft’s tests:
tests::barrowman_hand_values. A cone’s slope is 2 with its CP at ( its length). A conical transition from 20 to 40 mm (0.79 to 1.6 in) radius over 0.1 m (0.33 ft) has a slope of 1.5. Its CP is 0.05556 m (0.1823 ft) aft of its fore end. An elliptical fin’s CP is aft of its root leading edge.
- L7, a fin slope and CP that never changed with Mach:
-
Limits and invariants (
body::tests,fins::tests,model::tests):- Cylinders and thin transitions; body lift at 0 and 90°.
- Eq. 57 and 76a closed forms against the same trapezoid as a polygon (1e-13).
- A 2000-gon ellipse, and a jagged fin.
- Prandtl-Glauert against [B67] eq. 3-6 written with the aspect ratio, and its limit.
- Roll sums against direct sums; a two-fin set along and across the flow.
- Mach changes only the fins.
- Supersonic linear theory on a rectangle, whose slope and CP have closed forms, including a tip cone that crosses the root.
- Outlines of each planform; where linear theory starts.
- A proptest (a rule checked on many random inputs): scaling every length leaves slopes unchanged and scales the CP; the reference diameter scales slopes only.
- Refusals: nine fins, Mach 5 for the normal force and for the drag buildup, angles out of range.
Normal force through Mach 1
Two references, in the fixture
validation/fixtures/aero/normal-force-vs-mach.json,
which cargo xtask aero writes and tests::normal_force_against_mach recomputes and pins
(ADR-027). The targets, set before measuring: within 15% and the CP within 0.5 calibers (a caliber is one reference diameter). 13 of the 37 rows miss, each for a measured
reason below.
- A wind tunnel. NASA tested half-scale models of the Arcas Robin sounding rocket from Mach 0.6 to 4.63 ([D4013], [D4014]). The short model has a nose 4.2 calibers long, a cylinder, a 15° boattail and four trapezoidal fins swept 30°, 18.2 calibers long in all. A longer version is 23.8 calibers long. The reports print only plots, so their points were read off the pages into
validation/fixtures/aero/arcas-robin-wind-tunnel.json. It records every figure and page, and each is read to about ±0.01 to ±0.02. The designs model the reports’ nose, a table of coordinates rather than a named shape, as a power-series nose with the same volume. That sets its slender-body CP. They model the planform within 2.4%. The slope is the straight line fitted through the plotted from about −4° to +4°. So HPR Sim’s is fitted the same way at the same angles. Its CP is taken over −2° to 2°, the reports’ low angles. - RASAero II, another code, for Calisto from Mach 0.1 to 2.0. Its potential-flow slope and CP come from the export RocketPy’s first commit shipped. The slope is the attached-flow part, without the crossflow lift its export adds from Mach 0.95. They are compared with HPR Sim’s small-angle values.
The short model (the Arcas Robin itself, 18.2 calibers long), rows outside the targets in bold. The last column is the body alone: the fins-off wind-tunnel reading, and HPR Sim’s body terms fitted the same way. The design’s lip sits in the boattail’s wake and carries nothing faster than sound (A lip in a boattail’s wake). The design’s vertical tip flies behind a Newtonian cap (Blunt tips). So the body flies the method to its base from Mach 1.2. With fins off it reads 3.02 to 3.95 per radian from Mach 1.5, where it read 1.90 to 2.09 on slender-body theory. Below the join its body lift grows as and with the crossflow Mach number. So the body terms’ fitted slope moves a little with Mach and with the angles each plot covers (1.90 to 2.09). From Mach 0.6 to 1.2 the fins-off readings, on a coarse grid (±0.02 per point), scatter from 1.41 to 2.88 with no trend. So they don’t settle whether HPR Sim’s 1.91 is high there.
| Mach | measured, per rad | HPR Sim, per rad | difference | CP measured, m | HPR Sim CP, m | difference, calibers | body alone, measured / HPR Sim, per rad |
|---|---|---|---|---|---|---|---|
| 0.6 | 11.05 | 10.54 | −4.6% | 0.7770 | 0.7837 | +0.12 | 1.53 / 1.91 |
| 0.8 | 9.92 | 10.85 | +9.5% | 0.7375 | 0.7896 | +0.91 | 1.41 / 1.90 |
| 0.9 | 10.22 | 12.77 | +25.0% | 0.7447 | 0.8215 | +1.34 | 2.44 / 1.91 |
| 0.95 | 11.88 | 13.74 | +15.6% | 0.7952 | 0.8342 | +0.68 | 2.88 / 1.92 |
| 1 | 15.79 | 14.69 | −6.9% | 0.8690 | 0.8455 | −0.41 | 1.58 / 1.92 |
| 1.2 | 15.42 | 18.54 | +20.2% | 0.8862 | 0.8798 | −0.11 | 2.43 / 1.92 |
| 1.5 | 13.43 | 14.61 | +8.8% | 0.8137 | 0.8282 | +0.25 | 2.19 / 3.02 |
| 1.8 | 11.99 | 12.46 | +3.9% | 0.7908 | 0.7883 | −0.04 | 2.61 / 3.29 |
| 2.3 | 9.89 | 10.50 | +6.2% | 0.7505 | 0.7369 | −0.24 | 3.08 / 3.60 |
| 2.96 | 8.77 | 9.10 | +3.7% | 0.6967 | 0.6858 | −0.19 | 3.28 / 3.84 |
| 3.96 | 7.73 | 7.85 | +1.6% | 0.6312 | 0.6330 | +0.03 | 3.88 / 3.95 |
| 4.63 | 7.55 | 7.30 | −3.3% | 0.5876 | 0.6073 | +0.34 | 4.15 / 3.95 |
| reference, Mach | difference | CP difference, calibers | rows within both targets |
|---|---|---|---|
| Arcas, long, 0.6 and 0.8 | +0.7%, +8.9% | −0.36, +0.07 | 2 of 2 |
| Arcas, long, 0.9 to 1.2 | −8.8% to +27.1% | +0.67 to +2.36 | 0 of 3 |
| Arcas, long, 1.8 to 2.96 | +8.4% to +9.4% | −0.53 to −0.43 | 1 of 3 |
| Arcas, long, 3.96 and 4.63 | +2.8%, −2.3% | −0.13, +0.21 | 2 of 2 |
| Calisto against RASAero II, 0.1 to 0.7 | +0.1% to +10.1% | −0.08 to +0.43 | 4 of 4 |
| Calisto against RASAero II, 0.8 to 2.0 | −6.3% to +21.9% | −0.44 to +0.95 | 7 of 11 |
What the misses come from:
- Faster than sound, every slope now passes, and the long model’s CP at Mach 1.8 and 2.3 does not. Until M1.8e7 and M1.8e8 the committed designs’ vertical tip and lip kept the shock-expansion method off. So their bodies flew slender-body theory past Mach 1. They lifted 2.0 to 2.6 per rad where the tunnel’s body alone lifts 2.2 to 4.6. The short model read −16.3% at Mach 2.96 and −28.0% at 4.63. With the cap (Blunt tips) and the lip carrying nothing in the boattail’s wake (A lip in a boattail’s wake), the body grows with Mach. It grows as the measurement does, though less steeply. The whole rocket’s rows from Mach 1.5 read +8.8% to −3.3% (short) and +9.4% to −2.3% (long). What is left is the body reading high: 15% to 19% above the tunnel fins off, at Mach 1.8 and 2.3 on the long model. That pulls the whole rocket’s CP 0.53 and 0.52 calibers forward of the measured one, just outside the half-caliber target. M1.8e6 sized that excess and left it (ADR-037). The body alone is judged against the 15% target in The body alone, against the 15% target. The fins’ share is the fins-on reading less the fins-off one. It agrees with HPR Sim’s fins within −1.4% to +7.0% at Mach 3.96 and 4.63. That agreement carries about 5% of doubt of its own. Over the boattail the models’ fin roots follow its 15° surface below the cylinder. The design leaves that strip out, about 0.32 in² of each fin’s 5.8 in² (5.5%).
- Mach 0.6, within the targets by errors that cancel. Both models pass there. But HPR Sim’s body is 25% and 19% above the fins-off readings, which are poorly determined at these speeds. HPR Sim’s fins’ share is 9.3% and 3.9% below the measured one.
- Transonic, Mach 0.8 to 1.2. The fins’ measured share lifts less at Mach 0.8 and 0.9 than at 0.6, then jumps at Mach 1. HPR Sim’s fins lift more, by Prandtl-Glauert and then along the join to linear theory’s peak at (1.2 for these fins). The long model’s CP jumps forward at Mach 1, 2.36 calibers from HPR Sim’s. No closed-form method covers this region, and the join is not fitted to it.
- RASAero II keeps its slope and CP constant through subsonic flow, where HPR Sim’s rise with Prandtl-Glauert, so they part from Mach 0.8. Past Mach 1.2 Calisto’s von Kármán nose flies the shock-expansion method behind a Newtonian cap, so its cylinder carries lift. Mach 1.5 reads +12.9% and Mach 2 +8.3% (−3.1% and −16.8% on slender-body theory, before M1.8e7). The wind tunnel sides with neither there. Below that the agreement is partly by construction: the Calisto design has the 2018 fins because they reproduce this export at low speed (ADR-009). Past Mach 1 the result rests on the choice of RASAero’s columns. RASAero’s secant slope and CP to 4° include its crossflow lift. Against them, 3 of the 11 rows from Mach 0.8 are within the targets, not 7. The tightest of the three passes at Mach 1 by 0.00002 calibers. Against them Mach 2 is −9.6%. That comparison is a summary in the fixture’s
secant_comparison, not a second set of rows. The export stays inrefs/, and the fixture commits its values once (ADR-009, ADR-027). Calisto has no fins-off data, so its body and fins can’t be split as the wind tunnel’s can.
So, for fins like these, whose linear theory starts at , trust HPR Sim’s slope to about
10% from Mach 1.5 up. The rows run +9.4% to −3.3%. From Mach 1.5 up, trust its CP to about half a
caliber. The long model misses that by 0.03 at Mach 1.8 and 0.02 at 2.3. Between Mach 0.8 and
, in the join, trust neither. A fin set’s own is
FinSetAero::fin.supersonic_mach,
from AeroModel::fin_sets. Fins
swept further back start later: a leading edge swept 48° starts at Mach 1.5, and until then it is in
the join. Nothing past Mach 4.63 has been checked, though the model runs to 5.
The body alone, against the 15% target
What this covers: how far HPR Sim’s body alone is from NASA’s measurement of the same body, and where the remaining gap sits.
The milestone M1.8e set a target before any of this was built: the Arcas Robin’s body alone within 15% at every Mach number from 1.5. It had a second part: both configurations’ whole-rocket slope within 15% at Mach 3.96 and 4.63. The second half is met (+2.8% to −3.3%). The first is not, on six of eleven rows, and this is where they stand (ADR-040).
- Rows outside the target are in bold. Slopes are on the body’s cross-section.
- is the Mach number over the nose’s fineness, the argument TN 3527 ([SD56]) states its method for from 0.4 to 2. One row, the short model at Mach 1.5, is below that at 0.36.
- measured and HPR Sim are the straight-line slopes fitted at the tunnel’s plotted angles, as ADR-036, which fixes how these comparisons are fitted judges them.
- at is the slope at zero angle. HPR Sim’s is the method alone, since body lift vanishes there. The measurement’s comes from fitting its points with , the form the tunnel’s own curves follow, and is quoted with its standard error.
- curvature is the rest: the fitted slope less the slope at . For HPR Sim it is body lift.
| model | Mach | ratio | measured, per rad | HPR Sim, per rad | difference | measured at , per rad | HPR Sim at , per rad | slope ratio, HPR Sim ÷ measured at | curvature ratio, HPR Sim ÷ measured |
|---|---|---|---|---|---|---|---|---|---|
| short | 1.5 | 0.36 | 2.192 | 3.017 | +37.7% | 1.779 ± 0.32 | 1.852 | 1.04 | 2.82 |
| short | 1.8 | 0.43 | 2.613 | 3.290 | +25.9% | 2.519 ± 0.33 | 2.143 | 0.85 | 12.20 |
| short | 2.3 | 0.55 | 3.078 | 3.598 | +16.9% | 2.196 ± 0.32 | 2.394 | 1.09 | 1.37 |
| short | 2.96 | 0.71 | 3.284 | 3.838 | +16.9% | 2.184 ± 0.30 | 2.612 | 1.20 | 1.11 |
| short | 3.96 | 0.95 | 3.884 | 3.946 | +1.6% | 2.694 ± 0.32 | 2.735 | 1.02 | 1.02 |
| short | 4.63 | 1.11 | 4.149 | 3.950 | −4.8% | 2.758 ± 0.32 | 2.718 | 0.99 | 0.89 |
| long | 1.8 | 0.43 | 3.159 | 3.770 | +19.4% | 1.920 ± 0.42 | 2.143 | 1.12 | 1.31 |
| long | 2.3 | 0.55 | 3.525 | 4.071 | +15.5% | 2.245 ± 0.41 | 2.394 | 1.07 | 1.31 |
| long | 2.96 | 0.71 | 3.868 | 4.400 | +13.7% | 2.521 ± 0.36 | 2.614 | 1.04 | 1.33 |
| long | 3.96 | 0.95 | 4.455 | 4.428 | −0.6% | 3.129 ± 0.41 | 2.740 | 0.88 | 1.27 |
| long | 4.63 | 1.11 | 4.615 | 4.425 | −4.1% | 2.877 ± 0.41 | 2.724 | 0.95 | 0.98 |
What the rows say, and what they can’t. What is solid is the first three number columns. On six rows HPR Sim’s fitted slope is 15% to 38% above the tunnel’s. The split into a slope at and a curvature is softer. The tunnel plots seven points over about ±4.5°. In a fit of over so short a span the two terms trade off almost exactly: their correlation is −0.96. A fit that reads low must read high. So the measurement’s own split carries the standard errors in the table (±0.30 to ±0.42 per radian). The widest of them is on a slope of 1.920. The curvature, being the same slope subtracted from another, carries at least as much.
Where the gap most likely is. At HPR Sim is within 1.5 standard errors of the measurement on every row outside the target (0.2 to 1.5 of one). So the readings cannot convict the shock-expansion method, the Newtonian cap or the boattail’s measured share. On five of those six rows most of the fitted gap sits in the curvature instead. That is what the rest of the plotted angles add, which for HPR Sim is body lift. The sixth is the short model at Mach 2.96, where 77% of the gap is HPR Sim’s slope at , 1.2 times the measured one. There the method itself, not body lift, carries most of the miss. HPR Sim’s curvature is 1.3 to 2.8 times the measured one below Mach 2.96, and 1.1 to 1.3 times at Mach 2.96. It is 0.89 to 1.27 times at Mach 3.96 and 4.63. The ×12.20 on the short model at Mach 1.8 is not a measurement of anything. The tunnel’s own curve barely bends there (0.094 per radian, against an uncertainty three times its size). So the ratio’s denominator is consistent with zero.
The likeliest single cause is Jorgensen’s crossflow term, which ADR-037 chose because the tunnel’s high-angle points support its size. At the few degrees these slopes are fitted over, that term reads too large. Two other explanations are open, and the readings do not close them. First, the short model at Mach 1.5 (the worst row, +37.7%) sits at 0.36, below the 0.4 that TN 3527 states its method for. Second, the same model at Mach 2.96 points at the method rather than at body lift.
What would close it. A cited rule for how the crossflow term grows from zero over the first few
degrees. Or measurements of this body at finer angles than the reports plot. Neither is in hand,
so the gap is left visible here rather than tuned away. The rows are in
validation/fixtures/aero/arcas-robin-body-gap.json,
written by cargo xtask aero, and a test pins which rows are outside.
Checking the shock-expansion method
A flight uses the second-order shock-expansion method of Bodies faster than sound
from Mach 1.2 on the bodies it covers. It is checked against two references in the fixture
validation/fixtures/aero/shock-expansion.json.
cargo xtask aero writes it, and shock_expansion::tests::against_tn3527_and_the_arcas_robin
recomputes every value and pins every miss (ADR-033).
To check a share by hand from outside the crate,
ShockExpansionBody::element_flows
reports each element’s flow. That is the state behind its corner, the tangent cone it relaxes toward, how
fast it does so, and the radius eq. 19 needs. The library’s own hand integral of a
boattail and the tube behind it uses that flow (footnote_eights_boattail_share_by_hand).
The tip cone’s flow (cone_flow_agrees_with_naca_1135_charts), against [R1135]’s cone
charts 5 to 7 at Mach 1.5 to 3 and cones of 10° and 20°. The shock angle is within 0.3°, the
surface pressure coefficient within 0.004 and the surface Mach number within 0.015. These bounds are twice the
charts’ reading error, since the charts are drawn for and HPR Sim uses 1.4. At Mach 2 on a 10°
cone HPR Sim gives a shock at 31.21° against the chart’s 31.25°.
The report’s own tables ([SD56] Tables I and II, transcribed from the page images into
tn3527-bodies.json).
They cover 144 bodies at Mach 3, 4.24, 5.05 and 6.28. These are cones and tangent ogives of fineness 3, 5 and 7, on cylinders of 0 to 10 calibers. For each they give the method’s slope and CP, as its
authors computed them by hand in 1956. For all but the 8-caliber cylinders they also give NASA’s
wind-tunnel measurements. The targets were set before measuring: within 0.05 per radian and
0.1 calibers of the report’s values. Against the measurements the target is the ±0.2 per radian and ±0.2 calibers that the report
claims. Each cell counts the rows within, with the range of HPR Sim’s value
less the reference’s:
| nose | slope within 0.05 per radian of the report’s | CP within 0.1 caliber of the report’s | slope within 0.2 per radian of the measured | CP within 0.2 caliber of the measured |
|---|---|---|---|---|
| cone, fineness 3 | 24 of 24 (−0.006 to +0.024) | 24 of 24 (−0.003 to +0.040) | 20 of 20 (−0.128 to +0.145) | 19 of 20 (−0.194 to +0.250) |
| cone, fineness 5 | 23 of 24 (−0.003 to +0.066) | 24 of 24 (−0.003 to +0.072) | 20 of 20 (−0.075 to +0.176) | 19 of 20 (−0.165 to +0.272) |
| cone, fineness 7 | 11 of 24 (−0.001 to +0.146) | 16 of 24 (−0.003 to +0.257) | 18 of 20 (−0.061 to +0.251) | 16 of 20 (−0.153 to +0.328) |
| tangent ogive, fineness 3 | 12 of 24 (−0.115 to +0.014) | 19 of 24 (−0.670 to +0.062) | 19 of 20 (−0.278 to +0.008) | 17 of 20 (−0.540 to +0.104) |
| tangent ogive, fineness 5 | 15 of 24 (−0.134 to +0.009) | 20 of 24 (−0.181 to +0.090) | 20 of 20 (−0.111 to +0.138) | 19 of 20 (−0.143 to +0.217) |
| tangent ogive, fineness 7 | 17 of 24 (−0.072 to +0.013) | 22 of 24 (−0.107 to +0.128) | 20 of 20 (−0.107 to +0.142) | 19 of 20 (−0.206 to +0.147) |
The 12 cones with no cylinder only read Fig. 2 back, so against the report’s values they check the hand reading, not the method.
A worked example: a cone of fineness 5 on a cylinder 4 calibers long, at Mach 4.24. Slender-body theory gives 2 per radian at any length. The tip cone alone gives 1.868 (Fig. 2). With the cylinder HPR Sim gives 2.922, the report 2.91, and the wind tunnel 2.84.
Against the measurements, 117 of 120 slopes and 109 of 120 centers of pressure are within the report’s ±0.2. Against the report’s own values, 102 of 144 slopes and 125 of 144 centers of pressure are within 0.05 and 0.1. That is 75 of the 528 comparisons outside, so the targets are not met (ADR-033 records it):
- Against the report’s own values (61 misses), in two kinds.
- Where the march stays inside the method’s limit (49 misses), HPR Sim follows the printed equations and the printed values depart from them. The largest misses are two. One is the fineness-7 cone on long cylinders (HPR Sim high, up to +0.146 at Mach 6.28 over 10 calibers). The other is the ogives (HPR Sim low, most at fineness 5 and Mach 3, down to −0.134). The evidence is a second implementation of the same equations, written from the paper with its own cone solver. For the cone-cylinders it used the report’s closed form (its Appendix C), for the ogives its ten-element march. With HPR Sim’s hand-read Fig. 2, the second implementation agrees with HPR Sim within 0.0001 per radian on all 72 cone-cylinders. With the same Fig. 2 it agrees within 0.0006 per radian and 0.0003 calibers on the 60 ogive-cylinders that stay inside the limit. It is an uncommitted scratch script by the same author, so it can’t be rerun from the repository. It can’t catch a misreading both share. Why the printed values differ is not known. The report took its cone pressures from charts (its Fig. 1), and a thin cone’s small pressure differences are sensitive to them. That is a guess, not a finding.
- Where the march reaches the method’s limit (12 misses), on the fineness-3 ogive at Mach 5.05 and 6.28, near the tip. There HPR Sim’s CP at Mach 5.05 sits 0.19 to 0.67 calibers ahead of the report’s. The report’s measurements agree with the report, so this is HPR Sim’s gap, not the report’s. The report doesn’t say how it continued past its limit. Carrying the pressure gradient on through the reduced elements comes closer at Mach 5.05 but further at Mach 6.28. The result doesn’t settle as elements are added. This is open (issue #81).
- Against the measurements (14 misses), in four groups:
- The fineness-7 cone on long cylinders (6). The report is already 0.07 to 0.15 high there, and HPR Sim, following the closed form, adds 0.06 to 0.19 more.
- Rows where the report is itself 0.20 to 0.22 off (3): the fineness-5 and fineness-3 cones’ CP at Mach 6.28 over 10 calibers. The third is the fineness-5 ogive’s at Mach 5.05 over 10.
- The fineness-3 ogive at Mach 5.05 (4): the limit above; the worst misses, −0.278 per radian and −0.540 calibers.
- The fineness-7 ogive’s CP at Mach 5.05 over 4 calibers (1): −0.206, just outside, where the report reads −0.13.
The Arcas Robin ([D4014], the wind tunnel of Normal force through Mach 1). The method needed a pointed tip when this comparison was made. The committed nose, behind the cap it now takes, is compared in Blunt tips. So here the nose is the secant ogive (a circular arc meeting the body at an angle) through the tip and base. It best fits the report’s coordinate table and is 4.17 calibers long. So the report’s Mach-over-fineness range of 0.4 to 2 covers Mach 1.67 to 8.3. The arc radius is 1.744 times a tangent ogive’s, the nose misses the table by 0.003 in rms, and its tip half-angle is 10.76°. HPR Sim’s committed design keeps its power-series nose, whose tip is blunt. The measured slope is the fins-off reading fitted over the plotted angles, as above. It includes the boattail, the lip behind it, and crossflow lift at those angles. The method has neither the lip nor crossflow at , and takes the boattail only by the report’s footnote 8. So the target is not applied here. It is applied to the body a flight flies, in The body alone, against the 15% target. This table is the method’s own; the body a flight flies since M1.8e6, with the boattail’s measured share, is compared below.
| model | Mach | measured, per rad | nose and cylinder, per rad | error | with boattail (footnote 8), per rad | error |
|---|---|---|---|---|---|---|
| short | 1.5 | 2.192 | 2.552 | +16.4% | 2.375 | +8.3% |
| short | 1.8 | 2.613 | 2.724 | +4.3% | 2.580 | −1.2% |
| short | 2.3 | 3.078 | 2.931 | −4.8% | 2.828 | −8.1% |
| short | 2.96 | 3.284 | 3.124 | −4.9% | 3.056 | −6.9% |
| short | 3.96 | 3.884 | 3.300 | −15.0% | 3.262 | −16.0% |
| short | 4.63 | 4.149 | 3.371 | −18.7% | 3.345 | −19.4% |
| long | 1.8 | 3.159 | 2.724 | −13.7% | 2.581 | −18.3% |
| long | 2.3 | 3.525 | 2.932 | −16.8% | 2.829 | −19.8% |
| long | 2.96 | 3.868 | 3.127 | −19.2% | 3.059 | −20.9% |
| long | 3.96 | 4.455 | 3.313 | −25.6% | 3.275 | −26.5% |
| long | 4.63 | 4.615 | 3.395 | −26.4% | 3.369 | −27.0% |
The method’s slope grows with Mach number, as the measurement does. On the short model it runs 2.55 to 3.37, where slender-body theory keeps its nose at 2. By the end of either cylinder the lift has died away, so the long model gets almost nothing more (3.313 against 3.300 at Mach 3.96). The long model’s measurement is 0.57 higher than the short model’s. That difference goes with the longer body’s larger side area, the mark of crossflow lift. The boattail column here is the report’s footnote 8, the method’s own rule. A flight used it from M1.8e4. Since M1.8e6 a flight takes Washington and Pettis’s measured share instead (the worked example under The body faster than sound in a flight).
The table above is the method alone, at . A flight also adds body lift, which grows as ; the table leaves it out, and the measured line includes it.
Most of that gap was the comparison, not missing lift.
M1.8e5 sized each cause of it on HPR Sim’s body model before
M1.8e6: Galejs’s body lift and footnote 8’s boattail.
The research note has the tables. The measurement is a straight line through points
from about −5° to +4°, and crossflow lift, which grows as , steepens it. HPR Sim’s body is fitted the same way
at the same angles. With its boattail and the body lift a flight added, it read 14.9%
to 73.2% high at every Mach number. The fixture is arcas-robin-gap.json, which
cargo xtask aero writes and aero_gap::tests::committed_fixture_is_current keeps current.
- Crossflow lift steepens that fitted line. In HPR Sim’s body lift it adds 1.40 to 2.09 per radian. In the tunnel’s own points (fitted with an term, the curvature) it adds 0.09 to 1.74. From Mach 2.3 the tunnel’s curvature matches body lift with a factor from 0.66 to 1.05, each ±0.18 to ±0.23 (one standard error). HPR Sim used 1.1 (Bodies of revolution). Jorgensen’s crossflow method ([J77] eq. 2.12, Fig. 4 and p. 15) gives about 0.9 for these bodies at small angles.
- The fit’s slope at and its curvature move together (their errors correlate at −0.95 to −0.96). So the readings can’t split HPR Sim’s excess between body lift and its slope at . With body lift at Jorgensen’s size alone, HPR Sim still reads 8.2% to 60.7% high.
- The one sized cause that size is the boattail’s share: TN 3527’s footnote 8, which a flight used, gives −0.177 to −0.026, slender-body theory −1.324. The lip, which the method can’t take, adds +0.178 by slender-body theory. A blunt tip like the tunnel’s, scaled from a blunter one measured, loses 0.015 to 0.07 past Mach 3. Below Mach 3 the tangent cones’ slopes are held at TN 3527’s Fig. 2 Mach 3 curve. There, Sims’s tables ([S64] Table 2, p. 20) move the nose and cylinder’s share by −0.031 to +0.056 at most. HPR Sim’s reading of issue #81 (how it continues the method where TN 3527’s relaxation condition fails) changes nothing on this body.
From then on the Arcas Robin is judged like for like, at the tunnel’s angles (ADR-036).
Crossflow’s size and the boattail’s share, together. Since M1.8e6 (ADR-037), body lift takes Jorgensen’s crossflow (Body lift). A boattail takes Washington and Pettis’s measured share (The body faster than sound in a flight). Fitted like for like, as the tunnel’s line is, the same body reads +3.4% to +41.0%. Each change takes about half of the old excess off. From Mach 3.96 both models are within 15%. From Mach 1.5 to 2.96 HPR Sim still reads 16% to 41% high. The columns are HPR Sim’s body model before M1.8e6, each change alone, and both. The last column is the current model’s slope at , which leaves body lift out. Slopes per radian on the body’s cross-section; the measured line’s standard error takes each reading’s accuracy as independent.
| model | Mach | measured, fitted, per rad | before, per rad | Jorgensen’s crossflow alone, per rad | measured boattail alone, per rad | both (current), per rad | current at , per rad |
|---|---|---|---|---|---|---|---|
| short | 1.5 | 2.19 ± 0.09 | 3.80 (+73.2%) | 3.53 (+61.2%) | 3.35 (+52.9%) | 3.09 (+41.0%) | 1.93 |
| short | 1.8 | 2.61 ± 0.09 | 3.98 (+52.2%) | 3.72 (+42.4%) | 3.57 (+36.6%) | 3.31 (+26.8%) | 2.17 |
| short | 2.3 | 3.08 ± 0.08 | 4.29 (+39.4%) | 4.03 (+30.8%) | 3.92 (+27.2%) | 3.65 (+18.6%) | 2.45 |
| short | 2.96 | 3.28 ± 0.08 | 4.54 (+38.1%) | 4.28 (+30.2%) | 4.20 (+27.8%) | 3.94 (+19.8%) | 2.72 |
| short | 3.96 | 3.88 ± 0.09 | 4.71 (+21.3%) | 4.47 (+15.0%) | 4.41 (+13.6%) | 4.17 (+7.3%) | 2.96 |
| short | 4.63 | 4.15 ± 0.09 | 4.79 (+15.5%) | 4.57 (+10.2%) | 4.51 (+8.7%) | 4.29 (+3.4%) | 3.06 |
| long | 1.8 | 3.16 ± 0.11 | 4.50 (+42.4%) | 4.20 (+33.0%) | 4.09 (+29.4%) | 3.79 (+20.0%) | 2.17 |
| long | 2.3 | 3.53 ± 0.11 | 4.80 (+36.1%) | 4.50 (+27.6%) | 4.42 (+25.5%) | 4.12 (+17.0%) | 2.45 |
| long | 2.96 | 3.87 ± 0.11 | 5.14 (+32.9%) | 4.84 (+25.1%) | 4.80 (+24.1%) | 4.50 (+16.3%) | 2.72 |
| long | 3.96 | 4.46 ± 0.11 | 5.23 (+17.3%) | 4.96 (+11.2%) | 4.92 (+10.5%) | 4.66 (+4.5%) | 2.97 |
| long | 4.63 | 4.62 ± 0.11 | 5.30 (+14.9%) | 5.06 (+9.7%) | 5.02 (+8.7%) | 4.78 (+3.5%) | 3.08 |
The rows are in
arcas-robin-crossflow.json,
which cargo xtask aero writes and aero_crossflow::tests::committed_fixture_is_current keeps
current; aero_crossflow::tests::the_guide_quotes_the_fixture checks this table against it cell
by cell. What is left at Mach 1.5 to 2.96 can’t be split between body lift and the slope at
from these readings, as M1.8e5 found. On the short
model at Mach 1.5 and 1.8 the tunnel’s points from −5° to +4° barely curve. The factors on body lift are 0.32 ± 0.24
and 0.07 ± 0.25, where HPR Sim uses about 0.9. HPR Sim’s slope at (1.93
and 2.17) lies within about one standard error of the tunnel’s. The tunnel’s values are 1.78 ± 0.32 and 2.52 ± 0.33, and HPR Sim’s is 1.1 standard errors below the second. There most of the excess is body lift. At 6° it is about half of HPR Sim’s normal force, and the points at 6° need a factor of 0.47 and 0.58 on it. From Mach 2.3 the points do curve. Their curvature gives factors of 0.66 to 1.05, each within about one standard error (±0.18 to ±0.23) of Jorgensen’s, five of the eight below it. The fixture also holds each of the 62 points above +4° and
the boattail’s share at under each rule. One caution on the long model: its points from
−5° to +4° are M1.8a’s reading. That reading may carry a skew of the
page that puts its slope 3% to 5% high
(issue #97). Its rows here depend on how that is
settled.
Where the body’s lift acts. A body model can match the slope with its lift in the wrong place.
So the body’s center of pressure is checked too. It comes from the tunnel’s fins-off pitching moment (read into
arcas-robin-fins-off-moment.json,
±0.02 to ±0.025 in ). Both are taken the way the tunnel’s are. They are straight lines through the
pitching moment and the normal force at the plotted angles up to ±4.5°, calibers from the nose
tip. The measured ones carry about ±0.5 calibers from the readings. The measured boattail share,
which takes lift off at the tail, moves HPR Sim’s center of pressure forward, toward the tunnel’s.
Before M1.8e6 HPR Sim put it 0.90 to 3.85 calibers aft of the tunnel’s on the short model and 0.59 to
1.94 on the long. Now it is −0.19 to +1.59 and −0.88 to −0.18. Five rows still miss by more than the
readings’ half a caliber. The largest are the short model at Mach 1.5 (+1.59), where the slope misses most too, and the long one at 3.96 (−0.88). The other three are the short model at Mach 1.8 and 2.96 and the long one at 2.96.
| model | Mach | measured, calibers from the tip | before, calibers | current, calibers |
|---|---|---|---|---|
| short | 1.5 | 1.00 | 4.85 (+3.85) | 2.59 (+1.59) |
| short | 1.8 | 2.36 | 4.98 (+2.62) | 3.03 (+0.68) |
| short | 2.3 | 3.56 | 5.27 (+1.71) | 3.67 (+0.10) |
| short | 2.96 | 3.21 | 5.20 (+1.99) | 3.77 (+0.56) |
| short | 3.96 | 4.88 | 5.79 (+0.91) | 4.69 (−0.19) |
| short | 4.63 | 5.05 | 5.94 (+0.90) | 4.95 (−0.09) |
| long | 1.8 | 4.61 | 6.55 (+1.94) | 4.27 (−0.33) |
| long | 2.3 | 5.04 | 6.79 (+1.74) | 4.86 (−0.18) |
| long | 2.96 | 5.33 | 6.43 (+1.11) | 4.65 (−0.68) |
| long | 3.96 | 6.19 | 6.78 (+0.59) | 5.31 (−0.88) |
| long | 4.63 | 6.40 | 7.35 (+0.96) | 6.12 (−0.28) |
Drag verification
-
RocketPy’s drag curves at Mach 0.3 (
tests::rocketpy_drag_curves_at_mach_0_3, fixturevalidation/fixtures/aero/rocketpy-drag-curves.json, written bycargo xtask aerofromrefs/rocketpy). Every RocketPy example whose curve is labeled RASAero, at sea level in the 1976 standard atmosphere (USSA76). RASAero II computes its exports’ Reynolds numbers there. Tolerance 10%. The fixture holds only derived numbers: each curve’s value at Mach 0.3, HPR Sim’s and the error. The test recomputes HPR Sim’s and the errors from the committed designs, andcargo test -p xtaskreruns the comparison whenrefs/rocketpyis present.case curve HPR Sim drag coefficient error Calisto, 2018 fins RASAero II export, power-off 0.3821 +0.2% Calisto, getting-started fins (variant) (outside 10%) the same 0.3376 −11.5% Juno III (outside 10%) labeled RASAero II, 3-decimal table 0.3364 −10.3% Cavour, power-off labeled RASAero II, 3-decimal table 0.5034 −8.3% Cavour, power-on (outside 10%) the same, power-on 0.4487 −18.3% Valetudo, power-off (outside 10%) labeled RASAero, 3-decimal table 0.5566 −47.0% Valetudo, power-on (outside 10%) the same, power-on 0.5189 −50.4% Calisto, the getting-started variant and Juno III are boattailed: since ADR-362, the base held to the Hermes A-3A, their base keeps of the flat-base value below Mach 0.8, which took Calisto from +4.4% to +0.2% and the other two from −7.3% and −6.0% to outside 10%. One code against another sizes the difference; it doesn’t say which code is right.
- Inputs (ADR-009, the drag decision). The exports record none, so the designs follow one declared rule:
- RASAero II’s default smooth finish.
- A NACA 00xx airfoil file in the example gives an airfoil section that thick at the mean aerodynamic chord (Calisto’s getting-started fins).
- A published section is used. Juno III’s team placed second for a technical award, cited for “análise de aletas com perfil de aerofólio truncado” (an analysis of truncated-airfoil fins). It is taken as rounded at the placeholder thickness, since the citation gives no thickness.
- Otherwise the placeholder, square 3 mm (0.12 in, Calisto’s 2018 fins, Cavour, Valetudo).
- Rail buttons are as RocketPy defines them.
- Sensitivity. The fins’ section (square, rounded or airfoil), their thickness and the finish move Calisto’s rows within 10% by band as
tests::calistos_rows_by_fin_and_finishpins (below); the rail buttons move a case too, not re-measured since ADR-362. The check places HPR Sim near RASAero’s subsonic drag under a declared rule; without the inputs it can’t show agreement to 10%. - Power-on. Separate power-on curves are compared (Cavour’s and Valetudo’s). Subtracting the motor’s area ([N09] pp. 50–51) removes 42% of Cavour’s base drag and 29% of Valetudo’s at Mach 0.3. Cavour’s power-on table is within its 0.001 rounding of power-off from Mach 0.16 up (0.0001 at 0.3). Below Mach 0.16 it is 0.001 to 0.013 lower. Valetudo’s is 0.004 lower, about a ninth of HPR Sim’s relief. The designs’ motor diameter is the larger of the grain and nozzle exit diameters, since RocketPy gives no case. Cavour’s result depends on it: −8.3% with no relief and −14.8% at 54 mm (2.1 in). It is −18.3% at the design’s 67 mm (2.6 in) nozzle exit and −20.8% with the example’s 75 mm motor. The cause of that miss stays open. One candidate is Niskanen’s rule of taking the motor’s area off the base. Others are a RASAero run with little or no nozzle exit diameter, or tables sampled along a flight. Their uneven Mach spacing suggests the last (unconfirmed).
- Valetudo. Its table (1.05) is 1.44 times the OpenRocket export for the same rocket (0.728). With that file’s own inputs (60 µm, two 14 mm × 30 mm lugs, 3 mm (0.12 in) square fins), HPR Sim gives 0.714. That is 1.9% under the OpenRocket export and 32% under the table. As designed for this comparison, its 0.5566 is 23.5% under the export.
- Not compared.
- Calisto’s power-on curve, which equals its power-off curve (no nozzle exit diameter in RASAero).
- Juno III’s power-on drag, which RocketPy takes from the same file.
- The other examples, whose drag is a constant, CFD or of unknown origin.
- Inputs (ADR-009, the drag decision). The exports record none, so the designs follow one declared rule:
-
Loft lessons, each with what it concerns:
- L11, drag that changed with the order of the fin sets:
drag::tests::drag_invariant_to_fin_set_order - L12, uncited form-factor, friction and roughness constants:
drag::tests::form_factor_and_roughness_match_cited_values - L13, no relief of base drag while a motor burns:
drag::tests::power_on_base_drag_subtracts_thrusting_motor_area - L14, uncited launch-lug drag:
drag::tests::launch_lug_drag_matches_cited_hollow_tube_formula - L15, shoulder drag that jumped as its length went to zero:
drag::tests::shoulder_drag_continuous_as_transition_length_tends_to_zero - L16, a silent cap on the drag coefficient that hid bad geometry:
drag::tests::malformed_geometry_is_an_error_not_a_clamped_cd - L90, drag invariants, a check kept from Loft’s tests (skin friction’s published jumps, split fin sets, base drag at Mach 1):
drag::tests::skin_friction_follows_eq_3_81_and_drag_invariants_hold
- L11, drag that changed with the order of the fin sets:
-
Limits of every term (
drag::tests):- Friction below , at and to Mach 5.
- Stagnation pressure against the isentropic series and its limits either side of Mach 1.
- Base drag at rest, at Mach 1 and far above.
- The joint term from smooth to a step.
- The boattail factor’s three pieces and their joins.
- Fin pressure drag by cross-section with the leading edge’s joins at Mach 0.9 and 1 and the sweep.
- The angle-of-attack factor’s stated values and zero slopes, monotonicity and its sign-reversed mirror (and at 135°).
- Joint angles of cones and power-series, Haack and ogive noses.
- Curved boattails ending in blunt tips.
- A tail closing to a point.
- Leading-edge sweeps of trapezoids, kinked outlines and ellipses (against a quadrature to 1e-8).
- A whole rocket’s buildup written out by hand to 1e-12, its component sum, and override tables (rescaled to another reference diameter).
-
Drag through Mach 1 (
nose_drag::tests,drag::tests):drag::tests::leading_edge_and_cone_pressure_drag_have_supersonic_branchescovers Loft lesson L17: Loft’s fin leading-edge drag frozen at its Mach 1 value and nose drag with no Mach term.- A 3:1 cone by hand from rest through eq. B.4, with its joins smooth to 1e-5.
- The ogive factor at its ends and middle.
- Eq. B.9 through both its anchors.
- Eq. 3.87 meeting its lower bound and its fallback.
- A step from 0.8 to the flat face.
- Short cones tending to the step and meeting the closed form at fineness 1 (Loft lesson L15).
- Stoney’s curves reproduced at fineness 3, held past their ends and interpolated between shapes.
- The guide’s worked example.
- The 3:1 cone against Stoney’s measured one.
- Refused shapes.
- A property test: every shape at any fineness, joint angle and Mach number to 5 gives a finite, non-negative coefficient. The coefficient has no jump at .
-
Boattails faster than sound (
afterbody::tests):- The Prandtl-Meyer function against NACA Report 1135’s table and its limit of 130.45°, and its inverse.
- An expansion’s pressure by hand and at the vacuum limit.
- The chart giving back its readings, falling with and the area ratio, and reaching 0 at .
- Calisto’s boattail by hand (the guide’s worked example) with the joins at Mach 0.9, 1 and 1.2.
- The drag past the chart continuous at its end and closing on the 2D limit.
- Separation from 16° to 30°.
- The base-pressure ratio on Fig. 5-141’s line, and to Mach 0.8.
- Every boattail from 1° to 89° finite and non-negative to Mach 5.
- The comparison with measured boattails and Jack’s theory is
tests::boattails_against_measurements.
-
Boattails in parts, wakes and gaps (
drag::tests): a boattail split in two drags as one (a_boattail_split_in_two_drags_as_one). So does a straight cone of 0.5° to 7° in 2, 4 or 8 parts, where a part’s share is below 0 too (a_straight_cone_in_parts_is_one_cone). A corner keeps two parts apart and the merge is continuous in the turn (a_sharp_corner_keeps_its_boattails_apart). A pair drags between its two limits (soft_merges_stay_between_their_limits). A partial merge shares the flow (a_partial_merge_shares_the_flow). A change of in any radius or length behind 2° to 14° boattails moves the drag in proportion to (a_part_narrowing_by_nothing_is_a_tube_and_one_of_no_length_a_step). A lip’s wake is tested by its rise and its gaps (a_lip_in_a_boattails_wake_fades_with_its_rise,a_lip_drawn_as_a_step_up_is_a_lip,a_hairline_step_before_a_lip_changes_nothing). A retainer behind a step down is in its wake (a_retainer_behind_a_step_down_is_in_its_wake). A 40-part zigzag keeps its tails few (a_zigzag_boattail_keeps_its_tails_few). -
Tables (
table::tests): the tests parse RocketPy’s quirks (\r\n,01.05, a repeated row), a byte-order mark, quoted fields and trailing commas. They parse RASAero II’s header with rows at 2° and 4° skipped. They report malformed text (a bad first row, repeated or unsorted Mach numbers,nan) by line.
Base drag under power against the Hermes A-3A’s flight
This checks HPR Sim’s base drag below Mach 0.8, coasting and while a motor burns, against a measured flight rather than another program. NACA flew rocket-propelled models of the Hermes A-3A with the motor burning and then coasting, and measured the pressure on the base (Jackson 1955, NACA RM SL55F15, Fig. 20; an error believed to be less than ±0.005, and ±0.001 more for reading the figure). The model narrows to its 4.8 in base along a long 4.5° cone. Its motor, a nominal 5 in case, sits forward, and a blast tube carries the jet to a 3.0 in nozzle exit at the base, past fixed vanes.
- Under power, HPR Sim’s rule as it flies reads low. It takes the motor case’s area off the base, down to zero, and this case is wider than the base: it leaves no base drag, where the flight measured 0.0204 to 0.0270 on the model’s largest cross-section. Too little drag gives too high an apogee, the optimistic side for a target altitude (which error flatters).
- Given only the nozzle exit, the same rule comes within 0.007, from 0.0040 low to 0.0061 high. The whole base kept under power, the area OpenRocket 24.12 keeps, reads high by 0.0108 to 0.0230 on HPR Sim’s coefficient; on OpenRocket’s own, the flat-base rule with no relief behind a boattail, by 0.036 to 0.052 (the fixture’s flat-base column less the measured).
- Coasting, HPR Sim reads high: 3.0 to 5.1 times the measured base drag, high by 0.025 to 0.035. Behind a boattail below Mach 0.8 HPR Sim keeps of the flat-base value, here 0.6 ([S61] p. 11; since ADR-362, the base held to this flight); before, it gave no relief and read high by 0.050 to 0.064, 5.0 to 8.4 times the measured. Hoerner’s rule, which also takes the forebody’s friction into account, reads high by 0.012 to 0.016 ([H65] eq. 35).
- The jet more than doubled the measured base drag, where HPR Sim’s rule lowers it and the whole base keeps it. Neither rule moves the way the flight did.
The rows, a worked example and how far this carries to a hobby rocket are on the accuracy page
(the base under power, against a measured flight).
The rows are written by cargo xtask aero to
validation/fixtures/aero/base-drag-under-power.json,
also in the fixture report,
and which way each rule errs is held by tests
(xtask/src/aero_base_power/tests.rs).
The comparison with OpenRocket that points at this term splits the drag below Mach 0.8 by term
(the slowest band, by term).
Drag against the Arcas Robin wind tunnel
NASA measured the axial force on its half-scale Arcas Robin models, the same ones as the normal force above ([D4013], [D4014]). The runs covered Mach 0.6 to 4.63, with fins at 0° and fins off. The
models sat on a sting, so their base pressure isn’t a free flight’s. Both reports take the base apart. [D4013] plots the axial force “corrected for base axial force” (, Figs. 11–12). [D4014] plots the axial force and, separately, the force on the balance chamber inside the base
(, Figs. 4–6). What compares is the forebody. HPR Sim’s less its base drag (friction, pressure and parasitic drag) against the measured axial force with the base at the free stream’s pressure. For [D4014] that is , which takes the chamber’s pressure over
the whole base as [D4013]’s correction does. 1.383 is : the base’s diameter in inches
over the 1.250-inch cavity drawn in [D4014] Fig. 1(a), squared. The report states no chamber area. Taking the pressure over the chamber alone moves the measured values by 0.002 to 0.015, which
changes no row’s verdict. The readings are in
arcas-robin-wind-tunnel.json, read off the reports’ plots. Each has its figure, page and reading uncertainty (±0.002 in for most, against the reports’ own ±0.004).
HPR Sim flies the committed designs (Normal force through Mach 1) at
both tunnels’ Reynolds number, 3.0 million per foot. Two inputs are set for drag before measuring: the double-wedge fins take HPR Sim’s airfoil section, as Niskanen modeled them ([N09] p. 90). HPR Sim gives the machined steel models a polished finish, 0.5 µm, since the reports state none. The target, set
before measuring, was M1.8’s 10% for drag. cargo xtask aero writes
drag-vs-mach.json, each row with HPR Sim’s drag by part. tests::drag_against_mach recomputes it from the designs and pins the 2 rows of 44 within target.
The two input choices matter, and moved HPR Sim toward the tunnel. With square edges and the default
20 µm finish no row is within target. With the airfoil section alone none is, with the polished finish alone none is, and with both 2 are (tests::drag_against_mach_depends_on_the_fins_and_finish).
The airfoil section follows the drawings and Niskanen; the finish is a guess. Allowing each
reading its uncertainty and the reports’ ±0.004, neither of the 2 could fall the other side of
10%. Before
M1.8b3 modeled the boattail faster than sound and the lip
in its wake, 8 rows were within target. Six were within target because the lip’s 0.085 made up for the missing
wave drag. Forebody drag on the reference area, measured and HPR Sim’s, and HPR Sim’s error:
| Mach | fins | short: measured drag coefficient | HPR Sim drag coefficient | error | long: measured drag coefficient | HPR Sim drag coefficient | error |
|---|---|---|---|---|---|---|---|
| 0.6 | on | 0.2987 | 0.3371 | +12.9% | 0.3455 | 0.3874 | +12.1% |
| 0.6 | off | 0.2217 | 0.2523 | +13.8% | 0.2477 | 0.3041 | +22.8% |
| 0.8 | on | 0.3299 | 0.4200 | +27.3% | 0.3706 | 0.4688 | +26.5% |
| 0.8 | off | 0.2308 | 0.2585 | +12.0% | 0.2517 | 0.3088 | +22.7% |
| 0.9 | on | 0.4202 | 0.6346 | +51.0% | 0.4510 | 0.6826 | +51.3% |
| 0.9 | off | 0.2610 | 0.3623 | +38.8% | 0.2671 | 0.4116 | +54.1% |
| 0.95 | on | 0.5680 | 0.6722 | +18.3% | n/a | n/a | n/a |
| 0.95 | off | 0.2916 | 0.4214 | +44.5% | n/a | n/a | n/a |
| 1.0 | on | 0.6858 | 0.7344 | +7.1% | 0.7247 | 0.7825 | +8.0% |
| 1.0 | off | 0.4194 | 0.5044 | +20.3% | 0.3674 | 0.5540 | +50.8% |
| 1.2 | on | 0.5935 | 0.7706 | +29.8% | 0.6245 | 0.8172 | +30.9% |
| 1.2 | off | 0.4311 | 0.5187 | +20.3% | 0.4220 | 0.5667 | +34.3% |
| 1.5 | on | 0.4932 | 0.6873 | +39.4% | n/a | n/a | n/a |
| 1.5 | off | 0.3401 | 0.4148 | +22.0% | n/a | n/a | n/a |
| 1.8 | on | 0.4260 | 0.6412 | +50.5% | 0.4543 | 0.6827 | +50.3% |
| 1.8 | off | 0.3142 | 0.3570 | +13.6% | 0.3267 | 0.3997 | +22.3% |
| 2.3 | on | 0.3328 | 0.5879 | +76.7% | 0.3730 | 0.6251 | +67.6% |
| 2.3 | off | 0.2474 | 0.2940 | +18.8% | 0.2927 | 0.3323 | +13.5% |
| 2.96 | on | 0.2639 | 0.5409 | +105.0% | 0.3010 | 0.5729 | +90.3% |
| 2.96 | off | 0.2030 | 0.2423 | +19.4% | 0.2362 | 0.2753 | +16.6% |
| 3.96 | on | 0.2056 | 0.4928 | +139.7% | 0.2342 | 0.5186 | +121.4% |
| 3.96 | off | 0.1554 | 0.1929 | +24.1% | 0.1894 | 0.2195 | +15.9% |
| 4.63 | on | 0.1850 | 0.4700 | +154.0% | 0.2113 | 0.4926 | +133.1% |
| 4.63 | off | 0.1390 | 0.1704 | +22.6% | 0.1648 | 0.1937 | +17.5% |
Why it misses, from the drag by part in the fixture:
- The fins past Mach 1.2. HPR Sim’s fins add about 0.30 from Mach 1.5 up. The measured fins-on less fins-off falls from 0.153 at Mach 1.5 to 0.046 at 4.63. HPR Sim’s increment is 78% above the measured increment at Mach 1.5 and 551% above it at 4.63 on the short model. The leading edge takes [N09]’s rounded-edge formula. Its value grows toward 1.2 on the fins’ frontal area, where a thin, sharp fin’s wave drag falls with Mach. Niskanen’s own comparison with this wind tunnel shows the same, his simulation about 80% high by Mach 3.96 ([N09] Fig. 6.6, p. 90). At Mach 0.6 HPR Sim’s fins are +10% and −15% of the measured increment. From 0.8 to 0.9 they rise sooner than the measured fins do.
- The boattail faster than sound. HPR Sim’s 15° boattail drags 0.285 from Mach 1.0 to 1.2, 0.196 at 1.5 and 0.037 at 4.63 (Boattails faster than sound). If the rest of HPR Sim’s forebody were right, the tunnel’s boattail would drag about 0.12 at Mach 1.5 and 0.08 to 0.11 at 1.8. That is 40% to 94% under HPR Sim. From Mach 3.96 it would drag next to nothing. Cubbage’s 16° boattails, in a boundary layer a fifth of the diameter thick, read high the same way, 26% to 54%. NASA reports the flow separating over this boattail at the higher Mach numbers ([D4014] p. 6). With the fins off HPR Sim reads +13.5% to +24.1% from Mach 1.5 (issue #72).
- The lip. The models end in a lip 1.3 mm (0.051 in) long. It flares from the boattail’s 33.2 mm (1.3 in) to the base’s 37.3 mm (1.5 in). It sits in the boattail’s wake, and HPR Sim gives it no pressure drag. Before M1.8b3 HPR Sim took it as a shoulder in the free stream, a stubby cone. It was worth 0.065 at Mach 0.6 and 0.084 to 0.086 from Mach 1.2. The short model keeps the fins’ raised root fairings with its fins off. HPR Sim leaves them out, and TN D-4013 blames them for its higher drag from Mach 0.975 to 1.2 (pp. 4–5).
- The boattail below Mach 1. [N09]’s boattail rule (eq. 3.88) gives the 15° boattail a pressure drag of 0.063 at Mach 0.6 (its 0.070 less its friction). The tunnel’s forebody holds that same pressure on the boattail’s surface. On the short model the whole forebody with its fins off measures 0.22 at Mach 0.6, against HPR Sim’s friction alone of 0.19. Little is left for the boattail’s pressure. The rule over-predicts this boattail, as Niskanen found against the same tunnel ([N09] p. 90). At Mach 0.6 and 0.8 HPR Sim’s forebody with its fins off is +12.0% to +22.8% high, most of it the boattail rule.
- Through Mach 1, where drag rises steeply, the short model’s measured forebody with fins off jumps from 0.29 to 0.42 between Mach 0.95 and 1.0. HPR Sim’s boattail rises from 0.076 at Mach 0.8 to 0.285 at 1.0, sooner than the tunnel’s. HPR Sim’s forebody with its fins off reads +38.8% to +54.1% from Mach 0.9 to 0.95 and +20.3% to +50.8% from Mach 1.0 to 1.2.
HPR Sim’s drag reads high for this rocket at every Mach number. From about Mach 1.2 the main cause is the thin, sharp fins, which HPR Sim takes as blunt. At every speed the steep boattail adds to it. The body alone reads +12.0% to +54.1%. Before HPR Sim modeled the boattail faster than sound, with the lip in it and no wave drag, it read −9.2% to +71.1%. The tunnel can’t measure HPR Sim’s base drag. It is compared with a calculation (Drag against MIL-HDBK-762’s sample calculation) and, behind boattails, with measured bases (Boattails faster than sound).
Drag through the speed of sound draws this comparison for a flier and marks the side that flatters. A drag that reads high reads the apogee low, as the test
a_higher_drag_reads_a_lower_apogee pins.
Drag against RASAero II through Mach 2
M1.8 asks for drag within 10% of the curves labeled RASAero in RocketPy’s example rockets from Mach 0.1 to 2.0, with the errors by band. HPR Sim doesn’t meet that. See ADR-029, the decision on this comparison, and ADR-030.
How it is compared. cargo xtask aero compares HPR Sim’s zero-lift
drag coefficient, , with each curve every 0.05 from
Mach 0.1 to 2.0, wherever the curve reaches. Each point is at sea level in the 1976 standard
atmosphere, at the Reynolds number for its Mach number, as
RASAero II computes its exports. The designs and their inputs are those of the Mach 0.3 check
above. Bands are Niskanen’s (Table 3.1): subsonic to Mach 0.8, transonic below 1.2, supersonic from
1.2. The fixture, rocketpy-drag-curves.json, holds HPR Sim’s value and the error
at every Mach number and each band’s summary. It doesn’t hold the curves, but the two numbers
give a curve’s value back at each Mach number.
drag::tests::supersonic_cd_against_rasaero_tables recomputes every row and pins the counts
(Loft lesson L18: Loft, the earlier simulator this project
learns from, used an invented transonic drag curve).
The curves don’t all reach Mach 2. Calisto’s, the one real RASAero II export, does (evidence row G26). Juno III’s is hand-edited past Mach 0.92. It climbs a constant step per row to Mach 1.0 and then drops to 0.001, so the comparison stops at 0.92. Cavour’s stop below Mach 0.93, and Valetudo’s at 1.53.
Rows within 10%, and the range of the errors, by band:
| case | to Mach | subsonic, to 0.8 | transonic | supersonic, from 1.2 |
|---|---|---|---|---|
| Calisto, 2018 fins | 2 | 15 of 15: −1.7% to +3.3% | 5 of 7: −10.1% to +13.4% | 8 of 17: −14.9% to −5.1% |
| Calisto, getting-started fins (variant) | 2 | 8 of 15: −12.1% to +24.5% | 0 of 7: +13.5% to +62.3% | 0 of 17: +22.6% to +31.7% |
| Juno III | 0.9 | 12 of 15: −10.7% to +2.4% | 0 of 2: +14.0% to +28.3% | n/a |
| Cavour, power-off | 0.85 | 6 of 15: −12.6% to −2.2% | 0 of 1: −12.6% | n/a |
| Cavour, power-on | 0.9 | 1 of 15: −26.2% to −9.2% | 0 of 2: −27.0% to −26.7% | n/a |
| Valetudo, power-off | 1.5 | 0 of 15: −51.4% to −43.5% | 0 of 7: −53.3% to −50.9% | 0 of 7: −54.6% to −52.9% |
| Valetudo, power-on | 1.5 | 0 of 15: −55.6% to −46.6% | 0 of 7: −57.6% to −54.7% | 0 of 7: −57.8% to −56.2% |
The getting-started fins are a variant. RocketPy’s getting-started example gives Calisto larger fins with a thick NACA 0012 airfoil. But the export was made for the 2018 fins, whose normal force it matches. So the variant’s rows show how much the fins move drag, not a second agreement. Its thick fins now read 23% to 32% high faster than sound. Calisto on its 2018 fins is within 10% up to Mach 0.85, at 0.95 and 1.0, and from 1.1 to 1.55. It reads +13.4% at Mach 0.9, where its boattail’s rise starts sooner than RASAero II’s. It reads −10.1% at Mach 1.05. It falls below the curve from Mach 1.6, to −14.9% at 2.0. Valetudo’s curve is 1.44 times its own OpenRocket export, as the Mach 0.3 check found, and Cavour’s power-on miss is the same open question. Two misses are unexplained. Cavour’s power-off curve rises faster than HPR Sim’s through subsonic flow, from −8.3% at Mach 0.3 to −12.6% at 0.85. Juno III’s curve stays flat up to Mach 0.91. There HPR Sim’s has begun its rise, its nose’s and its boattail’s, +14.0% at Mach 0.85 and +28.3% at 0.9.
What the boattail’s wave drag changed. Calisto ends in a short, steep conical boattail: 0.47 calibers long, narrowing to 69% of the diameter, a slope of 18.4°. Until M1.8b3 HPR Sim gave it only a share of the base drag, 0.083 at Mach 1.2 and 0.050 at 2.0. HPR Sim read −29.8% to −24.4% from Mach 1.2. The boattail’s supersonic wave drag (Boattails faster than sound) is 0.283 at Mach 1.2, 0.190 at 1.5 and 0.120 at 2.0. Calisto’s base drag falls by a third. Together they close the gap from 0.204 to 0.035 at Mach 1.2 and from 0.128 to 0.077 at 2.0. RASAero II lists such drag as its own term, “other body wave” drag. Calisto’s 18.4° boattail is steeper than any attached boattail measured here. 16° boattails read 26% to 54% high. So this agreement is not support for the model at that angle. What is left grows with Mach number. Part of it is HPR Sim’s body, which reads 6% to 10% low faster than sound against a worked example with every input known (below).
The unrecorded inputs now span most of the rest. Calisto’s fins could be square, rounded or an
airfoil, 2 to 6.35 mm (0.079 to 0.25 in) thick, smooth or painted (tests::calistos_rows_by_fin_and_finish). The committed inputs are square, 3 mm (0.12 in) and smooth by the rule of the Mach 0.3 check. They have 15, 5 and 8 rows within 10% by band. Rounded fins 4.76 mm (0.19 in) thick, smooth, have 6, 5 and 14. Airfoil fins
6.35 mm (0.25 in) thick, smooth, have 3, 4 and 17. No combination has every row within 10%. Before the
wave drag no combination had rows within 10% both below Mach 0.8 and from Mach 1.2. HPR Sim keeps the stated rule rather than
picking the inputs that fit.
Drag against MIL-HDBK-762’s sample calculation
RASAero II’s curves can’t show which way HPR Sim leans, because their inputs are guessed. A reference with every input known can. MIL-HDBK-762 is the U.S. Army’s handbook for designing unguided rockets. It works one rocket’s drag through by its own methods, term by term, from Mach 0.5 to 3.2 ([762] Table 5-4, pp. 5-58 to 5-66). The rocket is 3.84 m (12.6 ft) long and 0.16 m (0.52 ft) across. It has a 3-caliber tangent ogive nose and a plain cylinder with no boattail. Its four fins are 0.32 m (1.0 ft) long, 51 mm (2.0 in) tall and 6.4 mm (0.25 in) thick. They are flush with the base (Fig. 5-155).
This is a calculation, not a measurement: it checks HPR Sim’s methods against another set of
methods, whose base drag comes from measured bases. The table is transcribed with its pages in
mil-hdbk-762-sample-drag.json, and every row sums to its printed total.
The rocket is validation/designs/mil-hdbk-762-sample-rocket.json, with a smooth finish, as the
handbook’s friction is. HPR Sim flies it at the table’s Reynolds numbers.
tests::drag_against_mil_hdbk_762_sample recomputes the comparison in
drag-vs-mach.json and pins the rows within 10%. The 10% target comes from
M1.8. HPR Sim’s numbers for this rocket were seen before it was
chosen as a reference, so this is not a blind test.
The fins are left out. The handbook draws each fin as a single wedge, sharp at the leading edge and blunt at the trailing edge. It gives the fins a thin wedge’s wave drag and the base drag of their trailing edges. HPR Sim has no such section. The design gives them square edges. HPR Sim charges their leading edges the pressure of air brought to a stop against them. The charge is 0.100 at Mach 2, against the handbook’s 0.016 for the whole fin. So each side’s fin pressure drag is shown but left out of the totals compared; the fins’ friction stays in.
Each term, the handbook’s first and then HPR Sim’s, on the reference area:
| Mach | handbook drag coefficient | HPR Sim drag coefficient | error | nose coefficient (handbook, HPR Sim) | base coefficient | friction coefficient | fins coefficient, left out (handbook, HPR Sim) |
|---|---|---|---|---|---|---|---|
| 0.5 | 0.423 | 0.379 | −10.3% | 0.000, 0.000 | 0.170, 0.152 | 0.253, 0.227 | 0.023, 0.069 |
| 0.7 | 0.405 | 0.401 | −1.1% | 0.000, 0.006 | 0.163, 0.184 | 0.242, 0.211 | 0.023, 0.075 |
| 0.9 | 0.393 | 0.484 | +23.1% | 0.007, 0.062 | 0.156, 0.225 | 0.230, 0.197 | 0.023, 0.082 |
| 0.95 | 0.404 | 0.533 | +31.9% | 0.011, 0.102 | 0.163, 0.237 | 0.230, 0.194 | 0.026, 0.085 |
| 1.0 | 0.465 | 0.609 | +31.0% | 0.052, 0.164 | 0.183, 0.250 | 0.230, 0.195 | 0.043, 0.087 |
| 1.1 | 0.542 | 0.651 | +20.1% | 0.109, 0.234 | 0.215, 0.227 | 0.218, 0.189 | 0.043, 0.089 |
| 1.2 | 0.528 | 0.593 | +12.3% | 0.117, 0.200 | 0.194, 0.208 | 0.217, 0.184 | 0.036, 0.091 |
| 1.6 | 0.472 | 0.444 | −6.0% | 0.109, 0.123 | 0.168, 0.156 | 0.195, 0.165 | 0.022, 0.097 |
| 2.0 | 0.415 | 0.377 | −9.2% | 0.095, 0.104 | 0.147, 0.125 | 0.173, 0.147 | 0.016, 0.100 |
| 2.4 | 0.363 | 0.331 | −8.9% | 0.089, 0.094 | 0.124, 0.104 | 0.150, 0.132 | 0.013, 0.102 |
| 2.8 | 0.328 | 0.296 | −9.6% | 0.085, 0.088 | 0.106, 0.089 | 0.137, 0.119 | 0.011, 0.103 |
| 3.2 | 0.298 | 0.269 | −9.6% | 0.083, 0.084 | 0.089, 0.078 | 0.126, 0.107 | 0.009, 0.103 |
Six of twelve rows are within 10%. HPR Sim reads +12.3% to +31.9% high from Mach 0.9 to 1.2, and −6.0% to −9.6% low from Mach 1.6:
- The nose through Mach 1. Niskanen’s ogive gives two to three times the handbook’s: 0.164 against 0.052 at Mach 1.0, and 0.234 against 0.109 at 1.1. Stoney’s measured 3:1 cone also sits under Niskanen’s closed form through the rise (Drag through Mach 1). From Mach 2 the two agree within 10%.
- The base. Niskanen’s base drag (eq. 3.94, after Fleeman’s missile design textbook) gives 0.250 at Mach 1.0 where the handbook reads 0.183 from measured bases. Faster than sound HPR Sim’s is the lower: 0.125 against 0.147 at Mach 2.
- Friction reads 10.4% to 15.9% lower in HPR Sim. The handbook takes a smooth flat plate’s friction and adds 15% on the body. HPR Sim’s body factor ([N09] eq. 3.85) adds 2% for this slender body, which accounts for about 11 points. The rest is unexplained; the two methods correct friction for Mach number differently.
So HPR Sim’s body reads high through Mach 1, from the nose and the base. It reads 6% to 10% low faster than sound, from friction and the base. That is the same sign as Calisto’s gap to RASAero II, which is −14.9% to −5.1% from Mach 1.2 to 2. This rocket has no boattail, so it says nothing about a boattail’s own drag.
A tangent ogive past Mach 1, beside OpenRocket 24.12
What is checked: the pressure drag HPR Sim gives a tangent ogive nose of fineness ratio 3 at Mach 1.3, 1.5 and 2, against the closed form of the method it follows, with OpenRocket 24.12’s beside it; and from Mach 1 to 1.3, every 0.01, beside OpenRocket 24.12’s. Pressure drag is the drag from the air’s pressure on the nose, mostly wave drag past Mach 1. The result: HPR Sim gives the method’s value. OpenRocket 24.12 gives under 1% of it at Mach 1.3, 1.5 and 2, and between 0.6% and 32.2% of it from Mach 1 to 1.3. This is one code against another, not a measurement. It shows where the two differ. It doesn’t show which matches a real nose.
The probe is an invented rocket: a nose 150 mm (5.9 in) long on a tube 50 mm (2.0 in) across, with a 500 mm (19.7 in) tube and three fins behind it.
The method is the one in Niskanen’s thesis ([N09], appendix B). It gives an ogive the drag of the cone with its length and base diameter, times (eq. B.8). Here is the tangent ogive’s arc radius over the nose’s own arc radius: 1 for a tangent ogive. The factor is then exactly 1, so the nose drags as that cone, its equivalent cone. The cone’s half-angle has for fineness ratio . From Mach 1.3 up, at Mach number , eq. B.4 gives it, on its base area,
At and , where and :
The nose’s pressure drag coefficient on its base area, at zero angle of attack:
| Mach | equivalent cone (coefficient) | HPR Sim, tangent ogive (coefficient) | OpenRocket 24.12, tangent ogive (coefficient) | OpenRocket 24.12, cone (coefficient) |
|---|---|---|---|---|
| 1.3 | 0.15571 | 0.15571 | 0.00098 | 0.15571 |
| 1.5 | 0.13028 | 0.13028 | 0.00073 | 0.13028 |
| 2 | 0.10421 | 0.10421 | 0.00047 | 0.10421 |
- HPR Sim’s number is its code’s output for the nose, not the formula. It agrees with the equivalent cone’s to .
- OpenRocket’s numbers are what OpenRocket’s own drag calculation reports for the nose, read from OpenRocket itself by a script.
- The control is the number headed “OpenRocket 24.12, cone”: the same rocket with a conical nose of the same length and base. OpenRocket 24.12 returns the closed form for it, within at Mach 1.5 and 2 and low at Mach 1.3. The cause of that small miss wasn’t examined. So the number read for a nose is the nose’s own pressure drag.
- The area. On this probe the tube is as wide as the nose’s base, so the rocket’s reference area is the nose’s base area and nothing is rescaled. A second control shows that OpenRocket’s number is on the reference area. With the body widened behind the nose to 80 mm (3.1 in), the reference area is 2.56 times the nose’s base, and OpenRocket’s number for the nose falls to 1/2.56 of the first control’s.
- OpenRocket 24.12’s tangent ogive is under 1% of the equivalent cone’s at each Mach number in this table. That is the defect OpenRocket’s issue #3391 reported on this shape. A maintainer confirmed it on November 2, 2026, and a fix was merged to OpenRocket’s development branch that day (pull request #3431). Above Mach 1, OpenRocket 24.12 fed the cone formula the angle at which the nose meets the body tube, where the method takes the equivalent cone’s half-angle. For a tangent ogive that angle is almost zero, and so is the drag. By November 14, 2026 no release carried the fix.
What follows: at Mach 1.3, 1.5 and 2, OpenRocket 24.12 gives this nose almost none of the pressure drag its own documented method gives.
From Mach 1 to 1.3. A second set of runs asks OpenRocket 24.12 the same two noses, the tangent ogive and its cone, at each of the 31 Mach numbers from 1 to 1.3, in steps of 0.01 (its record). Below Mach 1.3 eq. B.4 doesn’t apply. The method gives a cone at Mach 1, here , and joins it to eq. B.4’s value at Mach 1.3 by the cubic that meets both ends’ values and slopes ([N09] eq. B.3 to B.6). HPR Sim’s number is its code’s output, and it gives the tangent ogive exactly its equivalent cone’s value at every row. So its coefficient rises from 0.16440 at Mach 1 to 0.23428 at Mach 1.1, the highest of the 31 rows, and falls to 0.15571 at Mach 1.3. The nose’s pressure drag coefficient on its base area, at zero angle of attack, at seven of the 31 rows:
| Mach | HPR Sim, tangent ogive (coefficient) | OpenRocket 24.12, tangent ogive (coefficient) | OpenRocket 24.12, cone (coefficient) |
|---|---|---|---|
| 1 | 0.16440 | 0.00162 | 0.16440 |
| 1.05 | 0.21816 | 0.05858 | 0.21741 |
| 1.1 | 0.23428 | 0.07551 | 0.23427 |
| 1.15 | 0.22441 | 0.06354 | 0.22412 |
| 1.2 | 0.20024 | 0.03824 | 0.20024 |
| 1.25 | 0.17345 | 0.01294 | 0.17363 |
| 1.3 | 0.15571 | 0.00098 | 0.15571 |
- Which way they differ. OpenRocket 24.12’s tangent ogive is below HPR Sim’s at every row, by 0.155 to 0.163 in the coefficient. It is 1.0% of HPR Sim’s value at Mach 1, rises to 32.2% at Mach 1.1 and falls to 0.6% at Mach 1.3. Its curve has the shape of HPR Sim’s, a rise to Mach 1.1 and a fall, but from a start near zero, so it peaks at 0.0755 where HPR Sim’s peaks at 0.234. OpenRocket’s issue #3391 reports that peak as a false hump of about 0.075 near Mach 1.1.
- The control. OpenRocket 24.12’s cone matches HPR Sim’s cone within at every even hundredth (Mach 1.00, 1.02 and so on). So the number read is again the nose’s own pressure drag. At each odd hundredth, OpenRocket’s number for either nose is the mean of the two beside it, as if it read its curve every 0.02 and drew straight lines between. That leaves its cone within 0.00094 of HPR Sim’s, 0.53%, the most at Mach 1.01.
So from Mach 1 to 1.3, too, OpenRocket 24.12 gives this tangent ogive far less pressure drag than its documented method gives: 0.6% to 32.2% of HPR Sim’s. This is code against code, and it doesn’t show which matches a real nose.
What the two codes’ noses do to an apogee is sized, code against code, on the designs of 5 logged flights that pass Mach 1 with a tangent-ogive nose. They reach Mach 1.06 on average and none passes Mach 1.3, so they sit in the band of the runs from Mach 1 to 1.3. Flown with OpenRocket’s number for the nose above Mach 1 in place of its own, HPR Sim climbs higher by 1.28% of OpenRocket’s apogee on average (the tangent-ogive nose’s line, M2.3c13, which sized it). The design library’s report sizes a faster flight, on HPR Sim’s own thrust and mass rather than OpenRocket’s. On its one supersonic flight the swap alone moves the apogee from +13.60% to +31.73% of OpenRocket’s. With OpenRocket’s base rule as well, it comes to +0.45% (a supersonic flight).
What stays open: whether the equivalent cone’s value matches a measured tangent ogive (evidence row G40, the nose’s pressure drag past Mach 1, #222, the supersonic drag gap to OpenRocket, #616, the nose scored against measured tangent ogives). Published NACA and Air Force reports, read in a research note and not yet committed as data, lean one way near Mach 1.5. Their means put a nose of this shape at 0.110 to 0.119, against HPR Sim’s 0.130. One report’s four cases, as the note works them out, span 0.103 to 0.136. If the means hold, HPR Sim’s nose drag is high there, which lowers its apogee. From Mach 2 to 3 the reports disagree with each other by 10% to 20%, so nothing is settled there. The MIL-HDBK-762 sample calculation above works a 3-caliber tangent ogive by the handbook’s methods.
The records are
openrocket-nose-pressure-drag.json,
written by validation/oracles/openrocket/nose_pressure_drag.py, and
openrocket-nose-pressure-drag-transonic.json,
written by nose_pressure_drag_transonic.py beside it; both need the OpenRocket 24.12 jar to run
again. The tests
openrocket::tests::a_tangent_ogive_s_pressure_drag_past_mach_1_beside_openrocket_24_12_s and
a_tangent_ogive_s_pressure_drag_from_mach_1_to_1_3_beside_openrocket_24_12_s in
hpr-validate pin every number in the two tables
(ADR-349, the decision that set this probe up).
The Basic Finner’s normal force against DREV’s range
In short: on the Basic Finner, HPR Sim’s normal-force slope reads 9.3% to 24.9% below the measured one from Mach 1.08 to 3.15, and its center of pressure lies 0.03 to 0.34 calibers forward of the measured one. Forward is the side that understates stability. The cause is not found.
What is checked: HPR Sim’s slope and center of pressure at a small angle of attack, against fits of free flights in the aeroballistic range of Canada’s DREV ([DREV] Table IX, PDF pp. 48–49). The model is the Basic Finner, a standard test body: a cone of 10° half-angle on a cylinder, 10 calibers long in all, with four fins at the base, each a square one caliber in chord and span ([DREV] Fig. 2, PDF p. 53). Each row is one six-degree-of-freedom fit of two to four flights of 30 mm (1.2 in) models at one Mach number.
DREV’s Table IX has eight rows. The six at or below Mach 3.5, the top of the envelope, are typed
into the reference, and the model is a committed design. cargo xtask aero writes the comparison to
the report, and hpr_aero::tests::basic_finner_normal_force_against_drev recomputes
every figure in it. The increment that added it set no
target.
The measured center of pressure is worked out, not printed. The report gives the slope and the pitching-moment slope , both per radian on the body’s cross-section, the moment about a point 5.50 calibers from the nose tip. It does not state the moment’s reference length. The body’s diameter is taken (the decision that set this comparison up, decision 4). A force that acts aft of that point turns the nose down, a negative moment, so the center of pressure, in calibers from the nose tip, is
For example, at Mach 1.832 the table gives and , so the center of pressure is from the nose tip, in calibers. Its probable error is the ratio’s, with the two slopes’ errors taken as independent. The table gives 4% for the slope and prints 0% for the moment, taken here as 0.5%. Together they are 4.03% of the 2.37-caliber arm, 0.10 calibers.
The slope. HPR Sim’s is the sum of its body’s part and its fins’, the fins’ with their interference with the body. The report measured the whole model only. The error is HPR Sim’s less DREV’s, as a share of DREV’s, worked from the unrounded figures, so a negative one is low.
| Mach | DREV’s , per rad (probable error) | HPR Sim’s body, per rad | HPR Sim’s fins, per rad | HPR Sim’s , per rad | error |
|---|---|---|---|---|---|
| 1.077 | 18.47 (2%) | 2.00 | 11.86 | 13.86 | −24.9% |
| 1.293 | 18.27 (3%) | 2.20 | 11.52 | 13.71 | −24.9% |
| 1.832 | 11.78 (4%) | 3.05 | 7.41 | 10.46 | −11.2% |
| 2.375 | 10.52 (2%) | 3.25 | 5.57 | 8.83 | −16.1% |
| 2.718 | 9.01 (2%) | 3.33 | 4.84 | 8.17 | −9.3% |
| 3.147 | 8.69 (1%) | 3.39 | 4.17 | 7.56 | −13.0% |
The center of pressure, in calibers from the nose tip. DREV’s is the one worked out above from its two slopes, with its probable error in parentheses. The error is HPR Sim’s less DREV’s, so a negative one is forward.
| Mach | DREV’s, calibers (probable error) | HPR Sim’s, calibers | error, calibers |
|---|---|---|---|
| 1.077 | 8.35 (0.06) | 8.28 | −0.07 |
| 1.293 | 8.29 (0.08) | 8.26 | −0.03 |
| 1.832 | 7.87 (0.10) | 7.54 | −0.34 |
| 2.375 | 7.30 (0.04) | 7.12 | −0.18 |
| 2.718 | 7.19 (0.03) | 6.91 | −0.27 |
| 3.147 | 6.93 (0.02) | 6.70 | −0.23 |
By band. From Mach 1.5 to 2.5, the band this comparison was added for, the slope reads 11.2% and 16.1% low and the center of pressure 0.34 and 0.18 calibers forward. Below Mach 1.5 the slope reads 24.9% low at both Mach numbers, with the center of pressure 0.07 and 0.03 calibers forward. From Mach 2.5 to 3.5 the slope reads 9.3% and 13.0% low, and the center of pressure 0.27 and 0.23 calibers forward.
At each fit’s root-mean-square yaw. The table’s mean squared yaw is read here as the mean square of the whole angle of attack. On these six rows the fits hold at zero the terms that grow with the cube of that angle, so each measured slope is a straight-line fit over the angles the models flew. The table gives each fit’s mean squared yaw, 0.7 to 1.9 square degrees. HPR Sim’s body lift grows with the angle, so at an angle its is above its small-angle slope. At each fit’s root-mean-square yaw the slope’s miss is 0.8 to 2.4 percentage points smaller, and the center of pressure 0.02 to 0.04 calibers further forward:
| Mach | root-mean-square yaw, degrees | HPR Sim’s there, per rad | error | center-of-pressure error, calibers |
|---|---|---|---|---|
| 1.077 | 0.95 | 14.01 | −24.1% | −0.10 |
| 1.293 | 1.22 | 13.91 | −23.9% | −0.07 |
| 1.832 | 0.84 | 10.59 | −10.1% | −0.36 |
| 2.375 | 1.00 | 8.98 | −14.6% | −0.21 |
| 2.718 | 1.38 | 8.39 | −6.9% | −0.31 |
| 3.147 | 1.14 | 7.74 | −10.9% | −0.26 |
This is nearer like for like, not like for like. A straight line fitted over a spread of angles leans toward the larger ones: the fit weights them more, and the part of the lift that grows with the square of the angle is largest there. So the root-mean-square yaw is a low reading of the angle a fit stands for. At a larger one HPR Sim’s miss in the slope would be smaller again and, by the trend of the table above, its miss in the center of pressure larger.
Under each mean squared yaw, DREV’s table prints a second figure, headed ABARM. The report defines no such symbol. It defines AMAX, the maximum angle of attack, but the table does not give it. So the comparison stops at the root-mean-square yaw.
What it means. HPR Sim’s slope is low on every row, by more than the fit’s probable error. Its center of pressure is forward on every row, and by more than the probable error on all but Mach 1.293: narrowly at Mach 1.077, 0.07 against 0.06 calibers, and by more than three times it from Mach 1.832 up. Both hold at a small angle and at each fit’s root-mean-square yaw. On this body, then, HPR Sim understates the stability margin: with the models’ center of gravity at 5.50 calibers, where the report’s drawing puts it and the fits take their moments, the measured margin at Mach 1.832 is 2.37 calibers and HPR Sim’s is 2.04. The test pins each row’s sign and size, so a change to the model that moved the center of pressure aft of the measured one would fail it.
The direction is this body’s and does not carry to another rocket. Faster than sound, a small change of shape can take a body off the shock-expansion method and onto slender-body theory: the switches (The body faster than sound in a flight). At four of them (a step in radius, a flare too long for its boattail’s wake, a pointed tip steeper than 30°, and a vertical tip steeper than the cap’s handover) HPR Sim’s center of pressure then lies aft of where the shock-expansion method puts it, the side that overstates stability. At the fifth, a lip longer than its boattail’s drop, it lies forward. Those are jumps between two of HPR Sim’s own methods, not errors against a measurement, so which way the center of pressure moves on a given rocket depends on its body.
The cause is not found (#1502). The measurement can’t say whether the missing lift is the fins’ or the body’s, since it has no fins-off flights. The row at Mach 1.077 goes to the transonic increment, where the long Arcas Robin model’s slope reads both ways, from 8.8% low to 27.1% high (Normal force through Mach 1). The rows from Mach 1.293 to 2.375 go to the supersonic increment, and the two above Mach 2.5 to the extended band’s. An earlier issue, #619, tracks the two rows below Mach 1.5.
What it leaves out.
- The fins’ section. The report draws each fin as a single wedge, sharp at the leading edge and 0.08 calibers thick at the trailing edge. HPR Sim has no such section, and its fin lift uses the planform alone, so the design gives them a square section of that thickness. The lift a wedge’s thickness adds is not modeled.
- Spin. The models’ fins were canted 0°, 2° or 4°, and the fits pool flights of all three where they could, so some models rolled. The design’s fins are not canted.
- Drag and pitch damping. The same table gives both. The next section compares them.
- The rows past Mach 3.5. The table’s last two, at Mach 3.734 and 4.300, are outside the envelope and are not typed.
The Basic Finner’s drag and pitch damping against DREV’s range
In short: on the Basic Finner, with the drag of its wedge fins, which HPR Sim can’t draw, added from published figures, HPR Sim’s zero-lift drag reads 16.5% to 21.3% below the measured one from Mach 1.83 to 3.15, and its pitch damping 24.7% to 39.6% below it. Below Mach 1.5 the drag reads 10.1% high at Mach 1.077, in a band that reaches below the measured one, and 3.5% low at 1.293; the damping reads 25.4% high and 16.8% low. Less damping than measured lets a swing in pitch die away more slowly than it does, so the rocket looks less steady than it is: the side that does not flatter. More, at Mach 1.077, is the side that does. The cause of the drag’s miss is not found.
What is checked: HPR Sim’s drag coefficient at zero angle of attack, , against the
axial-force coefficient of the same range fits as
the normal force above ([DREV] Table IX,
PDF pp. 48–49), and its pitch damping, the moment that resists a rate of pitch, against their
.
Both are on the body’s cross-section, the damping about the same point, 5.50 calibers from the
nose tip. The six rows, each shot’s own drag from the single fits (Table VIII, PDF pp. 44–46) and
its Reynolds number (Table V, PDF p. 41) are in the reference. HPR Sim’s drag on each row is taken at the mean of its shots’
Reynolds numbers, 23.8 to 70.2 million per meter. cargo xtask aero
writes the report, and hpr_aero::tests::basic_finner_drag_and_damping_against_drev
recomputes every figure in it. The increment that added it
set no target.
The drag. The models’ fins are single wedges, sharp at the leading edge and 0.08 calibers thick at the trailing edge. HPR Sim has no such section, so the design draws them square, 0.08 calibers thick. A square fin’s blunt leading edge meets the air at its stagnation pressure, so as drawn HPR Sim’s drag reads 34.5% to 138.1% above DREV’s, which says nothing about the rest of the body. So the report takes out the square edges’ two terms, the leading edge’s and HPR Sim’s trailing-edge rule, and puts in the wedge’s two, from cited sources (the wedge note, its figures):
- The faces. Each face turns the flow by , half the 0.08-caliber thickness over the one-caliber chord. From Mach 1.293 up the shock stands attached at the sharp edge, and the face pressure is the oblique shock’s (NACA Report 1135 eqs. 128 and 138). At Mach 1.077 the shock stands off; there the faces take Vincenti and Wagoner’s transonic value (NACA Report 1095 Fig. 7). That two-dimensional value is “an approximate upper bound” for a wing of finite span (p. 11), and nothing bounds it from below, so the band’s high end adds its reading error and its low end takes the faces at zero.
- The trailing edges. Their base drag is a two-dimensional base’s with a turbulent boundary layer, a band read from Hoerner’s measurements and Love’s compilation (NACA TN 3819 Fig. 5). It lies 1.3 to 3.1 times above HPR Sim’s own trailing-edge rule, which is a rocket base’s (#1514).
For example, at Mach 2.375 the buildup as drawn is 0.934. Of that, its square leading edge is 0.592 and its trailing-edge rule 0.043, which leaves 0.299 for the body, the nose, the friction and the body’s base. The wedge’s faces add 0.016 and its trailing edges 0.065 to 0.073, so HPR Sim’s is 0.384, from 0.380 to 0.388. DREV’s is 0.484, so HPR Sim reads 20.6% low.
| Mach | DREV’s (coefficient) | its shots’ drag coefficient | HPR Sim’s drag coefficient, square edges out (coefficient) | the wedge faces’ drag coefficient | the wedge trailing edges’ drag coefficient | HPR Sim’s (coefficient; band) | error (band) |
|---|---|---|---|---|---|---|---|
| 1.077 | 0.863 | 0.854 to 0.868 | 0.606 | 0.110 | 0.175 to 0.293 | 0.950 (0.781 to 1.011) | +10.1% (−9.5% to +17.1%) |
| 1.293 | 0.731 | 0.701 to 0.760 | 0.487 | 0.043 | 0.151 to 0.200 | 0.706 (0.681 to 0.730) | −3.5% (−6.8% to −0.1%) |
| 1.832 | 0.585 | 0.567 to 0.598 | 0.362 | 0.022 | 0.098 to 0.110 | 0.488 (0.482 to 0.494) | −16.5% (−17.6% to −15.5%) |
| 2.375 | 0.484 | 0.473 to 0.500 | 0.299 | 0.016 | 0.065 to 0.073 | 0.384 (0.380 to 0.388) | −20.6% (−21.4% to −19.7%) |
| 2.718 | 0.435 | 0.400 to 0.452 | 0.272 | 0.014 | 0.053 to 0.061 | 0.342 (0.338 to 0.346) | −21.3% (−22.2% to −20.4%) |
| 3.147 | 0.373 | 0.350 to 0.385 | 0.244 | 0.012 | 0.041 to 0.049 | 0.301 (0.297 to 0.305) | −19.3% (−20.4% to −18.2%) |
The table’s has a printed probable error only at the first two rows, under 0.5%. At the other four, each shot was fitted its own (DREV’s section 5.2), and every shot’s fit prints under 0.5% too; the shots column gives their spread. The error is HPR Sim’s over DREV’s, less 1, from unrounded values, and the band takes both ends of the wedge’s figures.
The pitch damping. A free flight measures how fast the model’s swing in pitch dies away. HPR Sim’s damping is not a coefficient it adds: the flight engine takes each part’s force in its own local flow, which the rotation changes. Pitching at a rate about the reference point tilts the flow at a part behind it by , with the airspeed and the body’s diameter. That part’s slope times that angle is a force, and the force times again is the damping moment. As a coefficient per radian of , summed over the parts,
where, strictly, is a part’s arm to where the engine takes its flow times its arm to
its own center of pressure (hpr_aero::AeroModel::pitch_damping; a test in hpr_sim holds the engine’s moment to it within
0.01%). DREV’s equation for the damping rate, eq. [1] (PDF p. 28), implies the same convention:
with no spin it reduces to the rate of a swing damped by and by per
. A free flight can’t part from , the moment from the rate of
change of the angle of attack, so DREV’s figure is their sum. HPR Sim has no , so
its is the whole of its damping.
For example, at Mach 2.375 HPR Sim’s fins lift 5.573 per radian at 3.978 calibers behind the reference point, which gives . With the body’s −49.85 it is −226.2, against DREV’s −306.5: 26.2% less damping.
| Mach | DREV’s , per rad (probable error) | HPR Sim’s body, per rad | HPR Sim’s fins, per rad | HPR Sim’s , per rad | error |
|---|---|---|---|---|---|
| 1.077 | −322.4 (5%) | −52.0 | −352.3 | −404.3 | +25.4% |
| 1.293 | −487.4 (6%) | −50.5 | −355.1 | −405.6 | −16.8% |
| 1.832 | −377.7 (4%) | −51.1 | −233.2 | −284.3 | −24.7% |
| 2.375 | −306.5 (4%) | −49.9 | −176.4 | −226.2 | −26.2% |
| 2.718 | −335.5 (3%) | −49.2 | −153.5 | −202.7 | −39.6% |
| 3.147 | −260.1 (3%) | −48.6 | −132.4 | −181.0 | −30.4% |
A positive error is more damping than measured. DREV’s report notes that its damping scatters more than its other coefficients and that the multiple fit near Mach 2.4 is off the trend.
By band. From Mach 1.5 to 2.5, the band this comparison was added for, the drag reads 16.5% and 20.6% low and the damping 24.7% and 26.2% low. Below Mach 1.5 the drag reads 10.1% high and 3.5% low, and the damping 25.4% high and 16.8% low. From Mach 2.5 to 3.5 the drag reads 21.3% and 19.3% low and the damping 39.6% and 30.4% low.
What it means. From Mach 1.832 up HPR Sim’s drag is below every shot of its row at both ends of the wedge’s band. It stays below DREV’s even with the trailing edges at a vacuum, the most a base can add: so the miss is not the wedge’s base. Its cause is not found (#1513). The candidates are the body’s base, the friction and how the fins’ bases share the body’s wake, and none is measured here. On this body a drag that low would, other things equal, put a simulated apogee too high. At Mach 1.293 the drag is inside the shots’ spread. At Mach 1.077 the value with the faces at that upper bound and the trailing edges at their band’s middle reads 10.1% high, above every shot, but its low end reads 9.5% low: the faces’ figure is an upper bound with nothing below it, the trailing edges rest on one steep figure, and the row’s three shots flew from Mach 1.056 to 1.116, where that figure moves fast. So the sign there is not settled. A drag that reads high puts a simulated apogee too low, the side that flatters when it is held against an altitude waiver’s ceiling.
The damping is low in size wherever the shock stands attached, by 2.8 to 13.2 times the fit’s probable error: HPR Sim lets this body’s swing in pitch last longer than it did, the side that does not flatter. Part of that is the lift: from Mach 1.83 up HPR Sim’s slope reads 9.3% to 16.1% low (above; #1502). Part may be the that HPR Sim leaves out; nothing here parts the two. At Mach 1.077 HPR Sim overstates the damping by 25.4%, five times the fit’s probable error. The test pins each row’s sign and size, for the drag and the damping.
What it leaves out.
- The wedge’s base beside the body’s. The fins end flush with the body’s base. No source read here measures a fin’s base pressure there, so the band is a free two-dimensional base’s.
- Spin. The fits pool models with fins canted 0°, 2° and 4°. The design’s fins are not canted, and the drag of rolling is not modeled.
- The drag’s growth with angle. The table’s is not compared; HPR Sim’s is at zero angle.
Roll against the Arcas Robin and the Basic Finner
What is checked: HPR Sim’s roll forcing against NASA’s measured roll effectiveness of the two Arcas Robin models, Mach 1.5 to 4.63 ([D4014] Fig. 14). HPR Sim’s roll damping is checked against the Basic Finner’s measured in NOL’s wind tunnel from Mach 1.53 to 2.76 ([N6652] Table 2; Mach 2.76 from Table 1, where Table 2 prints 2.70), and against DREV’s free-flight range fits from Mach 1.83 to 3.15 ([DREV] Table IX). It is also checked against Barrowman’s own computed value at Mach 0.07
([B67] Figs. 5-6 and 5-7). The readings are in the wind-tunnel fixture and
the Basic Finner’s; cargo xtask aero writes the comparison to
the roll fixture, and hpr_aero::tests::roll_against_mach recomputes every row.
The roadmap set no target.
The forcing. per degree of cant, on the body’s cross-section and diameter, at an angle of attack of 0. The reports’ symbol is per degree, and the models’ fins were canted 2°:
| Mach | model | measured , per degree (the report’s) | HPR Sim’s , per degree | error |
|---|---|---|---|---|
| 1.5 | short | 0.1684 | 0.2489 | +47.8% |
| 1.8 | short | 0.1722 | 0.1968 | +14.3% |
| 1.8 | long | 0.1670 | 0.1968 | +17.8% |
| 2.3 | short | 0.1449 | 0.1495 | +3.2% |
| 2.3 | long | 0.1460 | 0.1495 | +2.4% |
| 2.96 | short | 0.1152 | 0.1151 | −0.1% |
| 2.96 | long | 0.1140 | 0.1151 | +1.0% |
| 3.96 | short | 0.0874 | 0.0861 | −1.4% |
| 3.96 | long | 0.0870 | 0.0861 | −1.0% |
| 4.63 | short | 0.0721 | 0.0739 | +2.5% |
| 4.63 | long | 0.0780 | 0.0739 | −5.3% |
The two models differ only in the body’s length ahead of the fins, which HPR Sim’s forcing doesn’t see. The measured values differ by up to 0.006 per degree (8%, at Mach 4.63). The report calls the effectiveness “about the same for either vehicle” ([D4014] p. 6). The short model’s readings were corrected when roll was added. The first reading had put each of its panels’ zeros 0.005 to 0.007 above the grid line it lies on (ADR-031). From Mach 2.3 all 8 are within 5.3%. At Mach 1.5 and 1.8 HPR Sim reads high, as Barrowman found for another sounding rocket. HPR Sim reads high because linear theory’s load climbs toward Mach 1 faster than the fins’ does. Without the body factor (0.935 here) every value would be 7% higher.
The damping. of the Basic Finner, four square fins one diameter in chord and span on a body one diameter across, per unit of on . The scored reference is NOL’s wind tunnel: models spun at 50 to 150 rev/s and left to slow, at an angle of attack of 0 ([N6652] Table 2, PDF p. 17, its average column). NOL prints its coefficient on one fin panel and the 3 d span. Times it is on the body’s cross-section and diameter, a factor two other reports confirm (research note). For example, at Mach 1.53 NOL prints 0.532, so ; HPR Sim gives −31.08, 27.5% more damping.
| Mach | reference | reference’s damping coefficient | HPR Sim’s damping coefficient | error |
|---|---|---|---|---|
| 0.07 | Barrowman’s computed curve (chose the method; not a validation) | −34.21 | −33.53 | −2.0% |
| 1.53 | NOL wind tunnel | −24.39 | −31.08 | +27.5% |
| 2.03 | NOL wind tunnel | −19.34 | −22.53 | +16.5% |
| 2.27 | NOL wind tunnel | −17.01 | −20.12 | +18.3% |
| 2.54 | NOL wind tunnel | −16.13 | −18.02 | +11.7% |
| 2.76 | NOL wind tunnel | −14.44 | −16.63 | +15.2% |
Against DREV’s range, free flights of 30 mm (1.2 in) models fitted several rounds at a time ([DREV] Table IX,
PDF pp. 48–49), HPR Sim reads high too. In the core band (Mach 1.83 and 2.38) it reads 8.8% high on
average and 12.4% at most; in the extended band (2.72 and 3.15), 5.0% on average and 8.7% at most.
cargo xtask roll-drev flies this from the report’s readings cached outside the repository and
commits only these statistics (the DREV statistics); the gate’s refs step checks them.
Barrowman’s Fig. 5-7 points are no longer scored. They read −33.60, −27.45, −23.48, −20.92 and −18.32 at Mach 1.51, 1.82, 2.27, 2.60 and 3.00, and HPR Sim reads 5.9% to 16.2% below them. They sit a flat 1.27 times BRL Report 799’s free-flight range data as NOL replots it, which fits a slip in convention rather than a difference in the air (research note). They stay in the Basic Finner’s fixture as a disputed set.
HPR Sim reads high faster than sound, most near Mach 1.5. The likely cause there, an inference not shown: linear theory’s load rises as toward Mach 1 faster than the fins’ does, as in the forcing above. That doesn’t explain the 11.7% to 18.3% left from Mach 2.03 to 2.76. Part of it may be NOL’s own: its tunnel values “fell slightly below” the free-flight data it plotted beside them ([N6652] PDF p. 13), and against DREV’s free flights HPR Sim reads closer. The fins’ 8% thickness is unlikely to be the cause (an inference). BRL Report 711 flew the same shape (a 3 d span on a 1 d body) with thicker wedges, 16% at the trailing edge. They read 21% above its linear theory, which has no body factor; taking out HPR Sim’s of 1.167 for that shape leaves about 4%. Its linear lift for such a wedge is about 15% below exact theory’s near Mach 1.7. Both point the same way: a thickness term would raise the damping, not lower it. With the forcing right, a damping 11.7% to 27.5% high makes the steady spin about 10% to 22% low (). Near Mach 1.5 the forcing reads high too, on the Arcas Robin: errors from two bodies that partly cancel. Barrowman’s own curve comes from Busemann’s third-order expansion ([B67] eq. 3-7), which counts the fins’ thickness. His text gives 5.68% between it and the Fig. 5-7 points without saying how it is taken ([B67] p. 66); read off the figure, the gap is 2% to 7%. At Mach 0.07 HPR Sim gives his computed value within 2.0%. That is how HPR Sim’s reading of his damping method, the fin’s own slope over the strips, was checked (above).
The flight (hpr_sim::tests::canted_fins_spin_to_the_analytic_balance): Valetudo with 1° of
cant at 100 m/s (328 ft/s), with no drag or gravity, settles on the steady roll rate. The worked example’s closed-form rate is −16.948 rad/s, and the flight is within 1e-6 of it (the test’s bound; 1e-11 measured). One time constant in, the roll rate is within 1e-5 of the exponential approach (2e-10 measured). No pitch or yaw appears.
The pieces (hpr_aero::fins::tests): the polygon’s span moments against the trapezoid’s and the
ellipse’s integrals ([N09] eq. 3.70–3.71). Supersonic forcing and damping within 1e-7 of a 20,000-strip sum of the same load on the Arcas Robin’s swept fin, from Mach 1.5 to 4.63. The subsonic ones against Barrowman’s closed forms, and both continuous at Mach 0.8 and . against its integral (eq. 3-121) by Simpson’s rule within 1e-10.
Rigid-body flight
See the equations that fly a rocket from rail to ground as a rigid body, free to turn, that lightens as its motor burns.
In short
- What it models: a rocket’s flight from the pad to the ground, rail included. The rocket is a rigid body free to move and turn in every direction (six degrees of freedom). It gets lighter as its motor burns.
- Sources: the equations of motion in RocketPy’s technical documentation (RocketPy 1.13.0). The RocketPy paper (Ceotto et al., 2021) is cited but was not fetched.
- How well it is validated: by analytic and unit tests, against RocketPy, and on eight of NASA’s check cases. In a vacuum, a tumbling rocket’s center of mass stays on the exact parabola to 1.7e-6 m over 22 s. On six of the check cases, a free body on the same equations differs from the codes NASA published by more than they differ from each other. It ends 19.51 mm (0.77 in) lower after a 4.4 km (2.7 mi) fall, turns up to 0.01633 deg/s apart, and puts a dragged sphere up to 105.0 mm (4.1 in) away. A named difference between the models brings each inside the codes’ spread at each code’s largest difference. For one code in the sphere’s cases it does so without explaining the gap. Read at every sample, case 2’s tumbling brick’s rates are left just past the spread. Two shots from sea level come out inside it as flown. There the codes sit about 2 m (6.6 ft) apart (a free body against NASA’s check cases). Five of RocketPy’s example rockets were flown from the pad to the ground by both codes, with the same declared drag. They agree on height, speed, time and acceleration within 3%. The largest scored difference is +1.783%, a peak acceleration on the rail (validation report, whole flights against RocketPy). The path agrees as well, except the apogee drift of NDRT 2020 and of rockets that leave the rail slowly in a wind. In those, HPR Sim’s apogee drift is −4.333% to −38.158% from RocketPy’s (validation report). The causes are HPR Sim’s body lift, which RocketPy’s normal force leaves out, and its later release from the rail (ADR-026). For Juno III, another cause is HPR Sim’s simpler fin model. A sixth, Prometheus 2022, passes Mach 1 on its drag table and agrees as well. Its drifts again differ from RocketPy’s through body lift. With HPR Sim’s own drag, against RocketPy flying the drag its examples ship, HPR Sim’s heights differ from RocketPy’s by −7.280% to +10.302% (validation report). The gaps are larger where the two drags differ most. HPR Sim’s is well below the example’s for two rockets. For Prometheus 2022 it is above the example’s at high speed. That rocket has flown through Mach 1 on HPR Sim’s drag since the drag through Mach 1 was built (Accuracy). Twelve public flights have been compared with their altitude logs at the apogee, seven of them along the climb too. 60 more have been compared with their logs, on apogee alone (Accuracy: real flights).
- What it leaves out: staging and delayed ignition (both on Staging), turbulence and thrust misalignment. Tip-off (the pivot as the rocket leaves the rail) is left out unless a flight asks for it (Tip-off), and that phase is held to RocketPy’s on RocketPy’s normal force, and on HPR Sim’s own in still air only. RocketPy’s tip-off phase puts the pivot’s cost at up to 3.765% of the apogee in the landing point and 0.414% in the apogee, one code against another with no flight to check it (below). Its small-angle aerodynamics are used at every angle of attack (the angle between the rocket’s axis and its path through the air), with no stall. A flight that reaches Mach 5, the top of the aerodynamic models, stops with an error. The rotational equations leave out the Earth’s rate; on NASA’s tumbling brick that moves a body rate by up to 0.01633 deg/s within 30 s (#1521).
About the model
What the equations do
At each instant of a flight, HPR Sim adds up every force on the rocket and every turning effect (a moment). They come from the thrust, the weight, the air and the propellant burning away. From those it works out how fast the rocket speeds up and how fast its turning changes. The integrator (Time integration) then carries the rocket forward, one short step at a time.
Burning propellant makes the rocket lighter, moves its center of mass, and lets the exhaust carry away some of the rocket’s turning (jet damping). The equations keep all three. They are RocketPy’s, from its technical documentation ([RP-EOM], under Code and sources), and are written out under Equations of motion.
Code and sources
Code: hpr_sim::{dynamics, flight, free_body, histories, rail, recorder, state}. Decisions:
ADR-011 (equations of motion, aerodynamic coupling, rail, phases and termination) and
ADR-353 and ADR-356 (the differences from NASA’s check cases, traced), and
ADR-357 and ADR-358 (tip-off: its cost, the phase, and what is held). The integrator and
events are in Time integration, and the frames in Frames.
Sources:
-
[RP-EOM] RocketPy technical documentation, “Equations of Motion” v0 (Kane’s method with the Reynolds transport theorem) and v1 (the form solved). They are
docs/technical/equations_of_motion.rstandequations_of_motion_v1.rstin RocketPy 1.13.0 (refs/rocketpy, MIT). -
[C21] G. H. Ceotto, R. N. Schmitt, G. F. Alves, L. A. Pezente and B. S. Carmo, “RocketPy: Six Degree-of-Freedom Rocket Trajectory Simulator”, J. Aerosp. Eng. 34(6), 2021, doi:10.1061/(ASCE)AS.1943-5525.0001331. Cited, not fetched.
-
[N15] D. G. Murri, E. B. Jackson and R. O. Shelton, Check-Cases for Verification of 6-Degree-of-Freedom Flight Vehicle Simulations, NASA/TM-2015-218675, both volumes, 2015, with the errata of September 8, 2025, and the codes’ time histories posted with it (https://nescacademy.nasa.gov/flightsim/2015). Cases 1 to 3 and 6 to 10 are flown (below).
-
[RP-TIP] RocketPy’s tip-off phase,
Flight.udot_rail2, in its development branch (MIT; no release carries it). Its pull request #920 added the phase and #1217 rewrote it. By its description the rewrite simplifies the phase’s function, changes what RocketPy reports inside the phase, and corrects how the phase ends: it finds the moment each button leaves by a root search on the solver’s own interpolation of a step, and it corrects what happened when a parachute opened inside the phase or the rail was too short for it. It also took away the phase’s switch. HPR Sim’s tip-off phase takes its form from the first: the free equations plus the force and the moment the last guide adds. The comparisons below fly the rewrite.
The equations
State
- The state holds the nose tip ’s position and velocity in the launch frame . It also holds the attitude quaternion , four numbers that give the rocket’s orientation, turning body axes into ’s. Last come the body rates (how fast it turns about each body axis) relative to , in body axes: 13 components in all.
- The state follows the nose tip because it is fixed in the body and is the body origin (the design-tree decision). The center of mass (from , body axes) moves as propellant burns.
- The norm of the quaternion (its length, 1 for a pure rotation) drifts slightly between steps. Every use normalizes it, and it is never reset at an event (Time integration).
Equations of motion
[RP-EOM] v0 derives the motion of a variable-mass system (one whose mass changes as it flies) about a point fixed in the body. It uses two standard tools:
- Kane’s equations, a systematic way to write the equations of motion, for the rigid parts;
- the Reynolds transport theorem, which accounts for mass flowing across a boundary, for the propellant and the gas leaving the nozzle.
Its assumptions:
- the gas flow inside the motor is quasi-steady, changing slowly enough to treat as steady at each instant. So the integrals over the space it flows through, the control volume, don’t change;
- the flow is axisymmetric: the same all round the rocket’s axis;
- the exhaust momentum is lumped into the thrust at the nozzle exit.
v1 solves the result for and , the rates of change of the velocity and of the body rates. The lines below are that form, in body axes, with primes for time derivatives seen from the rocket. , , and are labels carried over from [RP-EOM] v1, so each line can be matched against it:
- comes from the momentum of mass moving inside the rocket: gas flowing to the nozzles, and the center of mass shifting as propellant burns. The rotation turns that momentum into a force, , as it does for anything moving inside a turning body (a Coriolis force).
- is the thrust with the propellant’s internal-momentum terms (Measured thrust curves and the internal-momentum terms, below).
- gathers every force: , the weight , the air force , and two terms from the rotation. They are and , the second because the center of mass is not at .
- gathers every moment about . They come from the rotation itself, from the jet and the changing inertia (), and from the weight, the air and the thrust. The last term of , , is for parts that move along the airframe. Here is their angular momentum about , relative to the airframe. The term is zero for a part on the axis, and zero when nothing moves (Moving mass).
- The last lines give the angular acceleration and the nose tip’s acceleration (and from it in ). Then comes the rate at which the attitude changes.
-
Mass terms:
- , and are the mass, its rate and each motor’s mass acceleration.
- and are the inertia about and about the center of mass ().
- is motor ’s nozzle exit.
-
Forces and moments:
- is the thrust along , the motors’
thrust_at_pressure_n, with moment about . - is the weight: normal gravity (centrifugal term included) plus the Coriolis force , both acting at the center of mass.
- and are the aerodynamic force and its moment about (below).
- is the thrust along , the motors’
-
The nozzle gyration tensor describes how the exhaust leaving motor ’s exit disc is spread about . Times the mass flow , it gives the jet damping in :
It is integrated here from v0’s boxed rotational equation. The jet term there is over the exit disc of radius , with a uniform jet. For a disc at on the axis, this gives
- RocketPy 1.13.0’s code (
rocket.py:984-985,evaluate_nozzle_gyration_tensor) uses for the transverse distance term instead of . Its is measured from the center of dry mass, not from the nose tip, so the entries can’t be compared directly. The RocketPy comparison below corrects that term to . - A motor that gives no nozzle exit radius contributes .
- RocketPy 1.13.0’s code (
-
For an axisymmetric rocket turning slowly about a transverse axis, the equations reduce exactly to the classical jet damping about the center of mass,
with from the center of mass to the nozzle exit. The part damps, and the falling inertia partly offsets it (
dynamics::tests::jet_damping_matches_the_classical_form). -
Time derivatives of the mass properties:
- , , and come from central differences of
Assembly::mass_propertieswith a half-width of 1e-4 s. - The stencil, the times each difference samples, is kept inside the current integration interval. Every thrust-curve knot and burnout is a stop time, so no difference straddles a change in the thrust’s slope. Near an interval’s end the derivative is taken at the nearest valid center and extended linearly.
- differences each motor’s mass flow the same way.
- After burnout (an interval starting past every burnout) the rates are zero. They are also zero over intervals shorter than 2e-5 s, where differences would be rounding noise.
- A part that moves along the airframe adds its own rates in closed form, not by differences (Moving mass).
- , , and come from central differences of
-
A motor that burns through an interval is evaluated at its one-sided limit inside the burn, clamped to . The last stage of the step ending at burnout (or the first after ignition) then sees the burning motor. It sees the pressure correction too, which switches off at . Without this, fixed-step RK4 converged at first order (5.1 mm (0.20 in) of apogee at 2 ms).
-
Measured thrust curves and the internal-momentum terms. A static test measures , where is the internal momentum of the burning propellant, so a
.engcurve already contains it. subtracts again.- HPR Sim keeps the terms as RocketPy does, for parity in the RocketPy comparison. The form is exact for the [RP-EOM] model, not for a measured curve.
- The size of the double count on Valetudo: it lifts off at 1.56 ms with 73 N of thrust against 95 N of weight. At liftoff 21 N comes from . The double count changes the burnout speed by at most 0.05 m/s (0.16 ft/s).
-
Earth’s rotation enters only through the Coriolis force. The rotational equations use relative to , which differs from the inertial rate by at most 7.3e-5 rad/s (Frames and the flight decision). On a tumbling body of three unequal moments the effect of leaving it out grows past that: NASA’s check cases 2 and 3 measure it.
Aerodynamics in flight
hpr-aero gives coefficients at a flow condition (Aerodynamics). The engine applies them as follows.
- The air velocity uses the wind at the center of mass’s height. Wind vectors are taken in ’s axes.
- The axial force is , from the whole rocket’s drag. It is taken at the center of mass’s
airspeed, Mach number, angle of attack and Reynolds number per meter (). The drag is power-on
(
DragConditions::thrusting, with the burning motors’ cross-section) while any motor burns in the interval.Simulation::with_full_base_drag_under_powerkeeps the whole base’s drag instead, as OpenRocket does, for comparisons with it (base drag under power). The force acts along the axis, so it has no moment about . - Normal and side forces are taken component by component. Each body and fin set is evaluated at
its own local flow: at the station the aerodynamics gives it
(
AeroModel::component_station_m). That station is the component’s small-angle center of pressure wherever one model carries the component. Faster than sound, where the shock-expansion method and slender-body theory share one, it is not. There the station is joined between the two models while the force joins their slopes and moments. The two agree only at the ends of the join. A body can sit between the models at every speed (a lip riding half in its boattail’s wake). There a tube’s station can sit two calibers from its own center of pressure (issue #106). That moves the lever arm the damping below uses by that much. The margins don’t use the station. The apogee and the drift may lean either way, so a flight inside the join warns of it (the flight-path warnings). A component’s acts along the crossing air and its along (Frames), with moments about from its moment coefficients. - At any angle of attack, a fin set’s normal force follows the crossflow . Its
model’s is used as , the substitution Niskanen keeps for bodies (eq.
3.16–3.17). No source in hand gives a large-angle fin model, and stall is not modeled.
- At small angles nothing changes (1.5% less at 0.3 rad).
- The force now vanishes for axial flow from the tail as well as from the nose.
- A force linear in stays large at and flips with rounding noise in the lateral
velocity. A calm vertical flight falling tail first after apogee then collapsed the step size
and never landed (
tests::a_calm_vertical_flight_falls_tail_first_and_lands).
- The rotation’s contribution to each local flow is the only aerodynamic pitch and
yaw damping. At a component’s station the rotation adds a velocity , which changes the
angle at which the air meets that component. The station is the lever arm. Where it is not the
center of pressure (above), the damping is levered from the wrong point by the same distance.
- Only components with a normal-force slope damp this way: nose cones, transitions and fin sets. A boattail’s slope is negative, so it takes some away.
- Body tubes give none at small angles: their own slope is 0, and their body lift grows with .
hpr-aerohas no pitch or yaw damping coefficients. They would have to replace the local-flow damping, not add to it.- A flight on another tool’s normal force keeps this damping. The table (The normal force from RASAero II) gives the normal force at the center of mass’s airflow. Each component adds only its force in its own local flow minus its force in the center of mass’s airflow: the part the rotation makes. Without rotation that part is exactly zero (ADR-032).
- The fins’ cant drives the roll and the roll rate damps it. The moment about is
, at the center of mass’s Mach number. Here is the dynamic pressure, and the
reference area and diameter, the cant’s rolling moment, the damping and
. The cant’s forcing follows the axial flow,
, so it vanishes broadside and reverses tail first
(
AeroModel::roll, Roll: forcing and damping). The damping is written , so it fades smoothly as the airspeed does. The roll rate also changes through inertia coupling (turning about one axis driving turning about another) when a rocket’s mass isn’t symmetric about its axis. While a motor burns, it also changes through the jet and the falling inertia in . At constant speed a canted rocket spins up to the steady rate where cant and damping balance, as the closed form gives (tests::canted_fins_spin_to_the_analytic_balance). - Limits:
- The models are small-angle: no stall, and body lift and fins extended by . They
overstate the forces at large . In normal flights large occurs near apogee, where the
dynamic pressure is small, and off the rail in strong crosswinds.
Sample::angle_of_attack_radshows where it happens. - The normal force and the drag buildup cover Mach 0 to 5
(Fins through Mach 1,
Drag through Mach 1, the drag’s decision). A fin
set’s CP moves with the Mach number. Each component takes its local airflow at its CP for the
center of mass’s Mach number. At Mach 5 or faster they refuse the
flow, and the flight stops with
SimError::Aero. A drag override table covers drag at any Mach, but the normal force still stops at Mach 5.
- The models are small-angle: no stall, and body lift and fins extended by . They
overstate the forces at large . In normal flights large occurs near apogee, where the
dynamic pressure is small, and off the rail in strong crosswinds.
Running a flight
Phases
-
Pad.
- The rocket starts at rest with the rail’s attitude. Its aft end is at the rail’s foot: the aft-most point it stands on, of its body, of any part on its outside or of its nozzle exits. A swept fin whose tip’s trailing edge reaches past the tube counts there, as do a tube fin’s and a pod’s aft ends. So the rail’s length runs from that point to the rail’s top, and a standoff under the rocket shortens it.
- It stays until the force along the rail, with , exceeds friction (the liftoff event). is the rail’s reaction: the weight, the aerodynamic force and the mass terms across the axis.
-
Rail. One degree of freedom, along the rail, with no rotation:
- It ends when the aft edge of the aft-most rail button or launch lug passes the top of the rail. In a flight that asks for tip-off it ends sooner, when the guide next ahead of that one does. With no guides, it ends when the aft end does.
- If the speed along the rail falls to zero, the rocket returns to the pad phase, at rest where it stopped. It is held there, even if the force down the rail exceeds friction and a real rocket would slide back.
-
Tip-off. Only when the flight asks for it: between the rail and free flight, the rocket slides on its last guide alone and pivots about it (Tip-off).
-
Free. Six degrees of freedom until the ground.
-
Rail geometry.
- A button’s axial extent is its outer diameter, and a lug’s is its length.
- The rocket leaves after traveling . RocketPy ends its rail phase when
the forward button reaches the top (
flight.py:1716-1730,effective_1rl). HPR Sim keeps the rocket guided to the last guide (Loft lesson L26). - The pivot about the last guide (“tip-off”) is left out unless the flight asks for it (Tip-off). Without it the rocket leaves the rail with no angular velocity. On thirteen example designs, RocketPy’s tip-off phase moves the landing point by up to 3.765% of the apogee and the apogee by up to 0.414%, one code against another (what leaving tip-off out costs).
- Friction is Coulomb friction: a user coefficient times the net reaction , the force pressing the guides onto the rail. With a moment across two buttons (a crosswind at low speed), the true friction is larger. No source gives a default coefficient, so the default is zero.
Tip-off
A flight that asks for it flies one more phase between the rail and free flight. That phase is
tip-off, the turn a rocket picks up on its last guide alone. A guide is a rail button or a
launch lug, and the last one is the aft-most. Ask for the phase with
Simulation::with_tip_off in the Rust library. The command line and the Python package don’t
offer it yet. It is off by default, so every flight on this
site and in the reports flies without it unless it says otherwise.
What it does. Once the guide ahead of the last one leaves the top of the rail, the last guide holds the rocket alone. The rocket keeps sliding up the rail on it, free to pitch and yaw about it, with roll held. Gravity turns the nose down, and a crosswind turns it downwind when the air’s force acts ahead of the guide. When the last guide’s aft edge passes the top, the rocket is free, with the turning rate it has picked up.
The equation. The free equations give the acceleration of the nose tip and the angular acceleration the rocket would have with nothing holding it. The guide adds a force on the pivot, square to the rail, and a moment about the long axis . Write for the pivot’s position from the center of mass and for the center of mass’s from the nose tip. is the inertia about the center of mass. The two change the motion by
Three conditions fix the three unknowns, the two parts of across the rail and . The pivot’s acceleration has no part across the rail, in either direction, and the angular acceleration has none about the long axis. With no friction the three equations are linear, and friction is solved with them (below). Source: [RP-TIP], written for this page’s equations about the nose tip.
- The pivot is on the rocket’s axis, at the middle of the aft-most guide.
- Friction is the rail’s, on that force: on the pivot along the rail, against the sliding. It is solved with the force, since it turns the rocket a little. RocketPy’s rail has none.
- The phase starts when the aft edge of the guide next ahead of the last one passes the top of the rail. It ends when the last guide’s does. A rocket with one guide, or none, has no such stretch and flies as before. A rail too short to hold both guides pivots the rocket from liftoff.
- A rocket that stops on its last guide returns to the pad phase, at rest, as on the rail.
- Flying the phase by default is a later increment.
For a burnt-out rocket in no air the three conditions reduce to a pendulum hung from the guide. Write for the distance along the axis from the last guide to the center of mass. is the inertia about the center of mass for a turn in the rail’s vertical plane, and is the rail’s angle above the horizontal. The nose turns down at
A test holds the phase to that within 1e-9 of its size on four rails, 5° to 60° off the vertical.
A worked example. Take a 20 kg (44 lb) rocket on a rail 5° off the vertical, so . Its center of mass is 0.80 m (2.6 ft) ahead of its last guide. Its inertia about the center of mass is 9.0 kg m².
That is 35.9 deg/s². If the last guide holds the rocket alone for 0.07 s, about what Juno III’s does, it leaves turning nose-down at about 2.5 deg/s. Juno III, a real example, is under the tip-off phase against RocketPy’s.
What it leaves out. A real button sits a body radius off the axis and has play in its slot, and a lug slides on a rod. Here the pivot is a pin on the axis that lets nothing through across the rail. The rail does not flex or whip. The rocket cannot slide back down, as on the rail. No real flight checks any of it.
Events and termination
-
Thrust-curve knots, burnouts and the time cap are stop times. A burnout that is reached records a
Burnoutevent. -
Liftoff is the pad force margin rising through zero. It is checked also at each interval’s start, for a thrust that jumps at a knot. Stall is the speed along the rail falling through zero.
-
Rail exit is the travel along the rail reaching the exit travel.
-
Apogee is the center of mass’s ellipsoidal-height rate, , falling through zero. is the ellipsoid normal at its position. A flight that has let a part go records one apogee (Released mass).
-
Ground hit is the center of mass’s ellipsoidal height reaching the launch site’s, descending (Frames, Loft lesson L35).
-
A user event is a function of the
Sample, in free flight. -
A mass shift (
Shift) is a part starting to move along the airframe, and a release (MassRelease) a part leaving it. Each comes on its trigger (Moving mass, Released mass). -
Atmosphere and wind heights are , the height above sea level. is the ellipsoidal height. The geoid undulation , the height of sea level above the ellipsoid, is given in
Environment(no geoid model). -
The flight ends in exactly one of these ways (Loft lesson L25):
GroundHit;NoLiftoff(the last burnout passes on the pad);StalledOnRail(it lifted off, then stopped on the rail after burnout);TimeCap;StepLimit.
Any other failure is an error.
-
Turbulence and thrust misalignment are not modeled in a flight. Recovery is modeled, and has its own page. So are motors lit at their own times and a powered separation, on Staging.
Integration settings
-
FlightSettings::default()uses Dormand-Prince 5(4) withrtol = atol = 1e-8and unit weights, a one-hour cap and 10⁶ steps. -
Accuracy against cost was measured on Valetudo (K400C) in a 5 m/s (16 ft/s) wind from the west. Each apogee is compared with the one at 1e-11 (873.98272 m (2,867.3974 ft)):
tolerance, rtol = atol(ratio; state units)apogee error run time (release build) 1e-4 2.3e-2 m 0.36 ms 1e-6 6.8e-5 m 0.59 ms 1e-8 1.1e-6 m 1.13 ms 1e-10 1e-7 m 2.72 ms
Thrust and mass from another program
A flight can take its thrust, and its mass with its center of mass, from another program, as
numbers against time, in place of its own (Simulation::with_thrust_history and
Simulation::with_mass_history, since M2.3c11). It is
for one job: splitting the gap between HPR Sim’s apogee and OpenRocket’s by cause, one input
swapped at a time, as a drag table swaps the drag (ADR-349).
The split is in
Accuracy: drag is the largest part on
61 of the 68 flights both programs fly. It is not a model, and a flight on
it is not a prediction. It is in the Rust library only, for the validation harness: no hpr
command, Python call or file option takes a history.
-
Between samples. A history is a list of samples. Between two of them, and , it is the straight line
Before the first sample and after the last it holds that sample’s value. So its rate is the slope of the piece it is on, finite, with a jump at each corner, and its second derivative is zero inside a piece. Every sample where the slope changes is a stop time, where an integration step must end (time integration), so no step straddles a corner.
-
Thrust. The history’s value is the thrust as flown, along the axis . It takes the place of the motors’ thrusts with their correction for the air’s pressure, which isn’t applied to it again. It acts at the mean of the lit motors’ nozzle exits, so a symmetric cluster’s thrust turns the rocket no more than HPR Sim’s own does. An asymmetric cluster’s turning moment is left out.
-
What stays HPR Sim’s under a thrust history. The motors still set the burnout event and the base area a burning motor frees (base drag). They also set the mass flow behind jet damping and the nozzle terms and of the equations above. So those terms’ push, 21 N at Valetudo’s liftoff (internal momentum), stays on top of the history’s thrust.
-
Mass. The history gives the whole rocket’s mass and its center of mass , in meters aft of the nose tip, the body origin . In body axes the center of mass is , with HPR Sim’s own small offsets off the axis. Then and are the history’s slopes and .
-
What stays HPR Sim’s under a mass history. The inertia about the center of mass . The inertia about comes from it by the parallel-axis theorem with the history’s mass and center, , with the identity matrix, so the inertia’s difference from OpenRocket’s lands in the split’s remainder. The motors’ mass flow stays theirs in the nozzle terms, as under a thrust history. Where the history’s mass still falls after the motors burn out, its is in the turning terms with no nozzle flow to match, so jet damping is not the classical form there. That too lands in the remainder. A structure-mass scale changes only the inertia under a mass history, since the history gives the mass.
-
Time. A history’s clock is the flight’s: 0 at launch. OpenRocket’s clock starts at the same instant: its launch and ignition events are both at 0 s.
-
What is refused, with the reason. An empty sample list, lists of different lengths, times that don’t rise, a number that isn’t finite, a negative thrust, a mass that isn’t positive, or a first sample after launch. A thrust that doesn’t end at zero, since it would stop while the motor still pushed. A thrust history on a flight with no motor lit at a known time. Either history on a flight that splits, by a separation or an ejection, or that moves or releases a part: a history is the whole stack’s, with no part’s own.
Verification
Unit tests in hpr_sim::tests, hpr_sim::dynamics::tests and hpr_sim::rail::tests, at the
default settings. The numbers were measured on September 17, 2026.
-
A tumbling, spinning Valetudo in a vacuum starts from the nose tip at 500 m (1,640 ft) with m/s.
- The center of mass stays on the closed-form parabola to 1.7e-6 m over 22 s.
- The angular momentum stays constant to 7.8e-7 (relative).
- Apogee and ground contact are within 4.7e-7 s and 1.1e-8 s of the parabola’s. Those times are located (root-found) on the exact ellipsoidal height.
-
Falling nose down through uniform air with , the speed follows to 5.5e-9 . It is the terminal velocity to 1e-5 after 150 s.
-
Torque-free precession is the wobble of a spinning body with no torque on it. Valetudo ( = 0.0019) spinning at 25 rad/s with a transverse rate turns in body axes at = −24.95 rad/s. The rate matches to 4.7e-7 rad/s over 3 s, and the angular momentum in holds to 1.5e-6.
-
The pitch oscillation is checked against linear theory at 100 m/s (328 ft/s), with no drag or gravity. The two-state linear model (path turning, restoring moment , rotational damping ) predicts a 1.44954 s period. The flight measures 1.44965 s (8e-5), and the decay per half period is within 0.2% of the model’s.
-
The flight equations give the classical jet damping to 1e-6. The mass rate equals the motor’s to 1e-6, including stencils clipped by an interval’s end.
-
A powered vertical climb in vacuum runs from 0.5 s to 3.0 s. It ends at the speed of the axial equation, integrated independently from the motor and the assembly, to 4.3e-8 m/s.
-
On a rail at 60°, friction with removes exactly from the acceleration along the rail.
-
Valetudo weathercocks (Loft lesson L20). In a 5 m/s (16 ft/s) wind from the west, its unit axis has an east component of −0.12 at burnout. Its apogee is 96 m (315 ft) upwind, against 1.0 m (3.3 ft, Earth rotation) in calm air.
-
In a calm vertical flight with no Earth rotation, the rocket falls tail first after apogee and still lands, in under 20,000 evaluations.
-
RK4 at 2, 1 and 0.5 ms gives the same apogee as Dormand-Prince to 1.2e-5 m and 2.1e-7 s.
-
A user event on the thrust fires at burnout, and burnout is still recorded once.
-
A 2,000 m (6,562 ft) rail gives
StalledOnRail, with only liftoff and burnout recorded. -
Observer errors end the flight with that error. Starts before ignition or underground are refused. A cleared recorder records the same rows again.
Simulation,EnvironmentandRecorderareSend + Sync. -
Two runs of one
Simulationrecord the same bits for every channel at every step (Loft lesson L24). So does a secondSimulationbuilt the same way. -
A normal flight hits the ground (Loft lesson L25). A rail with at 60° gives
NoLiftoffat rest. A 5 s cap givesTimeCapat exactly 5 s, and a 40-step limit givesStepLimit. -
A 3 m (9.8 ft) rail is tilted to 1.3 rad (Loft lesson L26). The rail exit comes at the last button’s travel to 1e-6 m. Across the rail the rocket stays within 1e-9 m, with no rotation. Friction () delays the exit and slows it.
-
From a 1 m (3.3 ft) rod tilted 5 to 20 degrees, HPR Sim’s rocket is on OpenRocket’s bearing at apogee to within 0.03 degrees. It loses the same apogee to within 0.27 percentage points (
.ork: a tilted launch rod). -
Events come in order: liftoff, rail exit, burnout, apogee, ground hit. Apogee’s vertical speed is below 1e-6 m/s and ground contact’s height below 1e-6 m. Recorder rows fall on the interval or at events.
-
The synthetic 54 mm (2.1 in) rocket on an I175 passes Mach 1 and lands. It does both on HPR Sim’s own drag and on a constant drag table.
-
A Valetudo flight to the ground costs about 1.3 ms, measured on October 9, 2026 (
docs/perf.md). -
Thrust and mass histories (
histories_fly_the_closed_form_of_a_varying_mass_under_constant_thrust). In a vacuum, with gravity of 9.80665 m/s² (32.174 ft/s²), long after its own motor’s burnout, Valetudo rises straight up at a speed of 50 m/s (164 ft/s) on a thrust history of 300 N. Its mass history, not Valetudo’s own mass, starts at , 10 kg, and falls at , 1.5 kg/s, so . Its center of mass moves aft at 0.05 m/s (0.16 ft/s), so is −0.05 m/s (−0.16 ft/s) along , which points to the nose. After a time , the nose tip rises atwhich reaches 101.686 m/s (333.62 ft/s) after 2 s. The flight follows it to 1e-7 m/s. The term is the axial part of the equations’ . Without it the speed would be 0.036 m/s (0.12 ft/s) higher. Each history alone follows its own closed form to 1e-7 m/s too: the thrust on the design’s burnt-out mass, 8.26 kg, gains , 53.0 m/s (174 ft/s) in 2 s, and the mass alone the closed form above with . With a corner 1 s in, where the mass flow halves and the center’s rate drops to 0.02 m/s (0.066 ft/s), a step ends at the corner and each piece follows its own closed form to 1e-7 m/s.
-
Under a mass history, the inertia about the nose tip and its rate are the parallel-axis formula and its derivative, with the history’s mass and center and the design’s own inertia about its center of mass, to 1e-12 and 1e-6 of their sizes (
a_mass_history_moves_the_assembly_s_inertia_by_the_parallel_axis_theorem). -
A mass history read back at 1 s gives the history’s mass and center along the axis, with the design’s offsets off the axis and inertia. A separation, before or after a history, refuses it with the reason, and so do a mass shift and a mass release.
-
The own-history test (
cargo test -p xtask histories). Two public designs are flown, sampled at the times of OpenRocket 24.12’s own flight of each (validation/fixtures/ork/openrocket-histories.json), and flown again on those samples. Both are a 60 mm (2.4 in) airframe with a conical nose and three fins:pods-noneon an AeroTech H128W, the control of a tilted launch rod, andmach-probeon a J570W, made for this test. Onpods-none, a 251-sample flight to Mach 0.76, the apogee goes from 782.7197 m (2,567.978 ft) to 782.7214 m (2,567.984 ft), +0.00022%. Onmach-probe, a 567-sample flight to Mach 1.73, it goes from 2,030.4623 m (6,661.622 ft) to 2,030.4496 m (6,661.580 ft), −0.00063%. The bound is 0.05%, about a thirty-fifth of the 1.73% mean absolute gap between the two programs’ apogees on 60 real flights (accuracy). On the same flights, 5% more thrust raises the apogee by 2.8% and 3.0%, and 20% more mass delays the rail exit by 7.9% and 7.2%: both histories are flown.
A free body against NASA’s check cases
NASA’s Engineering and Safety Center published check cases for flight simulations that move a body in all six degrees of freedom [N15]. Each case is a simple body flown from a stated start. Six codes flew the cases in the air, labeled SIM 1 to SIM 6 without their names: five of NASA’s own and JSBSim, an open-source simulator. Five or six posted a time history for each case, beside the report. The report names no code as right: the codes’ agreement with each other is the measure.
HPR Sim flies eight of the cases with a free body, hpr_sim::FreeBody: a mass and an inertia,
with no design, no motor and no aerodynamics. It is not a second model. Its gravity and
Coriolis force come from the flight’s Earth model, its air and wind from the flight’s
environment at the height a rocket’s flight reads them, its accelerations from the equations
above, and its steps from the integrator at the default tolerances. A case’s damping or drag
is a load the test adds. At every step it forms a force and a moment from the state, the air
and the velocity through the air. A test
(the_derivative_is_a_coasting_rockets) evaluates a coasting rocket by the equations a flight
integrates, and the free body of that rocket’s mass and inertia at the same state: the two
agree to rounding.
- Case 1, the dragless sphere. A sphere of 1 slug (14.59 kg) is dropped from 30,000 ft (9,144 m) over 0° N, 0° E, at rest relative to the Earth, and falls for 30 s with no drag. Its altitude is compared.
- Case 2, the tumbling brick. A brick with three unequal moments of inertia starts at the same place, turning at 10, 20 and 30 deg/s about its three axes relative to the stars, with no aerodynamics. Its three body rates relative to the stars (inertial rates) are compared over 30 s.
- Case 3, the tumbling brick with damping. Case 2 with a damping moment about each axis. The report gives three coefficients of −1, a reference area, a span and a chord, but no formula. The test takes the usual one: about each axis , which is the dynamic pressure times times the rate made dimensionless, . Here is the speed through the air, the rate relative to the stars about that axis, and the span for roll and yaw and the chord for pitch. The codes split on the rate. SIM 4 damps the one relative to the stars, and SIM 1 comes nearer it than the other. SIM 5 and SIM 6 damp the one relative to the Earth. SIM 2 fits neither. The test takes the first. The inertial rates are compared.
- Cases 6 to 10, the sphere with drag. Case 1’s sphere with a drag coefficient of 0.1, acting along its velocity through the air whichever way it points. It is dropped from 30,000 ft in still air (case 6), in a steady 20 ft/s (6.1 m/s) wind from the west (7), and in a wind from the west that grows by 3 ft/s every 1,000 ft of height, 70 ft/s (21 m/s) at the start (8). In cases 9 and 10 it is shot from sea level at 1,000 ft/s (305 m/s) up and 1,000 ft/s east or north. Its position is compared: the distance between HPR Sim’s and the code’s. Each code’s position is read from the latitude, longitude and altitude in its file, since two of the codes write no Earth-fixed position.
How to read the table. A difference is HPR Sim’s value less a code’s, the largest over the 30 s; for a position, the distance. The spread is the largest difference between any two codes. One code is left out when leaving it out cuts the spread by more than half. As the report numbers the codes, that is SIM 1 in cases 1 and 3, SIM 6 in case 2, SIM 3 in cases 6 to 8 and SIM 2 in case 10. The model difference is a named difference between HPR Sim’s model and the codes’, worked out apart from the flight. The last column is what that leaves of the largest difference from any kept code.
| Quantity | Codes kept | The codes’ spread | HPR Sim’s largest difference from a kept code (size) | Model difference | Most left after the model difference |
|---|---|---|---|---|---|
| Case 1, altitude | 5 of 6 | 0.1424 mm (0.0056 in) | 19.51 mm (0.77 in) | −19.50 mm (−0.77 in) | 0.1364 mm (0.0054 in) |
| Case 2, inertial roll rate | 4 of 5 | 0.0008991 deg/s | 0.01077 deg/s | +0.01077 deg/s | 0.0008818 deg/s |
| Case 2, inertial pitch rate | 4 of 5 | 0.001242 deg/s | 0.01633 deg/s | −0.01633 deg/s | 0.001005 deg/s |
| Case 2, inertial yaw rate | 4 of 5 | 0.0003532 deg/s | 0.005500 deg/s | +0.005500 deg/s | 0.0001268 deg/s |
| Case 3, inertial roll rate | 4 of 5 | 0.003609 deg/s | 0.004873 deg/s | −0.003755 deg/s | 0.003176 deg/s |
| Case 3, inertial pitch rate | 4 of 5 | 0.003792 deg/s | 0.005633 deg/s | −0.005609 deg/s | 0.001123 deg/s |
| Case 3, inertial yaw rate | 4 of 5 | 0.003503 deg/s | 0.005102 deg/s | +0.004433 deg/s | 0.0007793 deg/s |
| Case 6, position | 5 of 6 | 85.03 mm (3.3 in) | 102.6 mm (4.0 in) | 180.2 mm (7.1 in) | 77.57 mm (3.1 in) |
| Case 7, position | 5 of 6 | 85.24 mm (3.4 in) | 102.8 mm (4.0 in) | 180.4 mm (7.1 in) | 77.63 mm (3.1 in) |
| Case 8, position | 5 of 6 | 87.74 mm (3.5 in) | 105.0 mm (4.1 in) | 182.3 mm (7.2 in) | 77.68 mm (3.1 in) |
| Case 9, position | 6 of 6 | 1,989 mm (78 in) | 1,980 mm (78 in) | 1,253 mm (49 in) | 1,991 mm (78 in) |
| Case 10, position | 5 of 6 | 1,986 mm (78 in) | 1,977 mm (78 in) | 1,251 mm (49 in) | 1,988 mm (78 in) |
For a position the model difference is a distance, and it differs from code to code; the table gives the largest. Distances don’t subtract, so the last column need not be the difference of the two before it.
Cases 1 to 3 and 6 to 8 come out past the codes’ spread. Each is traced. A named difference between the models, computed apart from the flight, is taken off at each code’s largest difference. What is left is inside the spread (the decisions that trace them, and the later cases, the report). In cases 1 to 3 the difference explains the gap; in cases 6 to 8 it does not explain SIM 1’s, below. A stricter reading, below, leaves case 2 just past the spread. Cases 9 and 10 come out inside it as flown.
- Case 1 is the gravity model. HPR Sim’s sphere ends 19.51 mm (0.77 in) lower after a fall of 4.4 km
(2.7 mi). It falls in WGS 84’s normal gravity
(Gravity), which holds every term of the model Earth’s field. The codes fall
in a field cut off after its second term, , the one for the Earth’s bulge at the equator.
On the equator the next term, , pulls harder by about 4.4 parts in a million of the
attraction, 4.34e-5 m/s². Held for 30 s, that acceleration moves a body 19.5 mm (0.77 in),
which a test of the tool works by hand (
the_gravity_gap_is_j4s_over_the_fall). The tool integrates the exact gap along the fall and gets 19.50 mm (0.77 in). - Case 2 is the Earth’s rate. The codes turn the brick by Euler’s equations in its rate relative to the stars. HPR Sim’s rotational equations use the rate relative to the launch frame, which turns with the Earth, and add the Earth’s rate back only when an inertial rate is read out. The rates the two sets of equations turn start one Earth’s rate apart, 0.0042 deg/s, and the inertial rates read out start the same. On a tumbling body of three unequal moments the inertial rates then drift apart, by up to 0.01633 deg/s in pitch within the 30 s, 3.9 times the Earth’s rate. Integrating both sets of equations apart from the flight gives the differences in the table. What the missing term costs a rocket’s flight is not measured: that, and whether to carry the Earth’s rate in the rotational equations, is #1521.
- Case 3 is the Earth’s rate again. The same two sets of equations are damped alike, on the rate relative to the stars, along the same fall. They leave at most 0.003176, 0.001123 and 0.0007793 deg/s, each inside the spread. Read at every sample, roll and yaw stay inside. Pitch comes to the spread itself, 0.003791 against 0.003792 deg/s. Against SIM 4, which damps as the test does, at most 0.0002691 deg/s is left. Read at every sample, the most is left in roll and pitch against SIM 5 and SIM 6. Those damp the rate relative to the Earth. In yaw the most is left against SIM 2.
- Cases 6 to 8 are the gravity and the codes’ own air. HPR Sim’s sphere ends within 21 mm (0.8 in) of three codes and 102.6 to 105.0 mm (4.0 to 4.1 in) from SIM 1. The codes don’t fly the same air. Set against HPR Sim’s 1976 standard atmosphere, SIM 4’s density is within 4.1e-7 of it. SIM 1’s is up to 1.35e-3 denser: more drag, so its sphere falls less. The model difference flies a point mass twice. Once it falls in the codes’ gravity through the code’s own density, read from its file; once in HPR Sim’s gravity and atmosphere. Less that, HPR Sim sits 0.004812 to 0.01569 mm (0.00019 to 0.00062 in) from the nearest code. It sits 77.57 to 77.68 mm (3.05 to 3.06 in) from SIM 1, inside the spread. SIM 1 is brought inside, not explained. Its own air, flown, would put its sphere 180.2 mm (7.1 in) above HPR Sim’s; its file is 102.6 mm (4.0 in) above. With the gravity alone, cases 6 and 7 were left 0.01 mm (0.0004 in) past the spread, so the air is part of the trace (the decision).
- Cases 9 and 10 are inside the spread, as flown. Shot kilometers downrange, HPR Sim ends 1,980 and 1,977 mm (78 in) from the farthest kept code, SIM 3. That is inside spreads of 1,989 and 1,986 mm (78 in): the codes themselves sit about 2 m (6.6 ft) apart. HPR Sim ends 15.60 mm (0.61 in) from SIM 4 and 13.68 mm (0.54 in) from SIM 5 in both. Less the same model difference it sits 0.03830 mm (0.0015 in) and 0.04217 mm (0.0017 in) from SIM 5. But it sits 1,991 and 1,988 mm (78 in) from SIM 3, just past the spread, so no cause is claimed for these cases. Here the launch frame’s flat axes carry the body far from the pad. So the cases hold the conversion that gives apogee and landing points, to the codes’ own agreement (the report).
A stricter reading. The last column takes the model difference at the moment of each code’s largest difference. Taken at every sample of the 30 s instead, what is left is 0.1369 mm (0.0054 in) in case 1, inside the spread, and 0.0008993, 0.001242 and 0.0003533 deg/s in case 2: over the spread by 0.0000001701, 0.00000007201 and 0.00000007634 deg/s. In case 2 the spread is set by one kept code, SIM 2, against two that agree with each other, so a flight that sat exactly on those two would differ from SIM 2 by the spread and no less. HPR Sim, less the model difference, sits 0.0000005866, 0.0000009229 and 0.0000002790 deg/s from the code nearest it. That distance is the integrator’s step error at the default tolerances: at tolerances of 1e-12 it falls to 0.000000002126, 0.000000003051 and 0.000000001089 deg/s. By this reading case 2 is not inside the spread: the excess is small, named and left open. The report’s “traced” is the first reading’s.
What the comparison does not see.
- The Coriolis force’s sign, in case 1. The force carries the falling sphere east, and that eastward speed is in turn pushed up, so the fall ends higher whichever way the Earth is taken to turn. Case 1’s altitude holds the size of the term, 7.0 mm (0.28 in) of the fall, which a test pins on the free body against its closed form. It does not hold the sign. Cases 6 to 10 compare whole positions, the eastward drift with them, so they do.
- What SIM 1 does in cases 6 to 8. 77.6 mm (3.1 in) of its difference is not accounted for, only inside the spread. SIM 3, left out there, is about 171 mm (6.7 in) off.
- The attitude. The codes’ files also hold the body’s Euler angles, which are not compared (#759). An error in the attitude reaches the inertial rates only through the Earth’s rate turned into the body.
- An error the kept codes share. The codes are the reference, so it would pass unseen.
The codes’ files carry no stated terms, so they are not committed: cargo xtask check-cases
reads them from an archive that cargo xtask refs fetch downloads and checks, and the
committed report holds only differences and spreads.
Whole flights against RocketPy
cargo xtask validate flies six of RocketPy’s example rockets from the pad to the ground. It
compares fifteen numbers of each with RocketPy 1.13.0’s own flight
(ADR-021, the whole-flight comparison). Both codes fly one declared drag coefficient,
a constant of 0.5 on the same reference area. So what is compared is the equations of
motion, the motor and the air, not the drag. The rest is RocketPy’s where HPR Sim has it: its gravity
formula, standard atmosphere and frictionless rail. So are the example’s rail angles, parachutes
and motor, and a declared wind.
| result | value |
|---|---|
| cases scored | 6, one of them (Prometheus 2022) past Mach 1, since M1.8a |
| height, speed, time, acceleration | all scored, all within 3% of RocketPy’s |
| largest of those | +1.783%, Bella Lui’s peak acceleration, on the rail |
| largest in apogee | +1.208%, Prometheus 2022; RocketPy flown with HPR Sim’s body lift and rail release comes within 0.01% (case file) |
| path without wind (drift of apogee and landing) | all scored, within 1.9% (largest −1.811%, Valetudo’s landing, in still air) |
| path in wind | Calisto’s scored (largest +1.257%), and NDRT 2020’s landing; Juno III’s, Bella Lui’s and Prometheus 2022’s, and NDRT 2020’s apogee drift, differ by 4.3 to 38% and are reported, not scored: HPR Sim’s body lift and rail release, and Juno III’s fin slope (ADR-026) |
What the two codes still do differently, and how much it moves:
- The wind. A rocket that leaves the rail slowly in a wind meets the air at a steep angle. Juno III, at 18 m/s (59 ft/s) in an 8.5 m/s (28 ft/s) wind, is 26° off the airflow. There HPR Sim’s normal force includes body lift (Aerodynamics), which RocketPy’s leaves out. Much of it acts ahead of the center of mass, the nose’s above all. So it moves the center of pressure forward and weakens the turn into the wind. HPR Sim turns into it less: Juno III’s apogee is 245.3 m (805 ft) from the pad, against 396.6 m (1,301 ft) in RocketPy. HPR Sim cannot model the airfoil lift curve Juno III’s example gives its fins, so it flies a flat-plate fin slope. Given HPR Sim’s body lift, its rail release and that fin slope, RocketPy puts Juno III’s apogee 248.3 m (815 ft) out. Every windy drift then comes within 1.3% of HPR Sim’s (ADR-026). HPR Sim’s growth of drag with the angle of attack moves no drift by more than 0.1%.
- RocketPy’s equations, corrected. HPR Sim’s equations of motion follow RocketPy’s technical documentation, which measures the center of mass from the center of dry mass. RocketPy 1.13.0’s code reads that vector the other way round. So during the burn it takes the turning moments about the wrong point, and its rockets turn into the wind too far. The fix is a pull request to RocketPy, merged on November 16, 2026. It is built on an earlier one, merged too. No release carries either yet. RocketPy 1.13.0 as installed still has the error, and the comparison applies both fixes. Without them, HPR Sim’s drifts in wind were up to −60.8% short of RocketPy’s at apogee and +151% beyond it at landing (ADR-026, issue #50).
- The rail. HPR Sim’s rail equation keeps the terms for the center of mass moving inside the
body as the propellant burns. RocketPy’s rail equation (
udot_rail1) leaves them out. At a sharp ignition spike, with thrust and mass the same to five digits, HPR Sim’s acceleration is 1.2 to 1.3 m/s² higher. HPR Sim also guides the rocket until its last rail button leaves, where RocketPy frees it at the first. - Calisto’s two peaks. Its acceleration peaks twice, 0.9% apart, and the rail terms make HPR Sim’s maximum the other peak. So the time of the peak (−96.8%) is reported but not scored.
- The parachutes. RocketPy counts the air a canopy drags along (added mass). HPR Sim has none. So the peak deceleration as NDRT 2020’s main opens is 83% higher in HPR Sim, and that number is reported but not scored. The speeds at landing agree within 0.03%.
The metrics are measured as RocketPy defines them. Speeds and accelerations are at the center of
dry mass. Heights are from that point’s height at launch, since RocketPy’s starts at the ground.
The rail exit comes when the rocket has traveled RocketPy’s effective_1rl, the forward button at
the top of the rail. HPR Sim’s own rail-exit event waits for the last one. Each case file argues
its tolerances. Accuracy gives every result.
What leaving tip-off out costs
HPR Sim flies without tip-off unless a flight asks for it (Tip-off). RocketPy’s tip-off phase puts the cost at up to 3.765% of the apogee in the landing point and 0.414% in the apogee. RocketPy flew thirteen example designs. Both are measured from a rocket held straight to its last guide, as HPR Sim holds it. The landing point moves farther from the pad in most flights, and the largest apogee move is down. That is one code against another: the phase is in RocketPy’s development branch, in no release, and no flight checks it. The landing point’s cost is past the plan’s bar of 1% of the apogee, so HPR Sim gained a model of the pivot. It is held to RocketPy’s on RocketPy’s normal force and in still air, not yet in a crosswind on HPR Sim’s own (below).
Tip-off is the turn a rocket picks up between its guides leaving the rail. Once the forward guide is off, the last one holds the rocket alone, and gravity and the wind turn it about that guide. By default HPR Sim keeps the rocket straight until the last guide leaves, then frees it with no turning rate.
cargo xtask tip-off flies the comparison and writes the report
(the decision record):
- What flies. RocketPy, at the merge of its
pull request #1217 (
65b9838f), flies the thirteen public designs built from its examples and tests, on its own inputs. They are twelve rockets; Calisto comes twice, from RocketPy’s getting-started notebook and from its tests. A Calisto id in the report ends in the motor’s position in meters, in the rocket’s own coordinates as its source sets it. Each source measures from its own zero point, and the two zero points are 0.118 m (4.6 in) apart. So in both the nozzle sits 2.533 m (8.31 ft) behind the nose’s tip. The fins differ, and the notebook’s rail buttons and its center of mass without the motor sit 0.118 m (4.6 in) farther back. Each design flies from its example’s rail on a constant drag coefficient of 0.5. It flies in still air and in a 20 mph (8.94 m/s) wind square across the rail’s heading. - Three ways. With the phase off, RocketPy frees the rocket where its forward button leaves the rail. With it on, the rocket slides on, free to pitch and yaw about its last button, until that button leaves too. Guided, the phase is off on a rail longer by the distance between the buttons. That holds the rocket straight to where its last button leaves the real rail, as HPR Sim holds it.
- What HPR Sim’s release leaves out is the phase on less the guided flight.
- The apogee moves by at most −0.414%: −10.9 m (−36 ft) for Juno III in still air. None of the 26 apogees moves by 1%.
- The landing point moves by more than 1% of the apogee in 6 of the 26 flights. They are on three rockets: Valetudo, Juno III and Prometheus 2022. The largest share is 3.765% of the apogee, 28.5 m (93 ft) for Valetudo in the crosswind. The largest distance is 92.0 m (302 ft), for Juno III in the crosswind.
- With the phase on, the rocket lands farther from the pad in 23 of the 26 flights. One of them, the vertical rail’s in still air, moves by 6 mm (0.2 in), which the report’s table rounds to zero. In those 23, a rocket guided to its last button lands nearer the pad than one that pivots. For a landing-area estimate that understates how far the rocket travels: the flattering side. In the other three, all in the crosswind, the guided rocket lands 0.3 to 3.6 m (1 to 12 ft) farther from the pad.
- The pivot itself is small. With the phase on, a rocket leaves its last button turning at up to 2.38 deg/s, its axis at most 0.083° off the rail’s.
- The plan’s rule set the phase on against the phase off. That moves 9 of the 26 landing points by more than 1% of the apogee, by up to 4.585%, and one apogee by +1.165%. Part of that is RocketPy’s early release and not the pivot. Bella Lui, freed at its forward button in the crosswind, has turned into the wind at 15.78 deg/s by the time its last button leaves. With the phase on it turns at 0.60 deg/s.
- A worked example. Juno III leaves a 5.20 m (17.1 ft) rail at 85°, its buttons 1.410 m (4.63 ft) apart. In still air its last button leaves at 21.53 m/s (70.6 ft/s), 0.071 s after the forward one. With the phase on, gravity has it turning nose-down at 2.26 deg/s by then, its axis 0.079° off the rail’s line; guided, it isn’t turning. Guided, it reaches 2,623.9 m (8,609 ft). With the phase on it reaches 2,613.1 m (8,573 ft) and lands 91.3 m (300 ft) farther from the pad. Each figure is rounded on its own; unrounded, the apogee moves down by 10.86 m (35.6 ft).
- The reference moved once. The report flies one fixed commit of RocketPy’s source. At
first that was the merge of RocketPy’s
pull request #920, which added the
phase. RocketPy then rewrote the phase ([RP-TIP] says what changed), and the report now
flies the rewrite (the decision record). No figure quoted on this page changed.
Between the two commits, a turning rate where the last button leaves moved by at most
0.000020 deg/s, and no flight’s apogee or landing point by more than 1.04 mm (0.041 in).
Each of the four differences HPR Sim’s phase is held to is under a hundredth of the bar it
is held to. The flights without the phase moved as far as those with it, so these are
differences between two commits of RocketPy, not the measured effect of the rewrite: the
report does not test which change made each. Its last table gives each flight, and the
earlier report’s data is kept as
validation/fixtures/flight/rocketpy-tip-off-at-pull-920.json. - What the comparison leaves out. RocketPy’s pivot is a frictionless pin with roll held; a real button has play in its slot. The guided flight frees the rocket at its last button’s position, and HPR Sim half a button’s length later, at the button’s aft edge. The thirteen fly one drag coefficient, and a wind that does not change with height. One rocket’s still-air flights open the apogee parachute with no lag, and the report says which and why.
The tip-off phase against RocketPy’s
HPR Sim’s tip-off phase is inside every bar below on all 26 flights when both codes fly RocketPy’s normal force. On HPR Sim’s own normal force it is on the 13 still-air flights and not on the 13 crosswind flights. That is one code against another, with no flight to check either.
cargo xtask tip-off-model flies the comparison and writes the report. The
gate and CI hold it (--check). The decision record gives what is
held and what stays open.
- What flies. The same thirteen designs, rails, sites, winds, parachutes and drag coefficient as RocketPy’s flights above. HPR Sim flies each guided, as it does by default, and with the phase. A design whose dry mass, reference area, motor or distance between its last two guides differs from what RocketPy flew is refused.
- Twice over. On RocketPy’s normal force, HPR Sim flies the force RocketPy flew. That is RocketPy’s slope at the Mach number times the angle of attack, at RocketPy’s center of pressure, read from RocketPy with each flight. The phase then meets one drag and one normal force in both codes. Damping in pitch and yaw stays each code’s own. On its own, HPR Sim flies its own aerodynamics.
- The bars are the tip-off decision record’s. Where the last guide leaves, the turning rate is within 10% of RocketPy’s or 0.1 deg/s, whichever is larger. The angle off the rail is within 10% or 0.005°. Each is compared as a pair. Nose-down is below the rail’s line in the rail’s vertical plane. Nose-right is to the right of the rail’s heading, which is downwind in the crosswind. The two codes’ apogee moves are within 0.2% of RocketPy’s guided apogee, and their landing-point moves, as vectors, within 1% of it.
- On RocketPy’s normal force, 26 of 26 flights are inside every bar. The largest difference in the turning rate is 0.003 deg/s against a bar of 0.238 deg/s, and in the angle 0.0001° against 0.0083°. In the apogee move it is 0.002% of the apogee, and in the landing-point move 0.029%.
- On its own normal force, 13 of 26 are: all 13 in still air, none in the crosswind.
- All 13 crosswind flights are past the turning rate’s bar, by up to 4.010 deg/s against a bar of 0.100 deg/s. 10 are past the angle’s, by up to 0.0671°. 3 are past the apogee move’s, by up to 0.379% of the apogee. 4 are past the landing-point move’s, by up to 4.082%.
- The cause is the normal force. In the crosswind the air meets the rocket at 9.7° to 25.6° as the last guide leaves. There HPR Sim’s own normal-force coefficient is 1.23 to 2.71 times RocketPy’s, and its moment about the last guide 0.35 to 15.20 times. The turn follows the moment. On 10 of the 13 the force acts ahead of the guide, and the nose turns downwind, farther on HPR Sim’s own. On 3 it acts behind the guide, and the nose turns upwind, less far on HPR Sim’s own. In signed terms the rate is farther nose-right on all 13, by 0.136 to 4.011 deg/s.
- Which force is nearer a real rocket’s at those angles, no reference here says (issue #1538). HPR Sim’s adds body lift, which RocketPy leaves out. Holding these 13 to the bars is an open increment.
- Which way leaving the phase out errs. With the phase, HPR Sim lands farther from the pad in 22 of the 26 flights on RocketPy’s normal force, as RocketPy does. On its own it does in 20. A move of under 0.1 m (0.33 ft) either way is not counted here. The count of 23 under What leaving tip-off out costs includes the vertical rail’s still-air flight, which moves 6 mm (0.2 in). For a landing-area estimate, a flight without the phase lands nearer the pad than one with it in most of these.
- A worked example. Juno III in still air, on HPR Sim’s own normal force, leaves its last guide at 21.5 m/s (70.7 ft/s), turning nose-down at 2.254 deg/s. RocketPy’s turns at 2.255 deg/s. Its axis is 0.0788° below the rail’s line, and RocketPy’s 0.0789°. The phase lowers HPR Sim’s apogee by 11.33 m (37.2 ft) and RocketPy’s by 10.86 m (35.6 ft). It lands HPR Sim’s rocket 95.4 m (313 ft) farther from the pad, and RocketPy’s 91.3 m (300 ft).
- What the comparison leaves out. Everything the comparison above does: one drag coefficient, a wind that does not change with height, and a frictionless rail. It also takes RocketPy’s normal force as RocketPy states it for a rocket at rest in the air stream. In flight RocketPy works each surface’s angle from the air’s speed at that surface. And in the crosswind the rocket leaves the rail at 9.7° to 25.6° to the air. Both codes carry small-angle models there, and 7 of the 13 are past the 15° the accuracy work assumes.
The tip-off phase on the real flights
This compares HPR Sim with itself, the phase on against the phase off; no flight’s log checks the phase. It moves each real flight’s apogee by under 1%, and each set’s mean error against the logs by a tenth of a percentage point or less. The compared first flights are the seven public flights compared as soon as they were flown; the predicted first are the five whose predictions were published before their comparison. On the seven compared first the phase brings the mean absolute apogee error down from 6.065% to 5.974%. On the five predicted first, and on the private collection’s 60 logged flights, it raises it by 0.0014 and 0.0033 percentage points. No real flight’s landing point is compared yet, so this measures apogees only. The phase is still off unless a flight asks for it; the next increment may make it the default.
cargo xtask tip-off-flights writes the report (the decision
record); the gate holds it (--check).
- What flies. Every real flight HPR Sim compares, each as its own report flies it: the twelve public flights of the real-flight report, and the private collection’s flights, given in aggregate only. Each flies guided, held straight to its last guide and then freed, as by default, and with the phase. A design needs two guides (rail buttons or launch lugs) at different stations for the phase to move it: 10 of the 12 public flights have them, and 23 of the collection’s 60. Each flies again in still air: the same air with its wind taken out, so that what the phase moves there is gravity’s turn about the last guide alone.
- Gravity lowers; the wind’s part is open. In still air the phase lowers 9 of the 10 public flights with two guides by more than 1 cm (0.4 in). The tenth, NDRT 2020, flies from a vertical rail, where gravity has no moment about the last guide; it moves 1 mm (0.04 in). On a tilted rail gravity turns the rocket nose-down about its last guide, so it leaves pointing lower. In the day’s wind the phase raises 2 of the 10 public apogees. That wind’s part is the part of the phase not yet held to RocketPy’s on HPR Sim’s own normal force; on Juno III in that comparison’s crosswind, HPR Sim’s phase raises the apogee and RocketPy’s lowers it.
- Why two errors rise. Of the predicted flights, the phase lowers Erebus 11, which HPR Sim already flies 8.05% low. On the collection it raises the mean signed error from +8.007% to +8.015%, on a set HPR Sim flies 8.0% high on average, and moves 14 of the 23 flights with two guides away from their logs and 9 toward them. How many it raises is held back, so that no figure gives a few flights’ own moves. Both rises are smaller than the hundredth of a point the reports print. The decision record traces each to its flights and lets the next increment make the phase the default; the fall over the compared-first flights rests on Juno III’s rise, so it is not counted for the phase.
- A worked example. Juno III’s log reads 3,151.5 m (10,340 ft). Guided, HPR Sim’s apogee reads 2,950.2 m (9,679 ft), 6.39% low. With the phase it reads 2,976.7 m (9,766 ft), 5.55% low: 26.5 m (87 ft) higher. In still air the phase lowers it by 16.7 m (55 ft). That is more than the 11.33 m (37.2 ft) of the comparison with RocketPy, which flies Juno III on one drag coefficient, not on the real-flight report’s drag and launch-day air; how much of the gap that explains is not measured. Taking out the wind changes the guided flight too, so the still-air and wind moves are not two parts of one sum.
- What it leaves out. The phase moves apogees by under 1%, against mean absolute errors of 6% to
13%, so no flight checks it. Landing points, where RocketPy’s
flights show the larger cost, wait for landing points against
the tracked landings. Two tests on the Valetudo pin which way
a landing point errs without the phase; the direction depends on the rail and the wind. On a 5.3°
tilted rail in still air the guided flight lands about 51 m (167 ft) short, held between 50.5 m
(166 ft) and 52 m (171 ft):
without_tip_off_a_landing_point_errs_nearer_the_pad_on_a_tilted_rail_in_still_air. On a vertical rail in a 5 m/s (11 mph) crosswind it lands about 26 m (85 ft) farther from the pad, held between 25 m (82 ft) and 26.5 m (87 ft):without_tip_off_a_landing_point_errs_farther_from_the_pad_on_a_vertical_rail_in_a_crosswind. That second direction comes from the wind’s part of the turn, the part not yet held to RocketPy’s on HPR Sim’s own normal force.
Time integration and events
Learn how HPR Sim steps a flight through time, stops exactly at set times such as burnout, and finds events such as apogee and landing.
In short
- What it models: stepping a flight through time, by Dormand-Prince 5(4), which adapts its steps to an error tolerance, or fixed-step Runge-Kutta (RK4). It lands exactly on set times such as burnout, and finds events such as apogee.
- Sources: Dormand and Prince (1980); Hairer, Nørsett and Wanner’s Solving Ordinary
Differential Equations I (1993), whose
DOPRI5code the port follows. Brent (1973) gives the root finding that locates events. - How well it is validated: by analytic and unit tests, and in part, together with the
rigid-body equations, against the codes of one of NASA’s check cases; not yet against a real
flight. Its
step counts match an independent transcription of
DOPRI5, and its error shrinks as theory predicts. In an exactly solvable flight with drag, apogee, deployment and landing times are right to 1.5e-8 s at default tolerances. On NASA’s tumbling brick, with the one named model difference taken off, the default tolerances leave the body rates within 0.0000009229 deg/s of the code nearest them over the 30 s. That is one of two codes that agree with each other; the other two kept codes are further off (a free body against NASA’s check cases). - What it leaves out: it can’t detect a stiff problem, where very fast, heavily damped motion forces tiny steps. The run then stops with an error. Fixed 10 ms RK4 steps can diverge for a light body under a big canopy. An event that crosses zero and back within one step goes unseen.
Code and sources
Code: hpr_sim::integrator and hpr_sim::events. Decisions: ADR-010 (Dormand-Prince
with dense output, RK4, stop times and events).
Sources:
- [DP80] J. R. Dormand and P. J. Prince, “A family of embedded Runge-Kutta formulae”, J. Comput. Appl. Math. 6 (1980) 19–26, doi:10.1016/0771-050X(80)90013-3. Cited, not fetched (the publisher refuses scripted downloads).
- [HNW] E. Hairer, S. P. Nørsett and G. Wanner, Solving Ordinary Differential Equations I, 2nd ed., Springer, 1993. §II.1 (RK4, table 1.2), §II.2 (order conditions, table 2.2), §II.4 (error norm, step control, starting step), §II.5 (DOPRI5, table 5.2), §II.6 (dense output). The PI controller is §IV.2 of volume II. Cited, not fetched.
- [D5] E. Hairer and G. Wanner,
DOPRI5(Fortran, version of 2004), BSD-2-Clause, pinned ashairer-dopri5invalidation/refs.lock.toml. It is the book’s code. The port follows it: coefficients (CDOPRI), the error norm and controller (DOPCOR), the starting step (HINIT) and the dense output (CONTD5). - [B73] R. P. Brent, Algorithms for Minimization without Derivatives, Prentice-Hall, 1973, ch. 4 (the zero finder). Cited, not fetched; implemented from the algorithm’s description.
Stepping and events
Methods
-
Dormand-Prince 5(4) ([DP80]; [HNW] table 5.2) has seven stages, first-same-as-last, so six new evaluations per step. The step advances with the fifth-order solution (local extrapolation), and the embedded fourth-order solution estimates the error: .
-
The error norm ([HNW] eq. 4.11; [D5]) is:
The weights come from
OdeSystem::absolute_tolerance_weights, so components in different units share one . A step is accepted when . -
The step control ([HNW] II, §IV.2; [D5] defaults) is the PI controller, with :
After a rejection, , and the step after a rejection can’t grow.
-
Departures from
DOPRI5:- A non-finite error estimate, or a derivative that fails in stages 2–7, counts as a rejection that shrinks five times. A long step’s stages can probe states off the trajectory (negative mass, a Mach number past a table’s end). The failure is reported only once the step can’t shrink further. A failure at the step’s first stage is reported at once, and so is any failure under RK4.
- A final interval within the rounding of , where is at most , counts as reached, instead of failing as too small.
- A step can be shortened to land on a stop time. After that, the next call starts from the larger of the controller’s proposal and the step the controller wanted before shortening.
- The step size overflowing to infinity (a problem with zero error and no stop) is an error.
- There is no stiffness detection.
-
For the starting step ([HNW] §II.4;
HINIT), , then one Euler step estimates the second derivative and -
With and , the dense output ([HNW] §II.6;
CONTD5) is:It is a continuous extension of order 4, so its error inside a step is .
-
RK4 ([HNW] table 1.2) has weights 1/6, 2/6, 2/6, 1/6 at 0, ½, ½, 1, with a fixed step. Its dense output is the cubic Hermite interpolant of , , , in the same nested form without (error inside a step). is the next step’s , so it costs nothing extra.
Stop times and discontinuities
Integrator::advance(system, t_stop)never steps pastt_stop. LikeDOPRI5, it stretches the last step up to 1% to land on it exactly (never pastmax_step_s). Thentime_s()equalst_stopbit for bit.- The system is one
OdeSystem<N>: the derivative, optional tolerance weights, optional events (event_count,event_direction,event_value), andaccept_step.accept_stepsees every accepted step with its dense output and can stop the run (Advance::Stopped). So a flight phase can record from, and stop on, its own state. - A discontinuity in the right-hand side (burnout, a staging, a phase change) must be a stop time. An RK step across a jump drops to first order (Loft lesson L23).
- The last stage of the step ending at
t_stopis evaluated att_stopand belongs to the phase before it. The first stage of the next call belongs to the phase after it. A system that picks its phase from alone gets one of the two wrong, so the caller sets the phase between calls (integrator::tests::a_discontinuity_inside_a_step_...). - Each call evaluates afresh, so the system can change between calls. The step-size estimate carries over.
Events
- An event is a scalar with a direction: rising (), falling () or either. The start value must be strictly on one side.
- After each accepted step,
advanceevaluates every at the step’s end. For each sign change it finds the zero of on the step with Brent’s method ([B73]) toEVENT_TIME_RESOLUTION_S = 1e-12 s(plus ). The earliest zero sets the stop. - The integrator stops at the end of Brent’s final bracket on the far side of
the zero, with the dense output’s state there. It returns
Advance::Events, andfired_events()lists every event past its zero at that state, ascending. Coincident events, such as two devices set to deploy at apogee, fire together. is already past zero (or exactly zero) for all of them when the next call starts, so none is reported twice. The system’saccept_stepsees the shortened step. - The event time is as accurate as the solution. The root finder adds at most about
2e-12 s. The state at the event is the dense output’s, which is fourth order for Dormand-Prince and third for RK4. - Limits:
- A function that crosses zero and returns inside one step goes unseen. Bound the step with
Adaptive::max_step_swhere that can happen. - A function that crosses and comes back to exactly zero at the step’s end is reported at the end.
- Events are checked only on accepted steps, never on stage values.
Integrator::resetbetween calls can move an event function back to its near side, by as little as renormalizing a quaternion. The event then fires again moments later. So normalize inside the system’s functions rather than resetting at an event.
- A function that crosses zero and returns inside one step goes unseen. Bound the step with
Defaults and limits
rtol = atol = 1e-8, no maximum step, and a limit of 10⁶ attempted steps.- The flight keeps these defaults with unit weights. On Valetudo’s flight on a K400C motor they took 1.13 ms to run, in a release build. The apogee came within 1.1e-6 m of a run at 1e-11 (Rigid-body flight).
- A stiff flight phase shows up as
StepTooSmallor the step limit. - A fixed step has to respect the drag’s own time scale. Quadratic drag , with , linearizes to . RK4 is stable only for . A light body under a big canopy is the worst case in HPR Sim. A 0.55 kg sustainer arriving at 168 m/s (551 ft/s) under 2 m² gives . So RK4 needs and diverges at 10 ms. The divergence surfaces as a geodesy error from an absurd position, not as a stability message. The adaptive method has no such limit. Recovery descents are the place this bites, because a separated body can be a tenth of the stack’s mass under a canopy sized for it.
- Integration runs forward only.
t_stopcan be infinite, to run until an event or a stop fromaccept_step. After any error, the integrator stays at its last accepted step and can resume.set_step_limitraises a spent limit.
Verification
Unit tests in hpr_sim::integrator::tests and hpr_sim::events::tests. The numbers quoted were
measured on September 17, 2026.
- In the tableau, rows sum to . The fifth-order weights satisfy all 17 order conditions to
order 5 ([HNW] table 2.2) to 1e-14. The embedded weights satisfy orders 1–4 and miss at least one
fifth-order condition by more than 1e-4. The dense output’s weights satisfy the conditions
to order 4 at = 0.1 to 0.9, which pins
D1–D7. - The port matches
DOPRI5on Hairer’s driver problem, the Arenstorf orbit, atrtol = atol= 1e-4, 1e-7 and 1e-10. The evaluations (494, 1,442 and 5,060) and attempted steps (82, 240 and 843) equal those of an independent line-by-line transcription ofDOPCORandHINIT. So do the accepted steps (64, 216, 841), and the end positions to 1e-9. This pins the controller, the starting step and the error norm. - Step-halving convergence on the nonlinear, non-autonomous , on
, driven through
advance:- Dormand-Prince runs at a fixed step , its first and largest, with tolerances too loose to reject. Over 10 to 160 steps its orders are 5.88, 5.53, 5.31, 5.17, falling toward 5. At 320 steps the error, 6e-15, reaches rounding. The dense output at = ¼, ½, ¾ gives 4.81, 4.97, 4.99, 4.99.
- RK4, 20 to 160 steps: orders 4.04, 4.02, 4.01. Its Hermite dense output gives 3.96, 3.99, 4.00.
- Over with
rtol = atolfrom 1e-4 to 1e-9, the error falls from 2.7e-5 to 2.2e-10. It is 0.22 to 0.28 of the tolerance throughout (asserted within 0.07 to 0.85). - A vertical flight with quadratic drag, , has a closed-form apogee
(
testing::closed_form_quadratic_drag, Loft lesson L21). As the tolerance halves from 1e-5 to 2e-8, the apogee time error falls from 5.7e-4 s to 1.2e-8 s. The height error falls from 3.4e-4 m to 8.3e-8 m. The fall is not monotone step by step: has a kink at apogee. The log-log slope of the height error against the tolerance is 1.36. The worst errors are 117·tol (time) and 91·tol (height). - In a vacuum with constant thrust, burnout is a stop time (Loft lesson L23). At burnout the state matches Tsiolkovsky’s equation with gravity loss to 1e-9 relative, for both methods. The coast apogee is within 6.3e-9 s and 5.2e-6 m of 48.8 km (30 mi) with Dormand-Prince (20 steps). RK4 (0.01 s) comes within 4e-11 s and 1.6e-8 m. Integrated straight through the jump, RK4 misses the velocity by 0.56 m/s (1.8 ft/s). With the stop time the miss is 1e-12 m/s.
cargo xtask check-cases, held by the gate where the codes’ files are fetched: NASA’s check case 2, a brick of three unequal moments tumbling for 30 s (a free body against NASA’s check cases). With the named model difference taken off, the flight at the default tolerances (1e-8) sits 0.0000005866, 0.0000009229 and 0.0000002790 deg/s from the code nearest it in roll, pitch and yaw rate. That code is SIM 1 or SIM 4, which agree with each other; the other two kept codes are up to 0.00004975 and 0.001242 deg/s away. At tolerances of 1e-12 the first three fall to 0.000000002126, 0.000000003051 and 0.000000001089 deg/s. So they are the default tolerances’ step error, read from HPR Sim’s own two flights and not from the codes. The steps are not checked on their own here: the gravity and rigid-body equations are in the same flight.- Events are located within 1e-6 s (Loft lesson L22):
- For the quadratic-drag flight, the apogee, a 300 m (984 ft) descending deploy and landing are all located against the closed forms. Errors: 1.2e-8, 1.5e-8 and 1.4e-8 s at the default tolerances, and 3e-12 to 1.3e-11 s with RK4 at 0.01 s. at the stop is below 1e-13.
- For , falling zeros and extrema over 20 s are located to 3e-8 s (Dormand-Prince) and 1.6e-9 s (RK4).
- Restarting on an event doesn’t report it again.
- Three coincident events fire together, once per crossing.
- Three crossings inside one RK4 step come out in time order, to 1e-12 s.
- Where the dense output is exact (), nonlinear event functions stop between 0 and 2.5e-12 s past their roots, on the far side.
- Brent’s method is checked on:
- a smooth root, to 1e-14;
- a triple root;
- a step discontinuity (under 60 evaluations, far side returned);
- exact zeros at the ends, a bracket that doesn’t bracket and a NaN.
- These failures are reported as errors, never as a quiet stop:
- a failing derivative (the adaptive method closes to within 1e-9 s of where it fails);
- a blow-up ( stops near );
- a step overflowing to infinity;
- the step limit (and resuming after raising it);
- bad settings, a backward stop and zero weights.
- Stops 1 to 40 ulps ahead of = 0, 3, 100 and 1,000 s are reached. Steps respect
max_step_s.accept_stepcan stop a run. Repeated runs are bit-identical. Unknown fields and the old tag names are refused in settings files.
Recovery
See how HPR Sim brings a rocket down under a parachute or a streamer or by tumbling, and where each part drifts and lands.
In short
- What it models: how a rocket comes down under a parachute, a streamer or tumbling. It covers when each device fires, how a canopy fills and the descent in the wind. A stack can split into parts (separation), or let out a nose cone or a payload (ejection), and each part lands.
- Sources: Knacke’s Parachute Recovery Systems Design Manual (1991) for parachutes; Carruthers and Filippone’s streamer tests (2005) and the OpenRocket technical documentation for streamers and tumbling.
- How well it is validated: against another simulator and against drop tests. Five public
flights’ descent rates under the main parachute are listed beside their logs’
(residuals report). The simulated rate runs from 1.48 m/s (4.9 ft/s) slower
than the log’s to 1.07 m/s (3.5 ft/s) faster, and slower is the side that flatters a landing.
Each difference is the simulation’s and the log reading’s together. No error over the five is
worked out as one number yet: that is for M2.12, descent rates against the logs.
- The descent under a parachute matches RocketPy’s for five example rockets, started from the same state near apogee. All 30 metrics are within 3%, the largest +2.865% (validation report). Drift is measured from that shared start, not from the pad.
- That comparison flies RocketPy’s gravity formula and RocketPy’s way of interpolating the wind. HPR Sim’s defaults differ from both: the full gravity vector, and a wind table interpolated by speed and direction. Under HPR Sim’s own gravity, Calisto’s drift read a little closer, once, before the comparison switched (Against RocketPy, below); no test pins that. What HPR Sim’s default wind interpolation does to drift has not been measured.
- Against measured drop tests, tumbling is −10 to +19% off, and the default streamer model predicts a descent +9% faster than Kidwell’s one flat streamer.
- A
.orkfile’s parachutes and streamers fly as OpenRocket flies them. The landing speed is within 0.021% of OpenRocket’s on 50 of its 53 example flights and within 0.12% on all 53. Of the 51 with no named cause for an apogee gap, drop the Base drag hack’s three. The flight time of the other 48 is −1.57% to +3.16% off (From an OpenRocket file). - Ejected pieces are a nose cone or payload that lands on its own (ejection). They are checked against exact answers only: no simulator or flight has been compared with them yet.
- What it leaves out:
- Two effects on the opening load are left out. One is the drag overshoot as a canopy fills. The other is the way a light rocket slows while it fills, when the canopy opens at once (the default). So the simulator’s peak opening load is no safe bound either way. Don’t size recovery hardware from it: use a dedicated opening-load method and the hardware’s own ratings.
- Airframe drag: a separated body falls with no drag until its device opens, so its deployment speed can read high after a long fall. It can also read low: a part split off while climbing, whose device opens later by a timer or the motor’s delay, coasts higher with no drag, so it is still near its top when a real part, slowed by its airframe’s drag, has already turned and is falling. If its device opens then, it opens slower than a real part’s would. That takes a part whose drag is large for its mass, a light nose cone rather than a heavy payload. The airframe’s own drag under a canopy is left out too. The same holds for an ejected piece.
- The push of a separation’s charge on the two stages (an ejection’s is modeled, a separation’s is not).
- Added mass (air carried along), the swing (the attitude freezes at deployment), and streamer pleats (+58% fast on a pleated one).
- Tumbling is used far outside its fit: 36.4 m/s (119 ft/s) for Valetudo, against 5.0 to 6.6 m/s (16 to 22 ft/s). A nose cone tumbling on its own is outside it too.
Code and sources
Code: hpr_sim::recovery in the API reference
(crates/hpr-sim/src/recovery.rs), and the descent branch of crates/hpr-sim/src/dynamics.rs.
Decisions: ADR-012 (parachutes and the descent), ADR-013 (streamers and
tumble), ADR-014 (separation), ADR-153 (a .ork file’s recovery, flown
by hpr::ork::recovery).
Sources:
- T. W. Knacke, Parachute Recovery Systems Design Manual, NWC TP 6575 (1991), for canopy drag
coefficients, filling times, drag-area growth and the equilibrium descent speed. Its title page
limits distribution, so it is cited, never redistributed (
docs/VALIDATION.md). - RocketPy 1.13.0 (MIT),
rocketpy/simulation/flight.py:2710-2790androcketpy/rocket/parachute.py, for the point-mass descent that the parachute milestone (M1.7a) is compared against. - A. C. Carruthers and A. Filippone, “Aerodynamic Drag of Streamers and Flags”, Journal of Aircraft 42(4), 2005, pp. 976–982, DOI 10.2514/1.9754, for streamers.
- The OpenRocket technical documentation v13.05 (CC BY-SA): Appendix C for streamers, §3.5 for
tumbling bodies, and §4.2.5 for a
.orkfile’s parachutes and descent. - C. Kidwell’s drop tests (2001), a research report for NARAM-43, the National Association of Rocketry’s annual meet. Both streamer models are checked against this measurement.
Drag of each device
Drag of a parachute, a streamer and a tumbling body.
Drag area
A device’s drag is set by its drag area , in m²: a drag coefficient times the area that coefficient is measured on. The simulator takes it in one of two ways:
- Given directly (
DeviceDrag::DragArea), which is RocketPy’scd_s. - From a canopy (
DeviceDrag::Canopy): . Here is the nominal diameter and the drag coefficient on the nominal area . That is Knacke’s convention (printed page 5-2; , so includes the vent and every opening).
CanopyType carries Knacke’s printed data for thirteen canopy types:
- The range (Table 5-1 for solid textile canopies, Table 5-2 for slotted). Knacke prints a range for every type and no single value. The simulator’s default is the middle of the range (flat circular: 0.75 to 0.80, so 0.775).
- The fill constant (Table 5-6). It sets how long the canopy takes to fill: the filling time is nominal diameters divided by the speed at line stretch (Inflation). The simulator takes it from the table’s unreefed column, for a canopy that opens freely. (Reefing is a line round a canopy’s edge that holds it partly closed at first, to cut the opening load.)
- The drag-area growth exponent of Pflanz’s method (Figure 5-51). Pflanz’s method, in Knacke’s manual, works out the opening force with a drag area that grows as a power of the time since line stretch.
- The infinite-mass opening-force coefficient : the peak force as the canopy opens, over its steady drag at the same speed. It is defined for a load so heavy that it doesn’t slow while the canopy fills. The simulator reports it; its equations don’t use it (Inflation).
Where Knacke prints “insufficient data” the simulator has None, and the user has to supply the
number.
RocketPy’s default parachute of 1.4 is not a in this sense. It is a hemispherical
canopy’s coefficient on the projected area. RocketPy uses it only to turn cd_s into a radius for its
added mass. Knacke’s hemispherical range on is 0.62 to 0.77.
Streamers
A streamer is a strip of fabric of length and width , so a
planform (one-side) area and an aspect ratio . StreamerModel picks the
correlation, the curve fitted to measurements that gives its drag coefficient:
-
Filippone(the default), on . It comes from wind-tunnel tests of cotton streamers clamped at the leading edge. The tests ran at 3.3 to 30 and 6 to 18.9 m/s (20 to 62 ft/s). The paper fits one power curve per planform area, and prints all three:planform area curve where 0.025 m² eq. 2 (Figure 2’s trend reads ) 0.05 m² the trend line on Figure 3; the text does not repeat it 0.075 m² eq. 1 (Figure 4 reads ) The simulator interpolates between neighboring curves, linearly in the logarithm of the area (). Outside the fitted areas it holds the end curve. Both are the simulator’s choice, not the paper’s. All three curves are needed, because is far from linear in . At , the middle area’s (0.3154) sits 0.3% below the smallest area’s (0.3163), not partway down to the largest’s (0.2245). A straight line in would put it 63% of the way there. Blending only the two end curves would read 18% low there.
Three of the paper’s own findings bear on how to read it, and none is in its curves:
- a free leading edge gives more drag than the clamped mounting these curves come from;
- lighter, smoother fabric gives less (polyester at 64 g/m² against cotton at 177);
- at the largest area it finds a drag crisis near = 7.2e5. That is a sudden change in the drag coefficient over a narrow range of Reynolds number.
A rocket’s streamer is free and light, so the first two pull in opposite directions.
-
OpenRocket, on :with the streamer’s drag coefficient on , the fabric’s mass per square meter (Appendix C, eq. C.6, printed page 117). It was fitted to model-rocket streamers. The fit covers 0.01 to 0.09 m (0.033 to 0.30 ft) and 0.2 to 1.0 m (0.66 to 3.3 ft). It covers 10 to 80 g/m² and 6 to 12 m/s (20 to 39 ft/s). Its stated error is 12 to 27% on an independent set. It is the only one of the two that uses the material.
Which model is right?
The two disagree by a factor that depends on the fabric. At and the ratio of their drag areas is 5.8 at 10 g/m², 3.5 at 32 and 1.9 at 80.
C. Kidwell’s NARAM-43 drop tests (2001) settle it as far as one dataset can. The tests used sixteen 4 in × 40 in streamers, each with about 5 g at one corner, dropped 20.1 m (66 ft).
Two details of his method decide how to compare, and both were got wrong here before review:
- His rates are distance over time, so they are averages over the drop rather than terminal speeds. A 20.1 m (66 ft) drop averages 0.97 of terminal at 2.8 m/s (9.2 ft/s) but 0.89 at 5.9 m/s (19 ft/s).
- They are normalized to a notional 5.000 g weight: scaled to what that standard weight would give.
streamer_models_against_kidwells_drop_tests uses the notional mass and compares the same
average, from the closed-form fall:
| case | measured | implied (coefficient), on | Filippone speed | OpenRocket speed |
|---|---|---|---|---|
| crêpe paper, 32 g/m², unpleated | 2.80 m/s (9.2 ft/s) | 0.155 | 3.05 m/s (10.0 ft/s, +9%) | 5.28 m/s (17.3 ft/s, +88%) |
| Micafilm, 42 g/m², pleated | 2.04 m/s (6.7 ft/s) | 0.338 | 3.21 m/s (10.5 ft/s, +58%) | 5.19 m/s (17.0 ft/s, +154%) |
What the table shows:
- Kidwell’s crêpe streamer is the one he left flat, and a flat correlation predicts it to 9%. Appendix C reads 88% fast.
- His other materials were folded in ¾ in pleats, which more than doubles the drag again. The simulator models no pleats, so it predicts a faster descent for a pleated streamer, which is the safe direction for a landing.
- Kidwell’s streamers are a little outside both fits: 0.1032 m² of planform against Filippone’s largest 0.075 m². They are 0.1016 m (0.333 ft) wide by 1.016 m (3.33 ft) long against appendix C’s , .
Streamers larger than the fits
Above 0.075 m², the simulator’s clamp holds the largest area’s curve. Kidwell’s streamers are above it, so his drops test the clamp, and the evidence pulls two ways:
- The paper’s trend says the clamp reads high. Its falls as the area grows. The two end curves at imply . Extrapolated to Kidwell’s 0.1032 m², that would give where the clamp gives 0.130. The steeper inner pair, , would give 0.110.
- The drop says it reads low. The drop itself implies 0.155, higher than any of them.
- The simulator holds the end curve rather than extrapolating, because that is the closer of the two to the one free-drop measurement in hand. It says so here rather than claiming the trend.
- Two caveats apply. That rests on a single point, at one aspect ratio, with a fabric nothing like the paper’s cotton. And it holds partly because the correlation, measured with the leading edge clamped, is itself biased low, so two errors cancel.
- Nothing is measured anywhere near 0.225 m². That is the 1.5 m (4.9 ft) by 0.15 m (0.49 ft) streamer one of the simulator’s tests flies on the clamp.
The simulator therefore defaults to Filippone and keeps OpenRocket for comparing with OpenRocket
(ADR-013, streamer and tumble drag).
Tumble
A body with nothing deployed descends broadside, tumbling. DeviceDrag::tumbling(&assembly)
computes its drag area from the airframe by the OpenRocket technical documentation’s §3.5
(printed pages 53 to 55, eqs. 3.98 and 3.99):
- is the body’s side profile area, the outer diameter integrated along the axis, . The simulator takes a tube’s diameter times its length, and integrates each nose cone’s and transition’s own curve.
- is, for each fin set, one fin’s planform area times an efficiency factor by fin count (Table 3.4). The factors are 0.50, 1.00, 1.50, 1.41, 1.81, 1.73, 1.90, 1.85 for 1 to 8 fins. It is a fit, not a model: four fins are 1.41 of one fin, not 2, and it is not monotonic. More than eight fins is refused.
- Tube fins are refused: the model has no factor for them.
- A pod’s tubes and fins count as the airframe’s do, once per pod. The documentation’s model has no term for pods, nor for one part shading another from the air. So a rocket with pods tumbles at a drag area the fit was never checked on.
- The documentation notes 0.56 is half a circular cylinder’s 1.12 in crossflow (air flowing across
it, side-on). It calls that expected of a cylinder falling at a random angle. It also notes that
1.42 is “similar to that of a flat plate 1.17 or an open hemispherical cup 1.42”. Those come from
Hoerner’s Fluid-Dynamic Drag (1965), which is copyrighted with no legal free copy. NASA TN D-540
and TR R-474 carry the same numbers and are free (
docs/research/streamer-and-tumble-drag.md). - Until M1.11b the simulator took each component’s end diameters, which under-counts a curved nose. For Valetudo’s tangent ogive that was 0.0111 m² against the true 0.0148 m², 25% low on the nose. Integrating the curve brought Valetudo’s tumbling speed from 36.77 to 36.38 m/s (120.6 to 119.4 ft/s, ADR-086, ejection impulse and tumbling pieces).
How well it does. The documentation says its fit predicts its own five drop-test models within
3 to 14%. The simulator does not reproduce that. Table 3.3 (printed page 54) gives five models,
22 m (72 ft) and = 1.31 kg/m³. The descent rate is read from video to ±0.3 m/s
(0.98 ft/s). Replaying Table 3.3 through the simulator’s reading of the model
(the_tumble_model_against_its_own_drop_tests) gives:
| model | fins | measured | HPR Sim, m/s |
|---|---|---|---|
| #1 | 3 | 5.6 m/s (18 ft/s) | 5.27 (−5.8%) |
| #2 | 4 | 6.3 m/s (21 ft/s) | 5.96 (−5.4%) |
| #3 | 3 | 6.6 m/s (22 ft/s) | 6.13 (−7.2%) |
| #4 | none | 5.4 m/s (18 ft/s) | 6.43 (+19.0%) |
| #5 | fins only | 5.0 m/s (16 ft/s) | 4.50 (−10.0%) |
So the spread is −10 to +19%. The finless tube is the outlier: it wants a body coefficient near 0.79 where the model prints 0.56.
The text pins neither the body-profile nor the fin-area convention (exactly which areas to measure). So either the simulator reads the areas differently from whoever fitted the constants, or the claim is not reproducible. The table above is what the simulator can demonstrate, so it is what the simulator states.
Where it stops being true. The fit covers 44 to 103 mm (1.7 to 4.1 in) bodies of 6.8 to 160 g. They descend at 5.0 to 6.6 m/s (16 to 22 ft/s). A high-power booster is far outside it: Valetudo tumbling comes out at 36.4 m/s (119 ft/s).
- A cylinder’s crossflow drag falls by roughly half above a Reynolds number near 2e5, its drag crisis. A 100 mm (3.9 in) body reaches that at about 30 m/s (98 ft/s). Valetudo’s 80 mm (3.1 in) at 36.4 m/s (119 ft/s) is right at it.
- So a real body that size would descend faster than the simulator says.
- The simulator does not model that fall, and nothing in the pinned sources covers it.
A piece on its own. DeviceDrag::tumbling(&assembly) covers the whole airframe, and
DeviceDrag::tumbling_stages(&assembly, (first, last)) a run of whole stages.
Simulation::tumbling_piece(k) is for an ejected piece that is part of a stage. It sums the same
model over piece ’s own body components and fins (Ejected pieces). A payload is refused: it has no
tube or fin of its own. A nose cone tumbling on its own is outside the fit, which was made on
whole rockets. Its speed is the model’s, not a measured one.
A tumbling body is a device like any other: give it a trigger, and it starts at that moment. The simulator does not decide by itself when a rocket tumbles. Nothing citable says when a stage becomes unstable enough (the same documentation declines to model the analogous streamer regime).
Deployment and descent
When a device fires, how a canopy fills, and the descent.
Triggers, lag and release
A device’s charge fires at its Trigger:
Apogee: when the center of mass is descending. The simulator’s apogee event fires it the instant the height rate crosses zero.- A flight that starts in mid-air, already past its apogee, has no crossing to find, so the
charge fires at its first step. RocketPy’s own apogee trigger does the same: it fires whenever
the vertical velocity is negative (
parachute.py:368-376). - Such a flight starts from
Simulation::run_free, as the comparison with RocketPy below does, and as staging and flight-data replay will. - The charge fires once, at whichever of the two comes first.
- A flight that starts in mid-air, already past its apogee, has no crossing to find, so the
charge fires at its first step. RocketPy’s own apogee trigger does the same: it fires whenever
the vertical velocity is negative (
Altitude { height_above_ground_m }: the first time the center of mass is descending and at or below that height above the launch site. This is an altimeter’s main setting. A rocket whose apogee is already below the setting fires at apogee, because no crossing follows. That is RocketPy’s numeric trigger: vertical velocity negative and height below the setting (parachute.py:354-364). After the flight’s recorded apogee the rocket counts as descending even if its center of mass rises for a moment. It can rise when a part is let go there (Released mass). Without a release that is the same rule.Time { time_s }: a time after launch.MotorDelay { motor }: that motor’s ejection delay after its own burnout. The motor must have a delay in seconds; a plugged motor or one with no delay set is refused.Burnout { motor, delay_s }: a given delay after that motor’s burnout, whatever its ejection delay; a stage separation timed from the booster’s burnout, say (Staging). A motor that never lights fires neither this norMotorDelay.
Charges are only checked in free flight and during the descent. So a Time or MotorDelay
trigger whose time passes while the rocket is still on the pad or the rail fires at
rail exit.
lag_s seconds after the trigger the device deploys (line stretch, where the lines pull taut)
and starts to fill. The first deployment of a flight switches it to the descent phase.
A device can name another whose opening releases it (released_by), which is how a drogue is
cut away under a main:
- The release waits until the releasing device is fully open, not its line stretch. Cutting the drogue at line stretch would leave the rocket under an empty canopy. The drag area would collapse and the descent speed up. That was found in review. Before the fix it measured 0.45 m² → 0.02 m² and 18.3 to 22.0 m/s (60.0 to 72.2 ft/s).
- A released device contributes nothing from its release.
- One released before its own charge fires never deploys at all: its
Triggeris recorded and noDeploymentfollows.
Events, in the order a two-device flight records them: Apogee, Trigger(drogue),
Deployment(drogue), Trigger(main), Deployment(main), Release(drogue) (at the end of the
main’s filling), GroundHit.
Trigger times known before the flight (a time, or a motor delay) are stop times, and so is every deployment and end of filling. So no integration step straddles a change in the drag area.
Inflation
A canopy doesn’t reach its full drag area at line stretch: it grows over a filling time. Each device that has deployed and is not released contributes
with its full drag area, its deployment, its filling time and its growth exponent. The open devices’ drag area at time is the sum of these.
The exponent sets the shape of the growth:
- is linear growth (Knacke’s ribbon and ringslot canopies);
- is the growth of solid cloth (Pflanz, Figure 5-51), : slow at first, fast at the end.
Inflation chooses :
Instant(the default): , the full drag area at line stretch. This is RocketPy’s model. For a deployment well above the canopy’s terminal speed it gives the simulator’s highest opening load. Near terminal speed, as at apogee, a filling time can give a higher one, because the rocket speeds up while the canopy fills.FillingTime { time_s, exponent }: a filling time fixed in advance.FillConstant { constant, exponent }: Knacke’s (printed page 5-43), with the airspeed at line stretch. The canopy fill constant is from Table 5-6’s unreefed column (printed page 5-44): 8 for a flat circular canopy. A deployment at rest has no filling time in this law ( diverges). So the canopy is taken as open at once and fills as the rocket picks up speed.
The fill constant at hobby speeds
Knacke states the linear form only “in the medium-velocity range of about 150 to 500 ft/s”
(45.7 to 152.4 m/s (150 to 500 ft/s); Inflation::FILL_CONSTANT_RANGE_M_S). A hobby main is slower:
- A main opening at 20 to 30 m/s (66 to 98 ft/s) is below that range.
- There, his alternative for solid flat circular canopies is with . It is a dimensional form (feet and ft/s) that cannot be used in SI as printed, so the simulator does not use it.
- So outside the range the filling time, and with it the peak load the simulator reports, is an extrapolation. At 25 m/s (82 ft/s) the linear form gives a 2.5 m (8.2 ft) main . That comes from a correlation fitted at 1.8 to 6.1 times that speed.
The opening load
The simulator’s drag area rises to the steady value and stays there. Knacke writes the opening force as (printed page 5-50), with the dynamic pressure at line stretch. Its two factors fare differently in the simulator:
- The overshoot, , is left out. Knacke’s measured drag area overshoots the steady value by 10 to 80% near the end of filling (Figure 5-40, printed page 5-47). His infinite-mass opening-force coefficient is for a flat circular canopy; the simulator’s is 1 in every mode.
- The slowing, , depends on the mode. allows for the rocket slowing while the canopy
fills. It is 1 at infinite mass (a load too heavy to slow). It is as low as 0.02 for a
final-descent parachute with a low canopy loading (little weight for the canopy’s size).
- With a filling time (
FillingTimeorFillConstant), the simulator already includes the slowing. It integrates the rocket’s deceleration while the drag area grows. That is Pflanz’s method done step by step, without the overshoot. Don’t apply on top of the simulator’s peak, or the slowing is counted twice and the load reads low. - Opening at once (
Instant, the default), there is no slowing: the peak is Knacke’s infinite-mass case with .
- With a filling time (
So the peak load the simulator reports is no safe bound on the real one, in either direction:
- With a filling time, the missing overshoot alone can only raise the real peak. The growth law and the filling time, extrapolated at hobby speeds, can move it either way.
- Opening at once, the simulator applies the full drag area at line stretch: the infinite-mass case. A big main on a light rocket can therefore see far less than the simulator’s instant peak.
- For scale, take the 1.5 m (4.9 ft) flat circular canopy deployed at 60 m/s (197 ft/s) in Verification. It peaks at 1.6 kN filling and 3.0 kN opening instantly. Knacke’s infinite-mass on the same dynamic pressure would be 5.1 kN.
The flight’s opening shock, max_descent_acceleration_m_s2, is the largest of this load over the
mass. After a separation with nothing left to burn, the part that
keeps the nose flies on as a point mass (body 0), and its own devices’ load counts too: their
drag alone over its mass, ( the
air’s density, the part’s velocity, the wind’s), with no airframe
drag, whether they open before the split or after. The part dropped aft is never counted in
the flight’s figure: its devices act only once it flies on its own. Two tests pin the nose
part’s load: at
to 1e-9 at an instant opening
(the_part_that_keeps_the_nose_has_its_own_opening_shock), and, under a canopy filling in a
crosswind, at the top of the load inside a step, which the step’s start, middle and end alone
read low (the_nose_parts_shock_tops_inside_a_step_under_a_filling_canopy). An
ejection that parts the stack, or the part that keeps the nose, ends
the count: from its charge on, neither the piece ahead of the parted joint (a nose cone pushed
off is the nose cone alone), which is body 0 from then on, nor the pieces behind it count. An
ejection in the part dropped aft, after the split, leaves the flight’s figure as it was: a test
flies one, and the figure is the same to the last bit with that charge and without
(an_ejection_in_the_part_dropped_aft_leaves_the_flights_shock_alone).
Each separated body has its own opening shock too, in body_max_descent_acceleration_m_s2,
in m/s²: at most one entry for each body, under the body’s number. It is the largest drag of
that body’s own open devices over its mass, by the same formula, over its whole flight as a
point mass. So the part dropped aft has one, and so has each piece an ejection makes. A
canopy’s steady fall reads 1 g here too. Read it with these in mind:
- A body that lets a piece go keeps its number. Its figure is the larger of the one before the charge and the one after, each over the mass the body had at that instant. A device that is already open stays with the piece it is on. A nose cone pushed off under its own canopy is far lighter than the part it left, so it reads far higher. That is why body 0’s own figure can be larger than the flight’s, which stops counting body 0 at such a charge.
- A tumble counts as a device. A part that tumbles from a fast split reads the tumble’s drag over its mass at the split. That can be above its canopy’s opening later, and then the canopy’s own opening is not given. The tumble’s drag was fitted to bodies falling at 5.0 to 6.6 m/s (16 to 22 ft/s) (Tumble). A fast split is far outside that fit, so the figure there is no bound either way.
- A canopy that opens after a tumble likely reads low. The tumble slows the part more than a real booster slows: a real one flies nose-first for a while (issue #179). So a canopy that opens on a timer or at a height on the way down opens at a lower speed in the simulator than it would in the air, and its load follows the speed squared.
- A body with no device of its own ever open has no entry. What a device did while the stack was whole is in the flight’s figure only.
Four tests pin a body’s own figure at to 1e-9 at an instant opening, over that body’s own mass:
- the part dropped aft at a separation
(
the_part_that_keeps_the_nose_has_its_own_opening_shock); - the airframe behind a nose cone’s joint, and the cone itself under its canopy and the drogue
it kept (
the_nose_parts_shock_stops_counting_where_an_ejection_parts_it); - the two pieces of a dropped part that parts at a charge of its own
(
an_ejection_in_the_part_dropped_aft_leaves_the_flights_shock_alone); - the nose cone of a rocket that pushes it off on the climb, with no separation
(
a_nose_cone_ejected_before_apogee_leaves_the_summary_with_no_apogee_or_shock, inpieces.rs).
Don’t size recovery hardware from the simulator’s opening load. Use a dedicated opening-load method and the hardware’s own ratings. Ludtke’s law and Pflanz’s reduction factor are candidates for a later milestone.
The descent
Once a device is open the rocket is a point mass: all of its mass at the center of mass, with no rotation. In the launch frame, the motion follows the equation below. Here is the mass, and are the center of mass’s velocity and acceleration, and is the wind. Also is the density at its height, is normal gravity, is the Coriolis acceleration and is the thrust:
- In code it is the free-flight equation. The simulator uses the translational equation of
Rigid-body flight with the body’s rotation rate and the
canopy drag in place of the airframe’s aerodynamics. Two things carry over:
- The terms for a still-burning motor: the center of mass moving inside the body as propellant burns () and the exhaust jet’s terms. That page sums them, with the forces, into . After burnout every one of them is zero.
- The point the integrator follows is still the nose tip , not the center of mass. With no rotation and nothing burning the two move together, so the nose tip’s acceleration equals and the equation is the one above.
- No moment. The drag acts at the center of mass along the air’s relative velocity, so it exerts no turning moment.
- The attitude freezes at deployment. The body rates are set to zero. The nose tip keeps its rigid offset from the center of mass, (the center of mass’s position from the nose tip, in body axes). As the rates go, the nose tip’s velocity is shifted by (turned from body axes into the launch frame). That way the center of mass keeps the velocity it had. Whatever stops the rotation acts through the lines and the canopy, inside the system, so it can’t change the center of mass’s momentum.
- The airframe’s own drag is left out, as it is in RocketPy, the oracle this is compared with. A rocket’s attitude under a canopy, and so the area it presents, is not modeled. For a drogue whose drag area is close to the airframe’s broadside area this is a real omission. The tumble model (M1.7b, streamers and tumble) is where a body’s own drag belongs.
- The thrust is kept, along the frozen axis. So a device that opens while a motor still burns (an off-nominal case) is not silently thrust-free. Its direction is wrong the moment the rocket would have swung under the canopy.
- The rest is shared. Gravity, the Coriolis force, the atmosphere and the wind are the same models the rest of the flight uses (Rigid-body flight).
- Added mass is not modeled.
- Knacke gives no closed-form apparent mass (printed page 5-40 says only that it is the enclosed volume times density times a form factor). RocketPy’s has no citation in its code.
- It is not small. The fixture records 5.6 kg for Calisto’s main against a 16.2 kg rocket. It records 15.9 kg for NDRT’s against a 20.8 kg one. Both are at the start height, and both grow with density as the rocket descends. The comparison below shows what leaving it out costs.
The equilibrium descent speed is Knacke’s (printed page 5-128), and recovery::terminal_speed_m_s
computes it:
Parts that come apart
A stage split and a piece let go at a joint.
Separation
A Separation is a trigger and a stage boundary. At the trigger the stack comes apart into two
bodies:
- body 0 keeps the nose: the stages from stage 0, at the nose, through the one
after_stagenames; - body 1 is the stages aft of the split.
Each body flies on as a point mass under the devices that name it (Device::on_body). The ascent
ends there: its FlightResult has Termination::Separated, a Separation event, and one
BodyFlight per body in bodies. The exception is a powered separation, where body 0 still has a
motor to burn. It flies on as a sustainer, and only body 1 descends here
(Staging).
This section describes the unpowered case, and the booster’s descent after a powered one.
What happens at a separation:
-
Each body is its own stages and their motors.
body_mass_propertiessums the stages’MassPropertiesand the motors mounted in them. So the bodies’ masses add to the whole rocket’s at that instant, which is a test. -
Nothing pushes the bodies apart. Each body starts at its own center of mass, with the velocity that point already had. That is the nose tip’s velocity plus the rotation’s share, , in the launch frame. So the bodies’ linear momenta add to the stack’s, which is a test.
-
Their spin is dropped. Each body’s center keeps moving round the stack’s as it was, but each body’s spin about its own center is lost. So angular momentum is not conserved. In the test, spinning at 0.6 rad/s, the lost spin is 31% of the angular momentum, and 0.02 J of energy.
-
Only body 0’s devices act before the separation. A device meant for another body has a drag area computed for that body (a booster’s tumbling area, say). That is not a model of the whole stack, so the device waits for its body. With no separation every device is body 0’s.
-
Each body finds its own apogee, whatever its devices are triggered by. The ascent ends at the separation, so this is the only place a staged flight can record a peak. Without it a body separated while climbing would never fire an apogee charge (found in review, now a test).
-
The bodies descend independently, each with the same point-mass equations as the descent phase, less the thrust:
They share the flight’s devices and their progress, so a canopy that opened before the separation stays open on whichever body carries it.
-
Bodies are not watched by the
Observer: their events and samples are in theirBodyFlight.
Limits:
- No push at a separation, and no tip-off. A separation’s charge or spring adds no impulse (an ejection’s can: see Ejected pieces), and the tumbling a tip-off would start is not modeled.
- A body must start above the ground, as a free flight must. The ground event is a falling crossing. So a body that started below the site would go on integrating underground until the flight’s time limit.
- Every body must carry a device, and it must open. The descent has no airframe drag (the descent-phase decision, ADR-012), so a body with nothing open would fall as if in a vacuum. A flight whose bodies are not all covered is refused when it is set up. A body that reaches the ground without a single deployment (a timer set after that body lands, say) is a flight-time error. It is an error rather than a landing at the speed of a fall with no drag. Both were found in review. A device on a body that nothing makes is refused when the flight starts, since an ejection given later could still make it.
- A body coasts with no drag at all until its first device opens. That is the same omission
as the descent phase’s, and it hurts more here. A 0.55 kg forward body separates at 2 km (1.2 mi)
and waits for a 300 m (984 ft) main. It arrives at 168 m/s (551 ft/s) where an airframe would
have held it near 60 to 70. So its deployment speed, and any opening load taken from it, read
high there. A part split off climbing whose device opens near the top of its drag-free climb
is the other way round. A part ejected climbing at 30 m/s (98 ft/s), its device 3 s later, opens
drag-free at (2 ft/s), just short of its top. If its
airframe’s drag is large for its mass (a light nose cone, not a heavy payload), it would have
topped out sooner and be falling by then, faster, so its opening speed and load read low. Give a
body a device that
opens at once (
DeviceDrag::tumbling_stagesover its own stages is the cited way) if the coast matters. After a powered separation the simulator requires it (Staging). A spent booster’s device is usuallyDeviceDrag::tumbling_stages(&assembly, its stages), which is §3.5’s model over that body’s own components rather than the whole stack’s. - The aft body’s motors must have burned out, because a body’s mass is held constant through its descent. A trigger that fires while one burns is an error, not a silent approximation. It is raised before the flight when its time is known, and in flight otherwise. A release across the separation is refused too: a line cuts a device on its own body. A forward body with a motor still to burn flies on as a sustainer (Staging).
Ejected pieces
An ejection lets a piece of the airframe go at a joint of your choosing, not only at a stage boundary. The piece can be a nose cone pushed off its airframe, a body section, or a payload carried inside. Each piece then comes down on its own, under its own parachute or tumbling, and lands somewhere of its own. The charge can push the pieces apart. This is new with M1.11a and M1.11b. It is checked against exact answers only: no other simulator or real flight has been compared with it yet.
A few words first:
- A body component is one of the parts the airframe is made of, nose to tail: the nose cone,
a body tube, a transition. An internal component sits inside one: a parachute, an
altimeter bay, a mass. Each has an
idin the design file. - A joint is where two body components meet.
- A piece is a part of the airframe that can come away: the part between two joints that can part, or a payload.
- A body is whatever flies as one: the pieces still joined together.
How you give one. An Ejection is a trigger and a place where the airframe parts. The
triggers are the same kinds a parachute has (apogee, a height, a time, a motor’s delay):
Ejection::aft_of(trigger, "nose")parts the airframe at the joint just aft of the body component with that id. The side toward the nose keeps its body number. The new piece is the side aft of the joint. It runs back to the next joint you have also given an ejection or a separation for, or to the tail. So ejecting a nose cone is written as parting the joint aft of it. The nose cone keeps body 0, and the airframe behind it becomes the new body.Ejection::payload(trigger, "payload")lets an internal component, and everything inside it, out of the piece that carries it. It must be inside the airframe, and not inside another payload.
Pieces tied together by a shock cord fly as one. So a nose cone on a shock cord is not an ejection at all. Leave it out, and the rocket comes down in one piece.
Which body is which. A body takes the number of the piece nearest the nose among those still joined, and a payload flying alone takes its own:
| What makes the piece | Its body number |
|---|---|
| The nose’s side of the airframe | 0 |
| A separation, if the flight has one: the stages aft of it | 1 |
| Each ejection, in the order you give them | 1, 2, … in order; after 1 if the flight has a separation (2, 3, …) |
Each body needs a device that names it (Device::on_body). A flight whose bodies are not all
covered is refused when you give the ejections. A device on a body that nothing makes is refused
when the flight starts, since a separation given later could still make it. run returns an
error naming that body.
When devices act. Only body 0’s devices act before the airframe first comes apart. After that, a device acts only once its own body flies on its own. So a parachute on the nose cone (body 0) triggered at apogee fires and opens in the same step as the nose cone leaves. It is logged in the flight’s own events, as the example below shows, and its drag acts on the nose cone alone from then on. A device on a piece that hasn’t left yet waits for it, even if its trigger has come. Give a piece a trigger that follows its ejection. Suppose a drogue is on the airframe and the nose cone is only ejected at 300 m (984 ft). The whole rocket would fall from apogee to 300 m (984 ft) with nothing open.
The flight’s apogee. The summary’s apogee is reached in one piece, by the whole rocket or,
after a separation, by the whole part that keeps the nose:
- An ejection at the rocket’s apogee, or after it, keeps that apogee.
- An ejection that parts the rocket while it still climbs leaves the summary with no apogee
(
None). From the charge on, body 0 is only what the charge leaves at the nose: the piece ahead of the parted joint (a nose cone pushed off is the nose cone alone), or the airframe without a payload it let out. The height that lighter body coasts to is not the rocket’s. - After a separation with nothing left to burn, the flight’s apogee
is the apogee of the part that keeps the nose (body 0). The same rule holds for that part: if it
lets a piece go before the part’s apogee, the summary has none. A test parts it 5 s after the
split, still climbing at over 30 m/s (98 ft/s). The nose cone then tops out more than 50 m
(164 ft) below where the whole part coasts to, and the summary gives no apogee
(
a_nose_cone_ejected_on_the_climb_after_a_split_leaves_the_summary_no_apogee). With the charge at the part’s apogee, or 3 s after it, the summary keeps the whole part’s apogee.
A body that climbs after its parting has its own apogee in its events (BodyFlight::event),
whatever the summary gives.
What happens at each parting:
- When the airframe first comes apart, each body starts at its own center of mass. Its velocity is the one that point had, (defined under Separation), as at a separation, plus the charge’s push below. The linear momenta add to the stack’s, which is a test.
- When a body parts again on the way down, it is already a point mass with no attitude. There is
nothing to place its pieces by. Both pieces start at the body’s position and velocity,
plus the push, and its mass steps down by the piece that left. Their true starting points could
be up to a rocket’s length apart, which is small against a descent of hundreds of meters. That
body’s event for the parting records its state just before (
BodyEvent::sample) and just after (BodyEvent::after): its lower mass, and its pushed velocity. - Each piece’s mass is its own components’. A stage that stays in one piece is counted by its own mass, overrides and all. A stage that parts is counted component by component. An override that doesn’t say how its mass divides is refused rather than guessed. That means a stage’s mass override, or a component’s override that covers what it holds. OpenRocket designs often override a stage’s mass, and such a stage can’t be parted. The pieces’ masses add to the rocket’s to 1e-12, which is a test.
- Every motor must have burned out by the time an ejection fires, because every body is a point mass of constant mass from then on. An ejection known to come earlier is refused when it is given, and one that fires early in flight is an error then.
The push of the charge. An ejection charge or spring pushes the two sides of the joint apart.
Give it as an impulse : the push summed over its short duration, in newton-seconds, as a
motor’s total impulse is. For example,
Ejection::aft_of(Trigger::Apogee, "nose").with_impulse(1.0). Without one there is no push. The
simulator doesn’t work out from a charge’s size. As a rough guide, for the speed
you expect a piece of mass to leave at. So 1 N·s puts 15.9 m/s (52 ft/s) on the example’s 63 g nose cone.
The push is equal and opposite:
-
The side forward of the joint gets toward the nose, and the side aft of it . A payload leaves forward, out of its host, as it does when the nose cone comes off first.
-
Each side’s velocity changes by , for its own mass , so the light side moves most. One newton-second is 4 m/s (13 ft/s) on a 250 g payload, and 1.8 m/s (5.9 ft/s) on the 556 g airframe it leaves.
-
The momenta still add up exactly, which is a test.
-
Which way is “toward the nose”? While the airframe flies whole with nothing open, it is its axis at that instant. A device that opens at the same instant as the parting doesn’t count as open yet. In every other case the body has no attitude to go by. A body flying on its own is a point mass. A whole airframe that has hung from a device since earlier has only the attitude it had when the device opened. So the simulator goes by the body’s velocity through the air:
- Take a device (any but a tumble) that was open just before that instant, deployed before it and not yet released. A body hanging from it points its forward end against that velocity (upward, as it falls), toward the device. The simulator assumes the device left through that end, as a main does once the nose cone is off. A payload let out under the airframe’s parachute is pushed up, toward it. For a drogue that left between the booster and the avionics bay, the airframe more likely hangs near level, and this direction is a guess.
- A body with nothing open, or only tumbling, points its nose along that velocity, as a stable rocket does.
- A body moving through the air at under 1 mm/s, at its own apogee in still air say, points up.
These are assumptions, not measurements (ADR-086) (evidence row G20). All the partings that fire on a body at one instant part it together. Each final body takes the pushes of the joints on its sides. So the order you list them in doesn’t matter.
-
A separation has no push. A payload always leaves forward. So a push on a payload in the nose’s own section, which is closed at the nose, is refused when the flight starts. A pushed payload whose section’s forward joint hasn’t parted by the time it leaves is an error in flight.
In the example below, every piece’s device opens as it leaves. There 1 N·s at each parting moves the airframe’s landing by 0.0 m (0.0 ft) and the payload’s by 1.3 m (4.3 ft). The drag takes the push away within seconds. A piece that coasts with nothing open keeps its push longer.
A piece that tumbles. A piece needs some drag of its own, or it falls as if in a vacuum. The
simulator can treat a nose cone with no parachute as tumbling; a real one may instead fall point
first, and faster. Simulation::tumbling_piece(0) gives the drag area of the nose cone tumbling on
its own, by the tumble model over just its own parts. Use it as that body’s device,
Device::new("nose cone tumble", tumble, Trigger::Apogee).on_body(0), triggered with its ejection,
as the example below does.
- Piece is the piece nearest the nose in body , numbered as in the table above.
- It is that piece’s own area. A body that still carries another section, until that section’s own parting, tumbles with its first piece’s area only.
A worked example. The example
ejected_pieces.rs
flies the 54 mm (2.1 in) test rocket on an I175 with a 250 g payload in its airframe. The wind is
4 m/s (13 ft/s) from the west. The nose cone leaves at apogee (16.23 s, 1,747 m (5,732 ft)) under a 0.45 m (1.5 ft) canopy. The airframe
comes down under a 0.9 m (3.0 ft) one. It lets the payload out at 300 m (984 ft) under a 0.6 m (2.0 ft) one. Each lands at
its own terminal speed, above, for its own mass and canopy in the air at the ground:
| Body | Mass (kg) | Flies on its own from (s) | Lands (s) | At (m/s) | speed (m/s) | East of the pad (m) |
|---|---|---|---|---|---|---|
| 0, the nose cone | 0.063 | 16.23 | 562.88 | 3.06 | 3.06 | 2,035.4 |
| 1, the airframe | 0.556 | 16.23 | 333.54 | 4.54 | 4.54 | 1,115.6 |
| 2, the payload | 0.250 | 268.05 | 333.14 | 4.57 | 4.57 | 1,114.0 |
The nose cone is light for its canopy, so it stays up 229 s longer and drifts 920 m (3,018 ft) further
downwind. The airframe’s body weighs 0.806 kg until the payload leaves, then 0.556 kg. The
flight’s own event list ends at the first parting. What happens to each body after that,
its canopy opening and the payload leaving the airframe, is in that body’s own list
(FlightResult::bodies).
The example then flies the same rocket again with a 1 N·s push at each parting. The nose cone has no canopy and tumbles:
| Body | Mass (kg) | Lands (s) | At (m/s) | speed (m/s) | East of the pad (m) | Moved from the first flight (m) |
|---|---|---|---|---|---|---|
| 0, the nose cone, tumbling | 0.063 | 130.93 | 14.82 | 14.82 | 269.6 | 1,765.7 |
| 1, the airframe | 0.556 | 333.42 | 4.54 | 4.54 | 1,115.6 | 0.0 |
| 2, the payload | 0.250 | 333.33 | 4.57 | 4.57 | 1,115.3 | 1.3 |
Tumbling, the nose cone comes down nearly five times as fast as under its canopy, and lands 1.8 km (1.1 mi) nearer the pad. The push barely moves the other two. At 300 m (984 ft) it changes the payload’s velocity by 4.00 m/s (13.1 ft/s), up toward the airframe’s parachute. It changes the airframe’s by 1.80 m/s (5.9 ft/s), down. That is for each. The example prints the upward parts, +4.00 and −1.80 m/s (−5.9 ft/s). Within seconds the drag has taken that away.
Limits:
- A piece coasts with no drag until its device opens, as every separated body does. Give it a parachute, or its tumble from the moment it leaves.
- The push’s direction is assumed whenever the airframe isn’t flying whole with nothing open (evidence row G20). It goes by the velocity through the air, as above. A payload always leaves forward.
- No powered separation with ejections. A sustainer flies on a design cut at its stage boundary, whose components aren’t the pieces the ejections were given for. So it is refused, and so is an ejection ahead of a separation that would light a motor.
- A piece’s spin and attitude are not tracked, as for a separated body.
- A
.orkfile’s recovery settings don’t make ejections, and HPR Sim has no names for pieces: you find the component ids in the design file.
The decision records on ejected pieces, ADR-085, and on the push and tumbling pieces, ADR-086, have the reasoning.
OpenRocket files and tests
How a .ork file’s recovery is read and flown, and the tests and comparisons that check it.
From an OpenRocket file
A .ork file’s parachutes and streamers fly as OpenRocket flies them. They land at OpenRocket’s
speed to within 0.021% on 50 of its 53 example flights, and within 0.12% on all 53. The function
hpr::ork::recovery turns each parachute and streamer of the
configuration flown into one of the devices above. hpr sim flies a
.ork file’s devices through it. The model is OpenRocket’s, not Knacke’s, as the file’s author
chose it. This is a check against another program only: no descent from a .ork has been
compared with a real flight. The decision record on flying a .ork’s recovery,
ADR-153, has the reasoning and the targets.
How each device flies:
- Drag. A parachute’s drag area is , with the canopy diameter and the
file’s value, or 0.8 when the file says
auto. That default comes from OpenRocket’s technical documentation (v13.05, section 4.2.5), which cites Hoerner’s Fluid-Dynamic Drag (1965). A streamer’s is the stated on its length times its width, or forautoOpenRocket’s own estimate (which streamer model is right). - Opening. Each device opens fully at once, the file’s delay after its event, with no filling time.
- Events.
apogeeopens at apogee.altitudeopens the first time, on the way down, that the center of mass is at or below the stated height above the ground.ejectionopens at the ejection delay of the first motor that lights in the device’s own stage.launchopens the delay after launch. - The descent. Once a device opens, the rocket is a point mass under the open devices’ drag alone, the airframe’s left out (The descent). That is OpenRocket’s own model: “the entire drag coefficient of the rocket is assumed to come from the deployed recovery devices” (section 4.2.5).
A worked example. A parachute 0.6 m (2.0 ft) across, with set to auto, has a canopy of
, and a drag area of . hpr sim prints it as
recovery: `Main` at apogee, 0.226 m² of drag area, then when it opened.
Some devices never open, and some are refused:
- No device. A device set to
never, or toejectionon a plugged motor or one with no delay given, gives no device.hpr simnotes “Mainnever opens”, with why. - No motor lights in its stage. A device set to
ejectionopens at its own stage’s charge (OpenRocket labels the setting “First ejection charge of this stage”). In a stage where no motor lights, it never opens, as in OpenRocket 24.12. The probe showed that a charge from another stage never opens it, whether the stages are joined or apart. Neither does a stage with no motor, a motor that never lights, or a plugged one.hpr simnotes “Mainnever opens: it opens at its stage’s ejection charge, and no motor of its stage lights”, and flies the other devices. Until M4.5i, HPR Sim refused the configuration’s whole recovery for it (ADR-168). - Refused by name. A device inside a part HPR Sim doesn’t read, and one set to open by a word
HPR Sim doesn’t know. One set
to open at
lowerstageseparationopens at the split right behind its stage when that split comes with nothing left to burn (Staging). It is refused otherwise. The flight then falls on its airframe alone, with the reason in its notes. - A height above the apogee. HPR Sim opens such a device at apogee, as an altimeter below its
main’s height at apogee would fire. OpenRocket’s one probed run never opened it
(what the words mean).
hpr simnotes when this happens. - The height’s zero. HPR Sim counts a height from the ground. OpenRocket counts it from where the center of mass starts on the pad. So HPR Sim opens a device set to a height that much lower.
How close it is. cargo xtask ork-flights flies each configuration of OpenRocket’s examples
that HPR Sim flies a second time, with its devices. It compares the result with OpenRocket 24.12’s own
flight (the report’s descents). The targets were set before measuring. Each
deployment is to be within 0.1 s or 2% of OpenRocket’s time, whichever is larger. The landing speed
and the flight time are to be within 5%. All 53 descents are compared. On the 7 configurations that
drop stages under power, it is the sustainer’s descent. On the 6 that drop a payload with nothing
left to burn, it is the payload’s. In each, it is the branch OpenRocket’s record keeps
(Separation).
- 48 flights: the report’s 51 with no named cause for an apogee gap, less the Base drag hack’s three (below). The landing speed is +0.00% to +0.02% off OpenRocket’s, and the flight time −1.57% to +3.16% (0.68% on average, either way). Among them are two of Pods--powered with recovery deployment. On its booster’s flight, the two pods’ parachutes open at launch + 5.35 s in both programs, and the flight time is −1.02% off.
- 40 of those 48 meet every target as written. The other 8 miss only on a deployment’s time. All 8 reach an apogee 0.63% to 4.34% below OpenRocket’s, a climb gap the same report shows. And OpenRocket opens a device set to a height at the end of its time step. That is 0.06 to 12.64 m (0.20 to 41.5 ft) below that height over the 15 such deployments. It is 0.36 to 11.15 m (1.2 to 36.6 ft) on the 8 that miss. With those two taken out, every deployment is within its target; the largest left is 0.33 s. That is what “met once sized” means in the report: each deployment that misses is held instead by what is left of it. For a device opened at apogee this holds by construction, as it takes out the apogee’s own time. The evidence on the descent itself is the landing speed. On the dual-deploy flights it is also the drogue’s speed as the main opens, within 0.07% on 5 of 6.
- The Base drag hack’s three flights have no named cause either, but read high in apogee (a part set to no drag). They land 0.11% to 0.12% faster than OpenRocket, and their flight times are +1.72% to +7.07% off; the last misses its target.
- 2 flights with a named cause for an apogee gap. One is put down to HPR Sim’s tube-fin drag.
In the other,
[C6-7; B6-0]of Pods--powered with recovery deployment, the sustainer turns over before apogee in both programs. Both land at OpenRocket’s speed (+0.00%), but their flight times are −52.64% and +5.78% off. - The private designs. On 34 descents, published only as differences (report), the landing speed is −1.53% to +0.04% off OpenRocket’s and the flight time −4.98% to +3.72%. 31 of 34 meet every target as written. All 34 do once each deployment that misses is held by what is left of it. That sizing rests on numbers the private report does not publish. The −1.53% landing speed is not explained.
A stage that drops away under power. Each device rides
the part its stage is in (hpr::ork::separated_recovery),
and each event is that part’s own: apogee is the part’s own apogee. After the split each part
is a point with no airframe drag (Separation), so a part needs a device from the
split. The booster tumbles from the split until its first own device in file order
opens, which releases the tumble (hpr::ork::tumbling). A
sustainer with no device of its own tumbles from its apogee. hpr sim flies it this way
(Separation). On the Two stage high power rocket’s two configurations,
the sustainer’s landing speed is +0.00% off OpenRocket’s and its flight time +0.32% and +0.73%.
On the first, the H148R-0 and H148R-0 configuration, the main opens 1.09 s before OpenRocket’s,
past its target. Its apogee is 1.79% lower and OpenRocket opens it 8.9 m (29 ft) below its set height.
With both taken out, as How close it is above does, 0.065 s is left
(ADR-159, powered separation in hpr sim).
What it leaves out. The booster’s own descent is not validated
(evidence row G13): OpenRocket flies it as a rigid
body, and its record keeps only the sustainer’s branch. A tumbling booster falls side-on from the
split, where a real one flies nose-first for a while. So its peak and landing are likely too low
and too close to the pad (#179). hpr sim
flies a configuration whose separation can only come after apogee as one stack, with a note.
Several separations under power fly, one after another
(M4.5g2, several separations). A payload dropped with
nothing left to burn flies when its own device opens at the split
(M4.5g3, a payload’s split).
Verification
crates/hpr-sim/src/recovery.rs’s tests, all analytic (checked against exact answers) unless they
name the oracle:
| What | Result |
|---|---|
| Knacke’s against a case from Loft, this project’s predecessor (1.1 kg, 1 m (3.3 ft) flat canopy, 0.8, 1.225) | 5.294 m/s (17.37 ft/s), as Loft printed |
| A descent from rest against the closed-form fall under quadratic drag (2 km (1.2 mi), uniform air, constant gravity) | 2.1e-8 of the terminal speed over the whole descent; the landing time within 1e-5 s of the closed form’s 204 s |
| Drift in a steady wind, entered drifting with the air, no Earth rotation | exactly the wind times the time of flight (1e-8); the fall itself within 1e-4 of the closed form |
| The Coriolis drift of a 3 km (1.9 mi) descent, Earth rotation on | 0.3666 m (1.203 ft) east against the steady prediction = 0.3685 m, 0.52% apart, and 29 µm north |
| Knacke’s filling law, and | the recorded drag area to 1e-9 of |
| Inflation against instant opening (deployed at 60 m/s (197 ft/s) under a 1.5 m (4.9 ft) flat circular canopy) | peak load 1,615 N against 3,020 N instant (0.53 of it), between the closed-form 1,527 N without gravity and 1,670 N with it |
| An oversized canopy (5 m (16 ft)) opening at 100 m/s (328 ft/s), 10 km (6.2 mi) of descent at 2.95 m/s (9.7 ft/s) | lands in 3,392 s in 6,914 accepted steps and 2 rejected (a mean step of 0.49 s, where Loft’s explicit RK4 needed a 2e-4 s floor) |
| A deployment with a 0.7 rad/s body rate, and another inside the burn in a crosswind | the center of mass keeps its velocity across the handover to 1e-12, and the nose tip’s moves by exactly , turned into the launch frame |
| A whole flight: drogue at apogee with a lag, main at 300 m (984 ft), drogue released | events in order; each stage settles within 2% of its own |
| Two devices triggered at the same instant | both open in the same pass, and the descent settles at the of the sum of their drag areas |
| A device released before its own charge fires | it is recorded as triggered and never deploys; the descent stays at the open device’s |
| A drogue released by a main that fills over 2 s | the release waits for the end of filling, the drag area never falls below the drogue’s, and the descent never speeds up |
| An apogee charge on a flight that starts descending | it fires at the first step (there is no apogee event to find), and a climbing start still waits for the apogee |
| Two user events and an altitude device on one flight | the user events keep their numbers and fire during the descent, in height order |
| The same recovered flight flown twice | bit-identical rows, events, final sample and step counts (Loft lesson L24: a run does not mutate the simulation) |
| A separation at apogee of the two-stage test design, canopy on the sustainer and tumble on the booster | both bodies land: the 0.550 kg sustainer at 729.0 s and 2.11 m/s (6.9 ft/s) under its 1.8 m (5.9 ft) canopy, the 1.125 kg booster at 107.5 s and 16.74 m/s (54.9 ft/s) tumbling; the masses add to the 1.675 kg stack to 1e-12 and each lands within 0.1% of its own |
| The linear momenta of the bodies at a separation with a 0.6 rad/s body rate | add to the stack’s to 1e-9, and each body starts at its own center of mass to 1e-12 (0.817 m (2.68 ft) apart on this design) |
| A separation while the booster’s motor burns | refused in flight, with the booster’s burnout time in the error |
| A separation while still climbing at 100 m/s (328 ft/s) | both bodies find their own apogee above 1,400 m (4,593 ft), fire there, and land within 1% of their own |
| A timed separation, and a height separation | fire at their own time to 1e-9 s and at their own height to 1e-6 m, rather than at the next boundary that happens to exist (found in review: one fired 186 s late, another never) |
| A body that runs out of time | says TimeCap in its own BodyFlight; FlightResult::bodies_landed is false and landings() is short |
| A body whose device never fires (a timer set after it lands) | refused in flight, naming the body, rather than landed at the speed of a fall with no drag |
| A body whose canopy opened on the stack just before the separation (an apogee separation with an apogee parachute) | lands: the open canopy counts, though its deployment is in the flight’s events, not the body’s (found with M1.9a) |
| A timed separation known to precede the booster’s burnout | refused when the separation is given; a height one that a climbing rocket passes early is refused in flight |
The ejected pieces’ tests are in crates/hpr-sim/src/pieces.rs, also analytic:
| What | Result |
|---|---|
| The nose cone at apogee and a 250 g payload at 300 m (984 ft), from the pad in a 4 m/s (13 ft/s) wind, in uniform sea-level air (not the example’s atmosphere, so its numbers differ) | all three land, each under its own canopy; the payload leaves at 300 m (984 ft) to 1e-6 m; landings pinned (the nose cone 911.6 m (2,991 ft) further downwind than the airframe, 4 m/s (13 ft/s) times its 227.5 s longer descent to 1%) |
| The masses at each parting, with wind and a 0.6 rad/s body rate | the two bodies at the first parting, and the three pieces, add to the rocket’s mass to 1e-12; the nose cone and the payload are their own components’ masses to 1e-12 |
| The linear momenta at each parting | at the first, from the rigid stack, they add to the stack’s to 1e-9, and the nose cone starts at its own center of mass to 1e-12; at the second, on the way down, they add up by construction (one shared velocity), so only the masses test anything there |
| Each piece’s landing in uniform air | within 0.1% of its own , the airframe’s at its mass after the payload left |
| An ejection with a separation (the two-stage test design, both at apogee) | the booster is body 1 and the airframe body 2; the booster’s mass is its stage’s and motor’s, and the three add to the stack’s, to 1e-12 |
| A payload whose trigger comes after the landing | never leaves: its airframe lands with both pieces, and the two bodies add to the rocket’s mass |
| Two partings firing in one pass on the way down (the two-stage design, three joints), given in either order | each piece counted once: the four bodies add to the stack’s mass to 1e-12, and the nose cone and the interstage are their own components (found in review: the interstage was counted twice, 1.7651 kg landed from 1.6752 kg) |
| An airframe whose own mass is overridden, but not what it holds | still divides: the payload is its own mass, and the pieces add to the rocket’s, to 1e-12 |
| A powered separation with ejections, an ejection ahead of a separation that lights a motor, an ejection timed from a motor with no ignition | each refused with its own reason |
| Partings the design can’t make: an unknown id, a joint aft of an internal part or of the tail, a body component or an external part as a payload, a payload inside another, two at one joint, one payload twice, an overridden stage or covering override | each refused with its own reason, naming the component |
| An ejection during the burn, a height below the ground, a body without a device, a device on a body nothing makes | refused, the last when the flight starts |
| A 1 N·s push at both partings, from a stack tilted 60° up toward 30° east of north, in wind, moving sideways and turning at 0.6 rad/s | each body’s velocity changes by to 1e-9 against the same flight unpushed. At the first parting that is along the hand-computed rail axis, 15.9 m/s (52 ft/s) on the nose cone. At the second, the airframe under its canopy, it is 4 m/s (13 ft/s) on the 250 g payload, against its velocity through the air. The momenta add up to 1e-9 at both, and every piece still lands within 0.1% of its |
| The same push at 300 m (984 ft) with the airframe’s canopy not yet open | the payload is pushed down its velocity through the air, 4 m/s (13 ft/s), and the airframe the other way, to 1e-9 |
| A nose cone pushed off at 300 m (984 ft) from a stack that has hung from a drogue since apogee | pushed against its velocity through the air to 1e-9, not along the attitude frozen at apogee (found in review: it went along the frozen axis) |
| A push at a body’s own apogee, climbing straight up in still air with nothing open | straight up, 4 m/s (13 ft/s) on the payload, to 1e-9, where along its flight would point down |
| A separation and a pushed nose cone at apogee (the two-stage design) | the booster, the separation’s body, gets no push; the nose cone and the sustainer’s airframe get along the axis to 1e-9; the momenta add up to 1e-9 |
| Two pushed partings at one instant on the way down (the two-stage design), given in either order | by hand, the nose cone , the airframe between the joints 0, the interstage , each to 1e-9; the momenta add up to 1e-9, and the landings agree between the orders to 1e-6 m (found in review: taken one at a time, the order moved the nose cone’s push from 15.85 to 17.66 m/s (52.0 to 57.9 ft/s)) |
| The airframe’s canopy opening at the same instant as the payload leaves | not yet hung from: the payload is pushed down its flight, 4 m/s (13 ft/s), whether the canopy opens at once or fills over a second (found in review: the push flipped with the inflation law) |
| A pushed payload let out at apogee while its section’s forward joint waits for 300 m (984 ft) | an error in flight, at the ejection’s time |
| A stack with only a tumble since apogee, the nose cone pushed off at 300 m (984 ft) | along its velocity through the air, to 1e-9: a tumble is nothing to hang from |
| A drogue since apogee released by a main that opens at 300 m (984 ft) as the nose cone leaves | still hung from: against the velocity through the air, to 1e-9, whether the main opens at once or fills over a second (found in review: the push flipped with the law) |
| One charge pushing off the nose cone and letting the payload out, both at apogee | by hand, along the axis: nose cone +1 N·s, payload +1 N·s, airframe between them −2 N·s, each over its own mass to 1e-9 |
| A pushed payload in the booster, behind a separation, with the builders in either order | accepted both ways, and every piece lands; without the separation it is in the nose’s piece and refused at the start, and so is one in the sustainer’s airframe with it |
| A drogue since apogee cut away at 600 m (1,969 ft) by a tumble, the nose cone pushed off at 300 m (984 ft) | hung from nothing by then: along the velocity through the air, to 1e-9 |
| A parting on the way down with no push | the body after it has the same point and velocity, and its mass without the piece; only partings record a body after |
| A nose cone tumbling on its own after apogee, in uniform sea-level air | its drag area is 0.56 times its tangent ogive’s closed-form side area, to 1e-12; it lands at 13.849 m/s (45.44 ft/s), its model’s to 1e-6 (the example’s 14.82 m/s (48.6 ft/s) is in its own, thinner air at 1,400 m (4,593 ft)) |
| The tumbling drag areas of an airframe cut into a nose cone and the rest | add to the whole airframe’s to 1e-12; a payload or a piece not made is refused |
| A push that is negative, NaN or infinite | refused when the ejections are given; one on a payload in the nose’s own section when the flight starts |
Against RocketPy
HPR Sim’s descent is compared with RocketPy’s for five of RocketPy’s example rockets, a code-to-code comparison. Every compared number agrees within 3%, and most within 0.1% (22 of the 30 in the validation report). The largest gaps, in order:
- NDRT 2020’s north drift: +2.86%. HPR Sim carries it 50.8 m (167 ft) south, 2.86% further than RocketPy does. NDRT’s main has a drag area of 16 m². RocketPy’s added mass, which HPR Sim leaves out, is the likely cause. No test has isolated it yet.
- Valetudo’s north drift: −1.77%. That drift is 19 µm, from the Earth’s rotation alone, so a tiny difference is a large fraction (its own section below).
- Valetudo’s whole drift: −0.89%, of 0.19 m (0.62 ft), also from the Earth’s rotation alone.
- NDRT 2020’s descent time: +0.71% longer in HPR Sim, likely the same added mass.
How the comparison is run:
validation/oracles/rocketpy/recovery.pyflies RocketPy’s own parachute phase for the five rockets and writes what it computes tovalidation/fixtures/recovery/rocketpy-descent.json. The testdescent_matches_rocketpy_examplesreplays each case in HPR Sim.- Both codes start from the same declared state after burnout, near apogee. The first device opens at once. Its lag is overridden to zero, so no ballistic stretch, flown under each code’s own rocket aerodynamics, comes between them.
- Both get the same , the same deployment settings and the same wind. RocketPy’s random noise on each parachute is set to zero, and HPR Sim flies RocketPy’s formula for gravity (see Gravity below).
- The test checks that the two environments agree first, then compares the descents.
- The oracle runs at
rtol = atol = 1e-8: its relative and absolute tolerances, how much error each step may make, both 1e-8 (scientific notation for 0.00000001). Run again at 1e-6, it moves every compared metric by at most 3.5e-6 relative (the fixture’ssolver.relative_change_from_loose), far below the gaps. The one larger entry, 2.1e-3, is Valetudo’s north drift of 19 µm, which has its own section below.
The results. Measured (HPR Sim against RocketPy, September 17, 2026):
| case | descent time | descent rate under the drogue | impact descent rate | drift | worst drift component |
|---|---|---|---|---|---|
| Calisto (drogue 1.0 m², main 10 m² at 800 m (2,625 ft), wind 5 E / 2 N) | +0.08% (257.27 s) | −0.01% (17.967 m/s (58.95 ft/s)) | −0.03% (5.454 m/s (17.89 ft/s)) | +0.08% (1,386.0 m (4,547 ft)) | +0.08% |
| Valetudo (drogue 0.4537 m², no wind) | −0.02% (45.76 s) | n/a | +0.00% (17.627 m/s (57.83 ft/s)) | −0.89% (0.19 m (0.62 ft), Coriolis only) | −1.77% (north, 19 µm; +2704% under HPR Sim’s own gravity, issue #27) |
| NDRT 2020 (drogue 0.438 m², main 16.05 m² at 167.6 m (550 ft), sheared wind) | +0.71% (61.60 s) | +0.01% (28.156 m/s (92.38 ft/s)) | +0.01% (4.604 m/s (15.10 ft/s)) | +0.28% (327.9 m (1,076 ft)) | +2.86% (north, −50.8 m (−167 ft)) |
| Prometheus 2022 (drogue 0.467 m², main 5.78 m² at 457.2 m (1,500 ft)) | +0.08% (153.50 s) | −0.01% (26.400 m/s (86.61 ft/s)) | −0.03% (7.323 m/s (24.03 ft/s)) | +0.08% (1,237.1 m (4,059 ft)) | +0.09% |
| Juno III (drogue 0.885 m²) | −0.02% (53.56 s) | n/a | −0.01% (22.431 m/s (73.59 ft/s)) | −0.02% (457.9 m (1,502 ft)) | −0.02% |
- Every metric is inside the 3% that the parachute milestone (M1.7a) set. The descent rate under the drogue, where a case has a main, agrees to 0.01%.
- The later devices’ trigger heights agree to −0.01%, −0.17% and −0.01%. RocketPy’s trigger sampling (below) accounts for them.
- Both simulators land within 1% of Knacke’s for the device that is open, computed from HPR Sim’s own air and gravity at the site.
- These numbers use RocketPy’s gravity and wind interpolation, not HPR Sim’s defaults.
- Gravity: the comparison has flown RocketPy’s gravity model since issue #27. Under HPR Sim’s own gravity the drifting cases read a little closer (Calisto +0.06% rather than +0.08%). That was measured once when the comparison switched, and no test pins it. The drifting cases read closer because the vertical’s turn downrange pushes the rocket back toward the pad and cancels part of a real difference. The like-for-like number is the honest one.
- Wind: here both codes interpolate the wind by its east and north components, as RocketPy does. For a table of wind levels, HPR Sim’s default is to interpolate speed and direction instead (Wind). Only NDRT 2020’s wind changes with height; the other four cases have one wind at every height, where the two ways agree. What HPR Sim’s default would do to NDRT’s drift has not been measured.
What still differs between the two codes:
- Added mass. HPR Sim has none. RocketPy’s carries no weight, so it changes no steady descent
rate, only the response just after an opening. It is most likely the largest difference.
- RocketPy’s added mass for NDRT’s main is 15.9 kg, against the rocket’s 20.8 kg, so its response to the opening is slower.
- That most likely lengthens the descent (+0.71%) and, in a wind that shears with height, moves the smaller drift component by 2.86%.
- A cited apparent-mass model would show whether it closes that gap.
- When a trigger fires. RocketPy checks its triggers on a grid of
1/sampling_rate(100 or 105 Hz), anchored at . It checks only over the span after its first accepted step. HPR Sim has no sampling rate: its event finder locates the crossing.- So RocketPy’s first deployment is 2.5 ms late in the four 105 Hz cases, and 13 ms late in Prometheus’s.
- Its test, height below the setting (), can fire only at or below the setting. The overshoot is at most one sample of fall, the descent speed over the sampling rate (). That is 0.17 m (0.56 ft) for Calisto and 0.27 m (0.89 ft) for NDRT (about 0.01 s of descent).
- The fixture records the heights at those triggers: 800.07 m (2,624.9 ft), 167.93 m (551.0 ft), 457.26 m (1,500.2 ft). They come from the spline RocketPy fits through its stored samples for reporting, not from the continuous solution between steps that its trigger read. So they sit just above the setting instead.
- The table compares HPR Sim’s trigger heights with those reported values, the closest the fixture can come. The difference is the same size either way.
- Release against replacement. HPR Sim sums its open devices, and releases the drogue when the main is full; RocketPy holds one and replaces it. For these cases, whose canopies open instantly, the two are the same.
- Wind: no difference. Both codes interpolate the declared wind by its east and north components. The test holds HPR Sim’s to RocketPy’s samples within 1e-9 m/s in each, NDRT’s sheared profile included.
- Atmosphere. HPR Sim evaluates the 1976 standard atmosphere; RocketPy interpolates a 100-point pressure table over 0 to 80 km (0.0 to 50 mi). Over the fixture’s 23 samples they differ by at most 3.7e-4 in density, which the test gates at 5e-4.
- Gravity: the same size, a different direction. RocketPy’s “Somigliana” formula is
WGS 84 normal gravity, and HPR Sim’s
agrees with the fixture’s samples to 1e-8 (the worst of 23 is 4.7e-9 relative). The two point it
differently, and for a long time this page compared only the size.
- RocketPy applies gravity to the vertical axis alone (
Flight.u_dot_parachute,flight.py:2777, where onlyazcarries a gravity term). - HPR Sim’s default,
GravityModel::Ellipsoidal, uses the full normal-gravity vector. Above the ellipsoid it tilts slightly toward the equator (Gravity), in proportion to height above the ellipsoid. That is 4.0e-6 m/s² sideways at Valetudo’s site at ground level, and 8.7e-6 m/s² at 1,468 m (4,816 ft), where Valetudo’s descent starts. - Over the fixture’s 23 gravity samples the tilt runs from +6.9e-6 m/s² (north) at Valetudo’s top sample, 1,168 m (3,832 ft). It reaches −3.3e-5 m/s² (south) at Calisto’s 4,400 m (14,436 ft).
- HPR Sim’s vector also turns with the local vertical downrange, by . Here is the distance drifted and the Earth’s radius. That is 2.1e-3 m/s² at Calisto’s 1.4 km (0.87 mi) of drift, about 60 times the largest tilt. Over Valetudo’s 0.19 m (0.62 ft) it is about 3e-7 m/s², so there the tilt is the larger.
- The parachute milestone’s test (M1.7a) used to compare
gravity by its size alone, so it could see neither. This comparison and the validation suite
now both fly
GravityModel::VerticalTaylor. HPR Sim ships it as RocketPy’s own formula for like-for-like comparisons. Both check the gravity vector, not its length.
- RocketPy applies gravity to the vertical axis alone (
- Geometry. HPR Sim flies over the curved ellipsoid and measures heights along its perpendicular (ellipsoidal height); RocketPy’s height is measured in a flat frame. Over Calisto’s 1.4 km (0.87 mi) of drift the curvature is 0.15 m (0.49 ft) of height, 0.03 s of descent.
Valetudo’s north drift
This tiny number is worth its own section, because it is the one that found the gravity difference above.
- What to expect. In still air, Valetudo’s north drift comes from the Coriolis acceleration alone. The falling rocket picks up a small eastward velocity from it. The same acceleration acting on that eastward motion pushes it slightly north (Valetudo’s site is in the southern hemisphere). The horizontal velocity relaxes to a drag balance in about , with the terminal speed. So , with the vertical part of the Earth’s rotation. That integrates to 2.0e-5 m over the descent. RocketPy gives 1.9653e-5 m.
- What HPR Sim gave at first. The parachute milestone (M1.7a) didn’t compare this component; the validation harness (M2.1a) does. When it first did, HPR Sim read 28 times RocketPy’s: 5.51e-4 m (0.55 mm (0.022 in)), under HPR Sim’s default gravity. The tilt of that gravity, integrated down the 800 m (2,625 ft) of descent, = 5.2e-4 m. That accounts for the difference to within a few percent (issue #27).
- What it gives now. Flown against RocketPy’s own gravity formula, as the validation suite
does, HPR Sim gives 1.93e-5 m, −1.8% (validation report). Both codes carry the same
Coriolis term (HPR Sim in
dynamics.rs; RocketPy inflight.py:2779-2783). On this evidence neither is wrong: they were being asked different questions.
Staging
Learn how HPR Sim lights each motor at its own time, drops a booster under power, and flies each part to its own landing.
In short
- What it models: motors that light at their own times, and a rocket that drops its booster under power, or several stages in turn. A motor can light at launch, at a time, a delay after another motor burns out, a delay after its stage is freed, or never. The stack can come apart (separation) with the forward part still to burn. That part (the sustainer) flies on with its own shape and mass. The aft part (the booster) falls back to its own landing.
- Sources: no new physics. The flight is the same rigid-body flight (Rigid-body flight). The masses are the same sums (The design tree). The booster’s descent is the same descent under a recovery device (Recovery). What is new is when each motor burns, and which rocket is flying.
- How well it is validated: against OpenRocket, not against a real flight. OpenRocket’s
two-stage, three-stage, cluster and air-start examples are read from their
.orkfiles. They all fly within 5% of OpenRocket’s apogee and largest speed, on OpenRocket’s own curves. Five apogees are compared with OpenRocket’s flight with no parachute, since its parachute opened before apogee (Against OpenRocket).hpr sim, on the curves it fetches, flies the three-stage example within 5% too. A payload dropped with nothing left to burn flies under its own parachute from the split. On OpenRocket’s two payload examples, its apogee is within 1.1% of OpenRocket’s (A dropped payload). Boosters strapped beside the core burn with it and drop at their own separation. OpenRocket’s Parallel booster staging flies within 1.23% of its apogee (Boosters beside the core). Tests pin the bookkeeping. Ignition times hold to 1e-12 s, and the mass step at the split to 1e-12 of the mass. While the sustainer is not yet burning, the two parts’ momenta hold to 1e-9 of the stack’s. The flight of a dropped booster or middle stage after its split is not validated at all (evidence row G13). - What it leaves out:
- The booster’s own airframe drag. After the split the booster is a point: a mass with only its recovery device’s drag. So the simulator requires a device on it that opens at the separation, usually tumbling, and refuses the flight otherwise. It tumbles the booster side-on from the instant it separates. A real finned booster flies nose-first for a while first. So the modeled booster slows far faster than a real one would. Treat the booster’s peak and landing point as rough. They are likely too low and too close to the pad (#179, a model of the booster’s own drag).
- Any push from the separation (no charge or spring), the air flowing between the parts as they part, and the booster’s orientation as it falls.
- A drag or normal-force table from another program (
Simulation::with_drag_table), or a drag model of your own (Models of your own). Either describes the whole stack, so a powered separation under one is refused. - With more than one separation, one that leaves nothing ahead of it to burn, such as a payload released after the stages (Several separations).
- The thrust a booster dropped still burning had left. A
.orkstage’s first burnout can drop the stage’s other motors while they burn, as OpenRocket does. The dropped part flies with no thrust, so its flight leaves out the impulse they had left, whichhpr simstates (Dropped still burning).
Using it today
Staging is set in a JSON design file or in code, or read from a .ork file. hpr sim flies a
.ork file’s powered separation, each parachute and streamer on its own part
(Separation; M4.5g1, powered
separation in hpr sim). It flies several powered separations in turn
(Several separations). It also flies a payload dropped with nothing left
to burn, when its own device opens at the split
(Dropped payload). It flies the stack whole when the
separation can only come after apogee. To fly a
.ork file’s staging from a program, start from the example
ork_two_stage.rs,
and see how such flights compare with OpenRocket’s in Against OpenRocket.
For a design of your own, start from the two-stage design
synthetic-two-stage-75mm-54mm.json
and the worked example below. The decision record is ADR-074.
Ignition and separation
How motors light and a stage drops away, with a worked example.
When a motor lights
Each motor in a configuration has an ignition
(Ignition). The flight’s clock starts at launch (). Each motor burns on its own
clock from its ignition, so its thrust curve and its mass are its own curve shifted to that time.
ignition | lights at | example in a design file |
|---|---|---|
launch (the default) | nothing written | |
time | a time after launch | "ignition": {"time": {"time_s": 4.0}} |
burnout | a delay after the motor in another mount burns out | "ignition": {"burnout": {"mount": "booster-motor-mount", "delay_s": 1.0}} |
separation | a delay after the separation that drops the stages behind this motor’s stage | "ignition": {"separation": {"delay_s": 0.5}} |
never | never: it rides loaded, as a motor that fails to light does | "ignition": "never" |
A design that says nothing lights every motor on the pad, the sustainer’s too, and the simulator
does not warn. For a staged flight, give the sustainer’s motor its ignition and the flight a
Separation.
Before a motor lights it is loaded: its full propellant mass sits in the rocket, and it gives
no thrust. A motor that never lights is carried loaded to the ground. That happens when it is set
never, or when the burnout or separation it waits for never comes. Every ignition time known
before the flight is a stop time. So is every point of each shifted
thrust curve. The integrator ends a step at a stop time, so no step starts a burn half way through
(Time integration). An ignition that waits on a
separation becomes a stop time when the separation fires. The design refuses:
- a burnout of a mount with no motor, or a chain of burnouts that comes back to the motor itself;
- a separation ignition in the aft-most stage, which has nothing aft of it to separate;
- a time or delay that is negative or not a number.
Powered separation
A separation has a trigger and a stage boundary (Recovery). It
fires at apogee, at a height on the way down, at a time, or at a motor’s ejection
delay. Now it can also fire a delay after a motor’s burnout
(Trigger::Burnout).
When it fires, the simulator looks at the forward part, body 0, which keeps the nose:
- If it still has a motor to burn, it is a sustainer. That covers a motor burning now, one due to light at a known time, and one lit by this separation. The sustainer flies on in six degrees of freedom, and the booster (body 1) descends under its own device.
- If it has nothing to burn, both parts descend under their devices, as before.
What the simulator refuses:
- A booster still burning. Its motors must have burned out, unless the separation is told it
may drop one (Dropped still burning). If the
separation’s time is known before the flight, building the
Simulationreturns the error. Otherwiserunreturns it when the separation fires, with no flight result. - A booster with nothing open at the split (see What it leaves out, above). A device on the
booster with
Trigger::Time { time_s: 0.0 }and no lag opens there, because a booster’s devices act only once it flies on its own. - A separation that could never fire, such as one timed from the burnout of the sustainer it lights.
Why the state carries straight across. The simulator’s flight state is the motion of the nose tip, not of the center of mass (Rigid-body flight). The sustainer keeps the nose, so the nose tip’s position, velocity, attitude and rotation rate are all still right for it. What changes is the rocket they belong to:
- Mass. The mass drops by exactly the booster’s: its stages plus its spent motors. The center of mass and the inertia are the sustainer’s own stages and motors.
- Aerodynamics. The simulator builds the sustainer’s aerodynamics from the design cut after the
stage boundary: the design with the booster’s stages removed. It is an ordinary rocket with a
nose and its own aft end, so its drag includes its own base. Its
reference area can be smaller than the stack’s, since the widest
body may have been the booster’s. So a recorded coefficient such as
Sample::axial_coefficientsteps at the split even where the force doesn’t.
The integrator restarts at the separation, because the mass steps there.
Momentum. Nothing pushes the parts apart. Write for a mass, for the velocity of a center of mass, and , for the sustainer and the booster. The sustainer keeps the nose tip’s velocity and rotation . The booster leaves with the velocity its own center of mass already had, , where runs from the nose tip to that center. So the two momenta add up to the stack’s, . A test checks this to 1e-9 of the stack’s momentum on a flight launched 10° off vertical, whose sustainer is not yet lit. With the sustainer burning, is not simply additive: the center of mass also moves inside the body as propellant burns. So the simulator makes no claim for that case.
Events. Along with the separation, the flight records an Ignition event for each motor lit
after launch. Burnout is recorded when no motor is burning or due to light at a known time. In
the example below that is 5.23 s only: the booster burned out at 1.73 s, but the sustainer was
already due. With a sustainer lit by its separation, whose time isn’t known in advance, Burnout
is recorded twice, at the booster’s burnout and at the sustainer’s.
What the result holds. The flight’s events and final sample are the sustainer’s, from the pad
to its landing. FlightResult::bodies holds the booster’s descent, and
FlightResult::landings gives both landings, the sustainer’s first.
A worked example
The program
crates/hpr-sim/examples/two_stage.rs
flies a synthetic two-stage design. It has a 54 mm (2.1 in) sustainer on a 75 mm (3.0 in) booster. A J760 is in the
booster and an I175 in the sustainer. The stages come apart 0.5 s after the booster’s burnout, and
the sustainer lights 1 s after it. The ignition names the booster by its mount’s id, as the
design file does. The separation’s trigger names it by its index among the placed motors, as
every trigger does, so the program looks that up:
sustainer_motor.ignition = Ignition::Burnout {
mount: "booster-motor-mount".to_owned(),
delay_s: 1.0,
};
let booster = simulation
.assembly()
.motors
.iter()
.position(|motor| motor.mount == "booster-motor-mount")
.ok_or("no booster motor")?;
Device::new("booster tumble", tumble, Trigger::Time { time_s: 0.0 }).on_body(1),
.with_separation(Separation::new(
Trigger::Burnout {
motor: booster,
delay_s: 0.5,
},
0,
))?;
The 0 is the stage boundary: the stages from the nose through stage 0 are the sustainer. Run it
with cargo run --example two_stage -p fusionspace-hpr-sim. It prints:
A 54 mm sustainer on a 75 mm booster, J760 then I175, calm air
Not yet validated: see the Accuracy page before trusting these numbers.
event time (s) CG height (m) speed (m/s) mass (kg)
liftoff 0.00 0.5 0.0 2.480
rail exit 0.20 6.3 61.0 2.410
separation 2.23 643.0 341.2 1.904
sustainer lights 2.73 797.4 280.7 0.779
sustainer burnout 5.23 1798.9 403.2 0.550
apogee 18.42 3103.2 0.1 0.550
parachute charge 18.42 3103.2 0.1 0.550
parachute opens 18.42 3103.2 0.1 0.550
sustainer lands 865.34 0.0 3.4 0.550
The booster (1.125 kg) leaves at 2.23 s and 642.7 m, tumbling. It peaks at 745.0 m at 5.11 s and lands at 47.21 s at 17.9 m/s.
How to read it:
- The split. At 2.23 s the stack weighs 1.904 kg. The booster (its stage and a spent J760) takes 1.125 kg of that. The sustainer flies on at 1.904 − 1.125 = 0.779 kg, the mass shown when it lights. The booster starts at 642.7 m (2,109 ft) rather than 643.0 m (2,110 ft). That is because its own center of mass sits 0.3 m (0.98 ft) below the stack’s.
- The coast. Between the separation and the ignition the sustainer coasts for half a second and slows from 341.2 to 280.7 m/s (1,119 to 921 ft/s). That is about 121 m/s², mostly drag, on a 0.78 kg rocket near Mach 1.
- The burn. The I175 burns for 2.5 s and the mass falls to 0.550 kg: the sustainer’s structure and a spent motor.
- Two landings. The sustainer lands under its parachute at 3.4 m/s (11 ft/s). The booster tumbles from the split, climbs only 102.3 m (336 ft) more (to 745.0 m (2,444 ft)), and lands at 17.9 m/s (59 ft/s). That short climb comes from tumbling side-on from near Mach 1 at once, and is likely too short (see What it leaves out).
These numbers are for a made-up rocket that no other program has flown, so nothing checks them beyond the tests below.
More stages and boosters
Three or more stages, dropped payloads, and boosters beside the core.
Several separations
A rocket of three stages or more flies, dropping its stages under power one after another, from the tail forward. At each split the stages behind it drop away and descend to their own landing, and the rest flies on as a new sustainer. The simulator cuts that sustainer from the whole design at the new boundary, as it cut the first. It carries the nose tip’s state straight across, as in Powered separation. This is checked against OpenRocket’s three-stage example, not against a real flight, and the dropped stages’ own flights are not validated (evidence row G13). The decision record is ADR-160 (several powered separations).
How it is set. Simulation::with_separations takes the separations in the order they fire.
with_separation is a list of one, and a flight with one separation flies as it did before, to the
bit.
- The order. Each separation’s stage boundary is forward of the one before. Separation
makes body : the stages from its boundary back to the boundary before it, or back to the
tail. Body 0 keeps the nose. On a three-stage rocket the booster is body 1 and the middle stage
body 2 (
Separation::body_ofandSeparation::stages_of_bodygive the numbering). - Each split hands the flight on. With more than one separation, each must leave the body with the nose a motor still to burn.
- A motor lit at a split stays lit at the next one. A motor that an earlier separation lit counts as burning from that split when the next one fires. So take a middle stage whose motor the first split lit. If that motor has burnt out by the second split, the stage leaves with that motor’s dry mass, not its loaded mass.
- Where else the list goes. The facade’s
FlightBuilder::separationstakes the same list, andhpr::ork::separationsmakes it from a.orkconfiguration’s stagings, from the tail forward.
What is refused.
- When the
Simulationis built: boundaries that don’t move forward, and separation times known before the flight that come in the other order. It also refuses more than one separation together with ejections, since a sustainer cut from the design doesn’t track the ejected pieces. - In flight, by name: with more than one separation, one that leaves nothing ahead of it to burn. It is refused since, once every body is a point mass, no sustainer is left to part. A separation that fires before the one listed ahead of it is refused too.
- Each dropped part must have a device open at its split, as a booster must.
- A
.orkconfiguration is left out, with its reason, when a separation at or after apogee sits beside another. It is also left out when one comes before the separation behind it.
A worked example: OpenRocket’s three-stage example. OpenRocket’s Three stage low power
rocket drops its booster at the booster’s burnout, as the middle stage lights. It drops the
middle stage at that stage’s own burnout, as the sustainer lights. Each configuration is written
sustainer first: [A8-5; B6-0; B6-0] is an A8-5 in the sustainer above B6-0s in the middle stage
and the booster. cargo xtask ork-flights flies each configuration on OpenRocket’s own thrust
curves, matched by their digests. is HPR Sim less OpenRocket, in per cent of OpenRocket’s:
| motors | apogee, OpenRocket (m) | apogee | largest speed | separations, OpenRocket / HPR Sim (s) | notes |
|---|---|---|---|---|---|
| A8-5, B6-0, B6-0 | 277.1 | −1.37% | +0.25% | 0.857 / 0.857; 1.714 / 1.714 | nothing deployed |
| C6-5, B6-0, B6-0 | 505.4 | −0.95% | +1.51% | 0.857 / 0.857; 1.714 / 1.714 | nothing deployed |
| C6-7, C6-0, C6-0 | 689.5 | −1.48% | +1.64% | 1.860 / 1.860; 3.720 / 3.720 |
How to read it:
- The splits. Both come at OpenRocket’s times, to the 1 ms the report shows: at the booster’s burnout, then at the middle stage’s.
- The apogee. On the first two, OpenRocket’s parachute opens before apogee, 0.45 s and 1.57 s early. So the apogee is held to OpenRocket’s flight with nothing deployed, as for the clusters below. Against OpenRocket’s own record those two read −1.24% and +0.98%.
- The descent. Flown with the file’s own parachutes, the sustainer lands within 0.009% of OpenRocket’s landing speed on each. Its flight time is −1.13%, −0.56% and −1.41% off OpenRocket’s. All three meet every descent target (Recovery).
- The mass off the rod. OpenRocket’s recorded mass falls as if every motor of the booster’s type burned from launch (#185). From launch to rod clearance it drops 2.0000, 1.9998 and 2.9944 times as much as HPR Sim’s: the count of such motors in each configuration. So HPR Sim reads 1.80% to 3.26% heavier as the rocket leaves the rod, though the launch masses agree within 0.054%. At that moment HPR Sim’s stability margin is 0.039 to 0.058 calibers shorter than OpenRocket’s. That is about as much as HPR Sim’s center of mass sits further aft, 0.043 to 0.062 calibers. Whether OpenRocket’s light mass accounts for that is not sized.
- With the curves
hpr simfetches. The file holds no curves, sohpr simfetches them from ThrustCurve.org (Motors from ThrustCurve). It takes the file that holds OpenRocket’s curve for each motor’s digest (ADR-161, OpenRocket’s curves by digest). The largest speeds read 0.31%, 1.55% and 1.67% above OpenRocket’s: 78.61, 121.55 and 132.02 m/s (433.1 ft/s). The apogees, flown with the file’s parachutes, read 1.15%, 0.58% and 1.37% below OpenRocket’s own record, which opens them too. Against its flight with nothing deployed, the table’s figures, the first two read 1.28% and 2.48% below. Before HPR Sim kept a table of which ThrustCurve file holds each OpenRocket curve, the first configuration flew another A8 file. That file burns out 0.536 s after lighting where OpenRocket’s burns 0.73 s. The configuration’s largest speed read 5.7% high.
What it leaves out.
- The dropped middle stage’s own flight, like the booster’s. It is a point under its devices’ drag, tumbling side-on from its split until a device of its own opens. So its peak and landing are rough (#179).
- An unpowered separation after a powered one, such as a payload released after the stages: it is refused. A lone unpowered one flies only as A payload dropped with nothing left to burn says.
- A motor lit by a separation can’t time a later separation, since its burnout has no time
before the flight. The
.orkreader never lights a motor that way.
A payload dropped with nothing left to burn
When the split leaves nothing ahead of it to burn, every part flies on as
a point with only its own devices’ drag. So hpr sim flies it only when the part that keeps the
nose has a device of its own open by then. That is how a payload section usually leaves. The
booster’s ejection charge pushes it off after the motor has burned out, sometimes before apogee,
and its parachute opens at once. No new physics is involved. Each part is a point mass under its
open devices, the descent model of Recovery, from the instant it
separates. This is how OpenRocket flies a descent (its technical documentation v13.05, §4.2.5).
- The payload’s device. A
.orkdevice set tolowerstageseparationopens on the split’s own trigger, plus its delay. A payload whose device opens later, or that has none, would coast with no drag, sohpr::ork::tumblingrefuses it by name. It is not tumbled instead: a finless payload on its own is unstable, and nothing measured says how it flies. To fly such a file, set one of the payload’s devices to open at the split. In OpenRocket, that is its deployment event “Lower stage separation” with no delay. - A device that fired but waits out its lag. The flight itself refuses a rising part parted
before apogee whose device fired by the split but opens after its lag. The
part would climb through the lag with no drag. A
.orknever flies one, since the check above refuses its delay first. A Monte Carlo run’s drawn deployment lag can make one. That flight fails by name and is counted (Monte Carlo). A device set for the part’s own apogee leaves it to coast as before, which the check above refuses for the payload. A part parted by an ejection charge on the way up is refused the same way. A part already falling when it parts still falls with no drag through its device’s lag. That is a smaller error, not refused, but the flight warns of #354. So does any flight with a part that starts with nothing open.hpr mcreports only its nominal flight’s warnings, so a drawn lag’s isn’t. - The booster tumbles side-on from the split until its own device opens, as after a powered split. Its flight is not validated (#179) (evidence row G13). Every flight that drops a booster warns of #179 (the separated parts’ warnings).
- Not measured: a real payload whose parachute opens late would land later and further away; OpenRocket’s record holds no such flight to compare with.
- The flight’s apogee is the payload’s own when the split comes before the stack’s apogee.
A dropped part can climb higher. The C6-3 example’s booster, tumbling, peaks 0.9 m (3.0 ft) above the
payload.
hpr simsays so in a note, as a waiver’s height is the highest any part reaches.
A worked example. OpenRocket’s Deployable payload on a C6-3 drops its booster at the
charge, 4.86 s after launch. In HPR Sim’s flight, from
hpr sim "Deployable payload.ork" --config "[C6-3]", the stack is then
230.4 m (756 ft) up. It is still rising at 27.6 m/s (91 ft/s, OpenRocket’s record: 27.9 m/s (92 ft/s)). The payload’s 10 in
(0.254 m) parachute, set to lowerstageseparation in the file, opens at that instant. The
payload climbs 3.3 m (11 ft) more, to 233.7 m (767 ft) above the site at 5.44 s. That height is the center of
mass’s, which starts 0.4 m (1.3 ft) above the site. From where it starts, as the table below compares, it
is 233.3 m (765 ft). Coasting with no drag, it would have risen more
instead.
Against OpenRocket. All six configurations of the Deployable payload and the ARC payload rocket separate at OpenRocket’s times. The payload’s apogee is within 1.1% of OpenRocket’s record, measured from where each tool’s flight starts, and every descent meets the targets of Recovery. Two of the six separate before apogee:
Each is taken from the report’s unrounded heights, so it can differ in the last digit from the rounded ones.
| motors | split (s) | payload’s apogee, OpenRocket / HPR Sim (m) | apogee | coasting with no drag: OpenRocket’s free payload / HPR Sim (m) | coasting |
|---|---|---|---|---|---|
| C6-3 | 4.86 | 233.2 / 233.3 | +0.04% | 258.5 / 268.8 | +4.00% |
| C6-5 | 6.86 | 265.3 / 264.4 | −0.32% | 266.6 / 265.4 | −0.43% |
The last two columns measure what the refusal avoids. OpenRocket’s flight of the same rocket with nothing deployed lets the payload fly on its own airframe. A coast with no drag puts the C6-3 payload 10.3 m (34 ft) above that. It puts it 3.5 m (11 ft) above the whole stack’s own climb. The report’s table has all six. The M4.5g3 milestone shipped this; its decision record has the reasoning.
Boosters beside the core
Boosters strapped beside the core, a parallel stage, burn with it
and drop at a separation of their own. From a .ork, they are flown on a rocket of one stage on the axis. No new physics is involved. The stack flies whole until
the split. The split is a powered separation like any other
(Powered separation). The core flies on with its own shape and mass. The
boosters fly as a point with only their devices’ drag, tumbling side-on from the split, as a
dropped booster does in the simulator. Their own flight after the split is not validated
(evidence row G13). Their peak
and landing are likely too low and too close to the pad
(#179).
- Which separation drops them. A separation after stage drops every stage after . So a parallel stage is dropped by the separation after the stage it hangs on, together with whatever hangs on it. A separation that would drop boosters hung on a stage the nose keeps together with an axial booster behind them is refused. Drop the axial booster first.
- When they light. In a
.orkfile, a booster’s motor set to lightautomatically lights at launch when the boosters hang on the last axial stage. That is how OpenRocket lights them (.ork: Delays and ignition). - Boosters with no motor stay on. When no motor in the boosters lights, their separation at burnout or at the charge never comes. They ride to apogee and land with the core, as OpenRocket flies them.
A worked example. OpenRocket’s Parallel booster staging, one of the example designs
OpenRocket ships, has an I115W in its core and an E12-0 in each of two boosters. The file holds
no thrust curves, so hpr sim fetches them from ThrustCurve.org once
(Motors from ThrustCurve.org). In configuration 1 both light at launch. From
hpr sim "Parallel booster staging.ork" --config 1, with its defaults (1.5 m (4.9 ft) rail, sea
level, calm air), the E12s burn out and fire their charges at 2.44 s. The stack is then 290.1 m (952 ft) up at 207.6 m/s (681 ft/s),
and the boosters drop away. The core burns on to 3.51 s and peaks at 1,138.2 m (3,734 ft) at 13.01 s; the
boosters land at 33.0 s. In configuration 2 the boosters hold no motor and stay on: the stack
peaks at 858.2 m (2,816 ft). These heights are a little above the table’s below. The table flies each
configuration under OpenRocket’s stored conditions instead (a 1 m (3.3 ft) rod, at its launch site).
Against OpenRocket. Under OpenRocket’s own stored conditions, from the flights report, recovery as saved:
| motors | split (s), OpenRocket / HPR Sim | apogee, OpenRocket / HPR Sim (m) | apogee | largest speed |
|---|---|---|---|---|
| I115W-10 and 2× E12-0 | 2.44 / 2.44 | 1,123.6 / 1,137.5 | +1.23% | +3.25% |
| I115W-10, boosters empty | none / none | 851.8 / 857.6 | +0.68% | +1.56% |
At rod clearance the masses agree to 0.7 g (0.06%) and the static margins to 0.003 caliber, and both descents meet the targets of Recovery. The 3.25% in largest speed is not traced. M4.5m shipped this; its decision record is ADR-171.
A booster dropped still burning
A powered separation may drop a booster whose motors still burn, when it is told to. The
dropped part then flies with no thrust, so its flight leaves out the impulse those motors had
left. This is how the simulator flies a .ork stage with motors in more than one mount.
OpenRocket 24.12 separates such a stage at its first motor’s burnout, measured by a committed probe
(Delays and ignition). It drops the stage’s other motors
still burning (M4.5n, a stage’s first burnout;
ADR-172).
- The opt-in.
hpr_sim::Separation::drops_burning, set bySeparation::dropping_burning(), is off by default, and then the booster’s motors must have burned out. On, a powered separation may drop a motor that has lit and still burns. A motor behind it still to light is refused either way, and so is any burning motor behind an unpowered separation.hpr::ork::separationsets it only for a staging the.orkreader markeddrops_burning. The reader marks only a split at its own stage’s firstburnout, and only when the split is powered. That means a motor ahead of it burns then, or lights then or later. A delay after that burnout counts too, though no probe has measured a delayed one. Such a split may drop only the stage’s own other motors, and only those lit strictly before the split. A motor behind it lit at the split itself, or one burning in another stage behind, is refused. Any other split while a motor behind it burns (a time, an ignition, a charge) is still refused. Leaving its thrust out could leave out most of a motor. A motor lit by a charge among several mounts is refused by name: which fires its charge first is not measured. - What the flight leaves out. A dropped part flies as a point with no thrust, as every
dropped part does, with its mass at the split, propellant left included.
BodyFlight::impulse_left_n_sgives the impulse its motors had left: each lit motor’s curve total, less what it had given by the split. That thrust could have changed the part’s speed by about that impulse over its mass, a little more as the propellant left burns away. It is 0 for every other part. - What
hpr simsays. It names the motors and gives the number. On the first configuration of OpenRocket’s Pods--powered with recovery deployment,[C6-7; 2× A3-4, B6-0], the booster drops at 0.860 s with both A3s still burning. Its flight as a point leaves out 0.509 N·s, as the report’s Parts dropped still burning section gives it.
The sustainer’s flight is not affected: it keeps no thrust from the dropped motors in either program. The dropped booster’s own flight is not validated (#179) (evidence row G13).
Validation
How staging compares with OpenRocket’s examples, and the tests that pin it.
Against OpenRocket
In short. HPR Sim reads when each motor lights and when the stages come apart from an OpenRocket
.ork file. It flies OpenRocket’s own two-stage, three-stage, cluster and air-start examples.
Every one of their 15 flights is within 5% of OpenRocket’s in apogee and in largest speed. The
tolerance was written down before any of them was flown
(M1.9c milestone, decision record ADR-076; the
three-stage example since M4.5g2, several separations).
Five apogees, three of the cluster’s and two of the three-stage example’s, are compared with
OpenRocket’s flight with no parachute. Its parachute opened before apogee.
What HPR Sim reads. A .ork file says when each motor lights with a word and a delay
(Delays and ignition). It says when each stage drops away with
another (When parachutes open and stages separate).
HPR Sim turns them into its own:
| the file says | HPR Sim flies |
|---|---|
a motor lit at launch, or automatic in the bottom stage, plus a delay | lit at : an air start when is not 0 |
a motor lit at burnout of the stage below, plus | lit after the stage below’s first burnout: the first of its motors to burn out, by each one’s ignition and curve, in whichever mount (ADR-172) |
ejectioncharge, or automatic in a stage above | lit at the stage below’s ejection charge: its burnout plus its ejection delay, plus |
never; burnout or ejectioncharge in the bottom stage; ejectioncharge or automatic over a plugged motor; or a motor lit by one of these | never lit: carried loaded, with no thrust |
a stage separating at launch plus a delay, at its motor’s ignition, burnout or ejection, or at the upperignition of the stage above | a separation at that instant, plus its delay, if at that moment a motor ahead of it is burning or has yet to light (one timed before the rocket leaves the rod fires as it leaves, #231) |
a stage separating at apogee, or at a height on the way down (altitudedescending) | no separation: it belongs to the descent, which HPR Sim’s flights of a .ork don’t fly yet, so the configuration flies whole |
HPR Sim flies such a separation when it is powered. A motor ahead of it is then burning or has
yet to light, and no motor behind it is. A powered separation at its own stage’s first burnout
may also drop the stage’s other motors still burning. OpenRocket does the same
(Dropped still burning). A configuration with several flies them all, from the
tail forward (Several separations), as long as each is powered. An apogee or altitudedescending separation is left to
the descent only on the assumption that every motor is spent by apogee. cargo xtask ork-flights
checks that of every flight it reports. When flown, HPR Sim refuses a powered separation that fires
after a recovery device on the part with the nose has opened. A configuration it can’t fly as
written is left out with its reason, never flown some other way:
- a separation at or after apogee beside another separation, and one that comes before the separation behind it (Several separations);
- a separation with no motor ahead of it burning or yet to light when it fires, beside another
separation. Alone, at a time known before the flight, it flies
(A dropped payload).
The exception is when the part that keeps the nose would coast with no drag from it. A lone one
at
apogeeor at a height on the way down can only come after apogee. So the climb is the whole stack’s, as in OpenRocket; - a separation while a motor behind it is still burning or yet to light. The exception is a
powered one at its own stage’s first
burnout. It may drop the stage’s own other motors still burning if they lit strictly before the split; - a separation at a height on the way up (
altitudeascending), which HPR Sim has no trigger for; - a negative delay on a separation HPR Sim would fly;
- a motor lit:
- at a word HPR Sim does not know, or by a stage below that holds no motor;
- by the charge of a stage below with motors in more than one mount (which fires its charge first is not measured);
- by the charge of a motor below that states no delay;
- a separation at the ignition of a motor that never lights, or at launch. One at launch is left out since HPR Sim’s flight fires a separation only once the rocket is off the rod;
- a configuration in which no motor lights.
A motor set never, or lit by an event that never comes, flies unlit and loaded, as OpenRocket
flies it (M2.2e10, probed by
validation/oracles/openrocket/unlit_motors.py). Such a motor is one in the bottom stage lit at the
stage below’s burnout or charge, or one lit by a plugged motor’s charge. A stage that separates at the burnout or
charge of its own motor that never lights stays on. A stage below with no motor is still refused:
OpenRocket’s reading of it has not been probed.
A cluster flies with a motor in every tube (Clusters).
The tolerance. A design is within when every configuration of it that HPR Sim flies has its
apogee and its largest speed within 5% of OpenRocket’s. Where OpenRocket’s parachute opened before
its apogee, which lowers it, the apogee is compared with OpenRocket’s flight of the same
configuration with nothing deployed. OpenRocket’s record is the set of flights OpenRocket 24.12
flew for this comparison, committed as
openrocket-flights.json.
It holds the flight of the part that keeps the nose, so both numbers are the sustainer’s.
The result. is HPR Sim less OpenRocket, in per cent of OpenRocket’s.
| OpenRocket’s example | motors | apogee, OpenRocket (m) | apogee | largest speed | notes |
|---|---|---|---|---|---|
| Two stage high power rocket | H148R-0, then H148R-0 | 678.5 | −1.79% | −0.54% | separates at 1.535 s in both |
| Two stage high power rocket | I357T-14, then I59WN-P | 1,384.2 | −0.13% | −0.04% | separates at 1.515 s in both |
| Three stage low power rocket | A8-5, B6-0, B6-0 | 277.1 | −1.37% | +0.25% | nothing deployed; separates at 0.857 s and 1.714 s in both |
| Three stage low power rocket | C6-5, B6-0, B6-0 | 505.4 | −0.95% | +1.51% | nothing deployed; separates at 0.857 s and 1.714 s in both |
| Three stage low power rocket | C6-7, C6-0, C6-0 | 689.5 | −1.48% | +1.64% | separates at 1.860 s and 3.720 s in both |
| Clustered motors | 4× A8-3 | 58.2 | −0.35% | +0.20% | |
| Clustered motors | 4× B4-4 | 143.1 | −0.79% | +0.31% | nothing deployed |
| Clustered motors | 4× C6-3 | 308.6 | −0.72% | +0.92% | nothing deployed; +9.43% against its parachute opening 2.59 s early |
| Clustered motors | 4× C6-5 | 308.6 | −0.72% | +0.92% | nothing deployed |
| Clustered motors | 4× C6-7 | 308.6 | −0.72% | +0.92% | |
| Airstart timing | 3× I211W-P and a K550W-P, all at launch | 1,317.5 | +0.94% | +0.81% | |
| Airstart timing | the three I211W lit at 1 s | 1,292.5 | +1.03% | +0.76% | |
| Airstart timing | at 2 s | 1,296.0 | +0.84% | +0.72% | |
| Airstart timing | at 4 s | 1,303.7 | +0.59% | +0.51% | |
| Airstart timing | at 6 s | 1,274.2 | +0.48% | +0.46% |
The full report, with the stability margin, mass and center of mass at rod clearance, is
openrocket-flights.md.
The test a_two_stage_and_a_cluster_design_are_within_5_percent_of_openrocket in
xtask/src/ork_flights.rs holds it to the tolerance in CI.
A flight OpenRocket aborted is checked up to the abort. OpenRocket stops its own flight of
Pods--powered with recovery deployment’s first configuration at 1.81 s (“Stage began to tumble
under thrust”). So it has no apogee to compare. Instead, cargo xtask ork-flights compares HPR Sim’s
height and speed with OpenRocket’s just after the separation and at OpenRocket’s last row. It
needs the splits at one time and each value within 5%. Both separate at 0.86 s, where HPR Sim is
1.17% lower (22.18 m (72.8 ft) against 22.44 m (73.6 ft)) and 0.04% slower. At 1.81 s HPR Sim is 1.18% lower (84.0 m (276 ft)
against 85.0 m (279 ft)). It is 4.02% faster (79.9 m/s (262 ft/s) against 76.8 m/s (252 ft/s)). So the check is met
(the report’s section;
.ork: Flights OpenRocket aborted). This is
weaker evidence than an apogee: two points on the way up, the second where OpenRocket’s flight is
breaking up. When OpenRocket aborts is its own call, too: its probe of the same configuration
with nothing deployed aborts at 2.40 s, not 1.81 s. The sustainer’s least static margin is −4.21 calibers at the split. In the record’s conditions, a 0.15 m (0.49 ft) rod at 28.61° N with no wind, HPR Sim’s
sustainer turns over at 2.04 s. From hpr sim’s defaults, a 1.5 m (4.9 ft) rail with no wind, it does
not. Why the two differ is not traced
(evidence row G17). hpr sim warns that the sustainer is unstable under
power and that its apogee is not a prediction
(Flight metrics: unstable under power;
#335).
What is not settled.
- On the first two-stage flight, OpenRocket’s mass falls about twice as fast as HPR Sim’s before the sustainer lights. It falls by 0.0823 kg against 0.0412 kg from launch to the end of the rod, as if both H148R motors lost propellant from launch. On the second, with two different motors, the masses agree to about 1 part in a million. The three-stage example shows the same fault. OpenRocket’s drop to the end of the rod is 2.0000, 1.9998 and 2.9944 times HPR Sim’s. That is the count of motors of the booster’s type (Several separations). What that does to the apogee has not been sized (#185).
- HPR Sim’s apogee is its center of mass’s, which jumps forward at the split from the whole stack’s to the sustainer’s. Whether OpenRocket’s altitude jumps the same way is not measured (#187). The jump is under 1.32 m (4.3 ft) on the two-stage flights, less than 0.2% of either apogee.
- HPR Sim’s descent of a separated part needs a recovery device on each part. So the climb’s
comparison tumbles the booster from the split and the sustainer from its apogee; neither acts on
the climb, which flies no parachute. A second flight, for the
descent, flies the file’s own devices, each on its part
(ADR-159, powered separation in
hpr sim). The sustainer’s landing speed is +0.00% off OpenRocket’s on both configurations. Its flight time is +0.32% on the H148R-0 and H148R-0 configuration and +0.73% on the I357T-14, then I59WN-P one. On the three-stage example it lands within 0.009% of OpenRocket’s speed, and its flight time is −1.13%, −0.56% and −1.41% off. The descents of the booster and the middle stage are not compared: OpenRocket’s record keeps only the sustainer’s branch.
Running it. cargo xtask ork-flights flies them. It needs OpenRocket’s jar and its motor
database, which cargo xtask refs fetch and the oracle scripts put in place. So CI checks the
committed report rather than flying it.
Flying a .ork file’s staging yourself. The rocket a .ork configuration builds does not
carry its separations. The reader hands them over separately, as the configuration’s staging
and later_stagings (MotorConfiguration::stagings gives them all, from the tail forward).
hpr::ork::separations turns them into the flight’s separations. The program passes those to the
flight with Simulation::with_separations, or the facade’s
FlightBuilder::separations, along
with a recovery device on each part. For a configuration with one, hpr::ork::separation,
Simulation::with_separation and FlightBuilder::separation still take it alone. The example
ork_two_stage.rs
does this for a made-up two-stage .ork: it tumbles the booster from the split and the
sustainer from its apogee. Run it with cargo run --example ork_two_stage -p fusionspace-hpr. For the
file’s own parachutes and streamers instead,
hpr::ork::separated_recovery puts each on its part
and adds the tumbles a part needs. hpr sim flies a .ork that way
(Separation).
Tests
In crates/hpr-sim/src/staging.rs and crates/hpr-design/src/config.rs:
serial_plan_timing_and_mass_step(Loft lesson L93, a check carried over from this project’s predecessor). The sustainer lights at the booster’s burnout plus its delay, to 1e-12 s. The mass steps down by exactly the booster’s, to 1e-12 of the mass, and holds until the sustainer lights. It also checks a sustainer whose separation never comes: it never lights, and it lands loaded.a_sustainer_set_never_to_light_flies_as_a_motor_outanda_motor_set_never_to_light_stays_loaded: a motor setneverflies exactly as one whose only tube fails, carried loaded to the end. A motor lit by that motor’s burnout never lights either.a_sustainer_keeps_a_motor_set_never_to_light_through_the_separation: a sustainer cut at a powered separation keeps it unlit.- In
crates/hpr-io/src/ork/tests.rs,openrocket_flies_a_motor_whose_ignition_never_comes_unlitholds OpenRocket’s probe record, anda_motor_waiting_on_one_that_never_lights_is_never_litthe reader’s chains and refusals. apogee_separation_fires_in_flight_and_booster_flies_to_landing(Loft lesson L30): an apogee separation fires at the flight’s own apogee, and a height separation where the flight crosses the height. Both bodies land, powered or not.staged_events_come_in_order: liftoff, rail exit, separation, ignition, burnout, apogee and landing, in that order. The burnout is recorded once at the sustainer’s, or twice with a sustainer lit by its separation.a_powered_separation_conserves_linear_momentum: the two bodies’ momenta add to the stack’s, to 1e-9 of it, launched 10° off vertical.an_air_start_lights_at_its_time_and_burns_on_its_own_clock: a motor lit at 3 s, loaded until then, burns out at 3 s plus its burn time.staging_refuses_what_it_cannot_fly: a drag table or a drag model past a powered separation, and a separation timed while the booster burns. It also refuses a delay that is negative or not a number, and a booster with nothing open at the split. A separation that could never fire is refused, and so is a powered separation after the sustainer’s canopy opened.two_powered_separations_drop_the_booster_then_the_middle: two splits at the booster’s and the middle stage’s burnouts, to 1e-9 s. At each, the mass steps by exactly the dropped part’s, to 1e-12 of the mass. The momenta add to the stack’s, to 1e-9 of it. The booster is body 1, the middle stage body 2, both land, and the flight repeats to the bit.a_motor_lit_by_the_first_separation_counts_from_it_at_the_second: a middle stage lit at the first split leaves at the second with its motor’s dry mass. A second split timed while that motor burns is refused.several_separations_refuse_what_they_cannot_fly: the refusals in Several separations.ignition_times_follow_their_events,bad_ignitions_are_refused.strap_on_boosters_burn_beside_the_sustainer_and_drop: boosters lit at launch drop at their separation. The mass steps down by exactly their structure and spent motors. The core burns on and climbs higher than with the boosters carried to apogee.a_separation_drops_only_what_hangs_together: the refusal above, and the order that flies.a_powered_separation_drops_a_burning_booster_only_when_told: a powered separation setdropping_burningdrops a booster still burning. The booster’simpulse_left_n_sis its curve’s total less what it had given by the split, to 1e-12 of it. A separation that is not set, is unpowered, or has a motor behind still to light is refused. Incrates/hpr-io/src/ork/tests.rs,a_stage_in_several_mounts_burns_out_first_where_its_motors_sayholds the reader’s first burnout and its refusals.
Moving mass
See what ballast or a payload sliding along the airframe during flight does to your rocket’s center of mass, stability margin and flight.
In short
- What it models: a part carried inside the airframe, such as ballast or a payload, sliding along the rocket’s axis in flight on a trigger. The rocket’s center of mass and inertia follow the part, and so do the equations of motion. Use it to see what a payload that moves, or ballast moved on purpose, does to the stability margin and the flight. The model was added in the moving-mass milestone.
- Sources: the parallel-axis theorem and the kinetics of a system of particles, from Meriam and Kraige’s Engineering Mechanics: Dynamics. Both are applied to the equations of motion on Rigid-body flight. The cycloidal motion of cam design is from Norton’s Design of Machinery.
- How well it is validated: against exact answers only. No other simulator or real flight has been compared with it. The mass properties match a hand calculation to 1e-15, and the static margin to 1e-12 calibers. In free flight with nothing acting on the rocket, its angular momentum is kept to 6.9e-12 of itself and its center’s velocity to 2.6e-12 m/s.
- What it leaves out: a mass that leaves the rocket, which is Released mass. A shift can’t come in a flight that also separates, ejects pieces or releases a mass, or before the rocket leaves the rail. A part can’t move across the axis or turn, and the shock of it hitting a stop isn’t modeled. The motion’s shape is a choice made here, not something a source gives for rockets.
The model
How a shift is described, and what it changes.
Describing a shift
A MassShift names the part, how far it moves, how long it takes, and when it starts:
| field | meaning |
|---|---|
trigger | when it starts: the same triggers a parachute has (apogee, a height on the way down, a time after launch, a motor’s burnout or delay) |
component | the id of the internal component that moves; everything inside it moves too |
travel_m | how far along the axis, in meters: positive toward the tail, negative toward the nose |
duration_s | how long the move takes, in seconds: at least 0.01 s |
In code, this slides a part with the id ballast 0.3 m (0.98 ft) toward the tail over 1 s,
starting 5 s after launch:
let simulation = simulation.with_shifts(vec![MassShift::new(
Trigger::Time { time_s: 5.0 },
"ballast",
0.3,
1.0,
)])?;
let flight = simulation.run(&mut ())?;
The part is any internal component of your design, such as a mass component. Each shift that
starts is recorded as an EventKind::Shift event. Simulation::mass_properties(flight, t) gives
the mass, center of mass and inertia the flight had at any time.
Shifts of one part add up. The simulator can’t know before the flight which triggers will fire. So it adds all of a part’s moves toward the nose, and separately all of its moves toward the tail. It refuses either total that would take the part out of the component that holds it. A part the design already places partly outside its holder can go as far as it already reaches. A weight in a nose cone’s shoulder is one.
Some parts can’t move, and the simulator says which rule a refused one breaks:
- a body component, or a part on the outside of the airframe;
- a part holding a motor, since the motor would not go with it;
- a part inside another part that moves;
- one tube of a cluster;
- a part covered by a mass override on its stage, or by one on a component around it that covers what that component holds. The override doesn’t say how much of that mass is the part’s.
A flight with a separation or ejections can’t have shifts yet. A shift can’t start before the rocket leaves the rail either. The rail has no stop at its foot. So a part thrown toward the tail on the pad could push the rocket up the rail and leave it hanging there. The simulator stops the flight with an error if one would. A shift timed close to the rail exit can therefore fly in one flight and stop another that leaves the rail later. Time it from the burnout or the apogee instead.
The motion. A part doesn’t jump from one place to the next. It follows a cycloid, the curve a cam designer calls cycloidal motion. It starts at rest, speeds up, and slows to rest again. Its acceleration is zero at both ends, so neither its speed nor its acceleration jumps. With the fraction of the move’s time gone, the part is of the way along:
At it is exactly halfway, moving fastest, at twice the average speed. Its acceleration peaks at for a move taking . A move shorter than 10 ms is refused. The peak there is 63 km/s² for each meter of travel, closer to an impact than a motion.
The move’s time is cut into 16 equal parts by stop times, so the integrator takes at least 16 steps across it. That matters with fixed-step RK4: a 10 ms step would otherwise take a 10 ms move in one step.
What the rocket’s mass properties do
Moving a part inside the rocket doesn’t change the rocket’s mass. It moves the center of mass the same way as the part, by the part’s share of the mass. With the rocket’s mass, the part’s and how far it has moved:
The inertia changes as well. The simulator takes the part’s contribution out where it was and puts it back where it is, both about the new center of mass. It uses the parallel-axis theorem. The part’s own inertia about its own center goes with it unchanged. Write for the part’s center where the design puts it and for the move. is the rocket’s new center and its inertia about that center. is the rocket’s inertia with the part where it was, taken about . With the unit matrix, :
As a check by hand, think of the rocket as two bodies: the part and everything else. About the center of mass, the rocket’s inertia is the sum of the two bodies’ own inertias plus . Here is the reduced mass and is the line from the rest’s center to the part’s. Moving the part changes only . The tests check the simulator’s inertia against this formula.
The stability margin. The static margin is the distance from the center of mass back to the center of pressure. It’s in calibers of the rocket’s diameter (Flight metrics: stability margins). It takes the center of pressure with the air along the axis at Mach 0, which doesn’t depend on where the mass is. So a part moving toward the tail changes it by:
The flight margin, at the flight’s own Mach number, moves by the same amount at any one instant, since only its center of pressure differs.
What the equations of motion add
The equations of motion (Rigid-body flight) are written about the nose tip, , a point fixed in the airframe, in body axes. is the airframe’s rate of turn and the center of mass seen from . The equations already allow for a center of mass that moves through the airframe and an inertia that changes, because burning propellant does both. Primes there, as below, mean how fast something changes with time, as seen from the airframe. Then and are the center of mass’s velocity and acceleration through the airframe. is how fast the inertia about changes. A part that moves adds to those terms, and adds one term more.
Sum Newton’s law over every particle of the rocket. Each particle’s acceleration is the nose tip’s acceleration, plus the airframe’s rotation, plus its own motion inside the airframe. In the force equation, the particles’ motion inside the airframe gives the and terms, with nothing more. In the moment equation it gives , and also this term:
is the moving parts’ angular momentum about the nose tip, relative to the airframe. is a part’s center and its velocity inside the airframe. A part only slides, so every point of it moves at the same . When the part is on the axis, and both lie along the axis and is zero. When it is off the axis, is not zero, and the simulator carries it. The sum is over the parts that move, each with its own , and . On the Rigid-body flight page, is the name the equations (from RocketPy’s documentation) give the sum of the moments about the nose tip. subtracts .
The simulator works out how fast the center of mass and the inertia change exactly, from the cycloid. For a burning motor it still estimates them from points 0.1 ms apart. The two add, so a part can move while the motor burns:
The sums are over the parts that move, each with its own , and . Here and are the rocket’s with every part where the design puts it. and are how fast the rocket’s mass changes and how fast that changes, both zero once the motor is out. and are the part’s velocity and acceleration along its move, and is the part’s center now.
A worked example
The example
moving_ballast.rs
flies the project’s 54 mm (2.1 in) test design (validation/designs/synthetic-54mm-three-fin.json, a
body 56.3 mm (2.2 in) across) on an I175 motor.
The design carries 200 g of ballast in its airframe. The ballast is a cylinder 50 mm (2.0 in) long on the axis, its
center 0.375 m (1.23 ft) aft of the nose tip. At 5 s, well after the 2.5 s burn, it slides 0.3 m (0.98 ft) toward
the tail over one second. What the example prints (the transverse inertia is about an axis across
the rocket through its center of mass, the one it pitches about):
| time (s) | mass (kg) | center of mass (m aft of the nose tip) | transverse inertia (kg·m²) |
|---|---|---|---|
| 4.00 | 0.8188 | 0.6681 | 0.09556 |
| 5.25 | 0.8188 | 0.6748 | 0.09248 |
| 5.50 | 0.8188 | 0.7048 | 0.08138 |
| 5.75 | 0.8188 | 0.7347 | 0.07483 |
| 7.00 | 0.8188 | 0.7414 | 0.07399 |
By hand, the center of mass moves aft. At 5.5 s, halfway through the move, it has gone exactly half of that. The transverse inertia falls because the ballast ends up near the center of mass. The two-body check gives the change too:
-
.
-
The rest of the rocket, 0.6188 kg, has its center at
aft of the tip.
-
The ballast’s center moves from 0.375 m (1.23 ft) to 0.675 m (2.21 ft). So its distance from the rest’s center shrinks from 0.3878 m (1.272 ft) to 0.0878 m (0.288 ft).
-
The inertia changes by
as the table shows.
The static margin falls from 4.297 calibers to 2.996, a change of −1.302 from the unrounded values. By hand it is , with . The apogee barely moves: 1,749.8 m (5,741 ft) with the ballast moving, 1,749.9 m (5,741 ft) with it held still.
Checks, limits and sources
How the model is checked, what it leaves out, and its sources.
How it is checked
The tests are in hpr_sim::shifts and hpr_design::mass. The last column is what each test
measured, where it records it, and in brackets the bound it holds the code to.
| test | what it shows | measured (bound) |
|---|---|---|
a_part_moved_inside_a_body_gives_the_hand_computed_whole | a point moved inside a cube matches a hand calculation, and the whole rebuilt with the point moved | exact (1e-15) |
mass_properties_before_during_and_after_a_shift_match_the_hand_calculation | the example’s rocket before, halfway and after, against the two-body formula | (1e-15 m and kg·m²) |
a_moving_mass_shifts_the_static_margin_by_the_hand_calculation | the static margin at every coast sample of the flight equals from its start | (1e-12 calibers) |
a_part_moving_off_the_axis_keeps_both_momenta_in_free_space | no air or gravity, the rocket turning about all three axes, the ballast 1 cm (0.39 in) off the axis: the angular momentum about the center and the center’s velocity stay constant | 6.9e-12 of the angular momentum (1e-10), 2.6e-12 m/s (1e-10) |
a_shift_s_rates_are_the_derivatives_of_its_mass_properties | the exact rates against differences of the mass properties, during the burn and after it | 2e-11 m/s (1e-9), 3e-8 of itself (1e-7) |
a_fixed_step_follows_a_short_shift_in_its_stops | the free-flight case with RK4 at 10 ms steps and a 10 ms move: 16 steps across it | 1.2e-4 m/s (3e-4) |
a_canopy_that_opens_while_the_ballast_moves_keeps_the_center_s_velocity | in a vacuum, a drogue opening halfway through a move keeps the center’s velocity, and from then on the center falls freely while the ballast finishes its move | (1e-12 m/s at the opening, 1e-9 m/s after) |
a_shift_the_flight_starts_gets_its_stops_too | a move started at apogee gets its 16 stop times when it starts | exactly 16 steps |
a_shift_starts_at_apogee_or_at_its_height_on_the_way_down | the triggers the flight watches for start the move at the apogee, and at 200 m (656 ft) on the way down | (1e-6 m) |
The free-flight test is the one that checks the new term. Without , its error would be the size of the ballast’s own angular momentum relative to the airframe. That peaks at 1.8% of the rocket’s angular momentum. It measures 6.9e-12.
A first version took the part’s rates from differences 0.1 ms apart, as the motor’s are. In free flight it kept the center’s velocity only to 1e-8 m/s, the error of the difference itself, so the rates were made exact. A check with RK4 taking a 10 ms move in a single step found the center’s velocity off by 0.071 m/s (0.23 ft/s). The 16 stop times across each move bring it to 1.2e-4.
Every refusal has a test that checks which rule fired, in shifts_that_cannot_be_made_are_refused,
refusals_that_need_a_design_of_their_own and
triggers_a_shift_cannot_have_are_refused_in_its_own_words.
What it leaves out
- Ballast or a payload that leaves the rocket while the rest flies on is Released mass, added in the released-mass milestone.
- A separation, ejections or a release can’t come with shifts. Their pieces and parts are fixed before the flight, with every part where the design puts it.
- A part can only slide along the axis, at whatever distance from the axis the design puts it. It can’t move across the axis or turn.
- The cycloid brings the part to rest smoothly. A real mechanism may stop it with a shock, which a rigid airframe can’t model.
- The simulator doesn’t warn when a shift takes the margin below a safe value. Read the margin from the flight’s metrics (Flight metrics).
The decision record is ADR-087.
References
-
[MK] J. L. Meriam and L. G. Kraige, Engineering Mechanics: Dynamics. Chapter 4 (kinetics of systems of particles) sums the force and moment equations over particles. It also covers angular momentum about a moving point. Appendix B has the parallel-axis theorem and the inertia tensor.
-
[N] R. L. Norton, Design of Machinery, the chapter on cam design, with the cycloidal displacement
-
The equations of motion this adds to: the RocketPy technical documentation, “Equations of Motion” v0 and v1 (Rigid-body flight).
Released mass
See what letting go of ballast or a payload in flight does to the rest of the rocket, and where the part lands.
In short
- What it models: a part carried inside the airframe, such as ballast or a payload, let go during the flight on a trigger. The rest of the rocket flies on in six degrees of freedom. The rocket’s mass, center of mass and inertia change at once to those of what remains. The part falls to the ground on its own. Use it to see what dropping ballast or a payload does to the flight, and where the part comes down. The model was added in the released-mass milestone.
- Sources: the parallel-axis theorem and the kinetics of a system of particles, from Meriam and Kraige’s Engineering Mechanics: Dynamics. The part’s fall uses the equations a separated body already has (Recovery).
- How well it is validated: against exact answers only. No other simulator or real flight has been compared with it. The mass properties after a release match a hand calculation, and the design built without the part. The tests’ bound is 1e-15 (kg, m, kg·m²). In free flight with nothing acting on the rocket, the rest and the part together keep the rocket’s momentum to a relative error of 1.5e-13. They keep its angular momentum to 7.3e-12.
- What it leaves out: a push that throws the part out, parachutes on the part, and the part’s own spin once it is out. A release can’t come in a flight that also separates, ejects pieces or moves a mass, or before the rocket leaves the rail. Where and how fast the part lands depends on its drag area, which you give. HPR Sim doesn’t warn when a release leaves the rocket unstable. Dropping a part forward of the center of mass moves the center aft. In the example below, the stability margin falls by 1.683 calibers. Read it from the flight’s metrics (Flight metrics).
The model
How a release is described, what it does and how it is read back.
Describing a release
A MassRelease names the part, when it leaves, and its drag area once it is out:
| field | meaning |
|---|---|
trigger | when it leaves: the same triggers a parachute has (Recovery: triggers): apogee, a height on the way down, a time after launch, a motor’s burnout or its ejection delay |
component | the id of the component in the design that leaves; everything inside it leaves too |
drag_area_m2 | the part’s drag area once it is out, in m²: positive |
Give the list to a flight with Simulation::with_releases. The part must be one component carried
inside the airframe, such as a mass component or an inner tube
(Rocket design: the tree). These are refused, each with an error that names
the part and the rule:
- an
idthat names no component; - a body component (a nose cone, a tube, a transition), or a part outside the airframe (fins, rail buttons);
- one of several copies in a cluster of tubes;
- a part that holds a motor: the rocket’s motors stay with it;
- a part whose mass is set by an override, on its stage or on a component around it that includes it. The override doesn’t say how much of the mass is the part’s;
- a part released twice, or inside another part that is released;
- a part with no mass, or releases that would leave the airframe, its motors aside, with none;
- a drag area that is zero, negative or not finite. A part with no drag would fall as if in a vacuum, which is a wrong number rather than a model;
- a trigger a parachute couldn’t have either:
- a time before launch;
- a height that isn’t positive;
- a motor that isn’t there, has no ejection delay, or is set to fail to light.
A release that would come on the pad or the rail makes Simulation::run return an error, with no
flight: the part has nowhere to go. A flight can’t combine a release with a separation, ejected
pieces or a moving mass yet.
What happens at the release
At the instant the part leaves, three things happen.
The rocket becomes the rest. is the rocket’s mass and its center. The part has mass , center and its own inertia about . The rest has
where is the rocket’s inertia moved to the new center by the parallel-axis theorem. is the identity matrix, and the bracket is the part’s inertia about that center. It’s the sum that builds a rocket from its parts, run backwards. The aerodynamics don’t change: the part was inside the airframe.
The rest flies on from the same state. The flight’s state is the nose tip’s position and velocity, the attitude and the turning rates (Rigid-body flight). The rest keeps the nose tip, so none of these changes. The mass properties step. The integrator (the numerical method that steps the flight forward in time) starts afresh at the same instant. It does the same when a sustainer flies on after a separation (Staging). What the flight reports about the center of mass steps too. Its position moves by (9.5 cm (3.7 in) aft in the example), and its height with it.
The part leaves with the velocity it had. Every point of a rigid body moves at . Here is the nose tip’s velocity, the rocket’s turning rate and the point’s place in the rocket. The part leaves from where it was, with its center’s velocity , and the rest’s center goes on at . Nothing pushes the two apart, so every bit of the rocket keeps its velocity. Once the motor has burned out, the rest’s momentum plus the part’s is the rocket’s just before. The same holds then for the angular momentum.
While the motor burns, the center of mass drifts along the airframe as propellant is used, and the reported center-of-mass velocity includes that drift. A release steps the center by , so the drift’s share of the velocity steps too. The reported momenta then differ by , with the propellant’s mass flow, turned into the launch frame. No part of the rocket changes its velocity; only the reported center does.
The flight has one apogee. The rest’s center is not where the rocket’s was. So on a flight
that turns, it can rise for a moment after the rocket’s apogee. Or it can already be falling when
a part leaves just before the apogee. The flight records one apogee: the rocket’s, or
the release itself when it leaves the rest already falling. A part let go at apogee leaves at
that one, whatever order the parts are listed in. It does so even when another part leaving
first sets the rest rising again. Past the recorded apogee the rocket counts as coming down. So
a part or a parachute set to a height above the apogee still goes there, as
Recovery: triggers describes. A flight started part way (Simulation::run_free) already
falling lets a part waiting for the apogee go at its start. It records an apogee only if the
rest later rises and falls again.
The rest can land at the release. Take a rocket falling nose up, just above the ground, that lets go of a part forward of its center of mass. That steps the rest’s center down, to the ground or below it. The rocket has then landed, at the release. A recorded trajectory’s last row is at that time, but of the rocket as it was before the part left. A release that steps the rest below the ground while it is still climbing is an error instead.
The part’s fall
Once out, the part is a point mass under its drag area, its weight and the Earth’s rotation, the equations a separated body falls by:
with and the part’s velocity and acceleration, the air’s density, the wind,
gravity and the Coriolis acceleration. It
falls from its release to the ground or to the flight’s time cap (FlightSettings::max_time_s).
If it left climbing, its own apogee is recorded.
The drag area is yours to give. For a part tumbling at random, the tumble model’s body term gives 0.56 times its side profile, its diameter times its length (Recovery: tumble). That is half the 1.12 of a cylinder broadside. It was fitted to whole rockets 44 to 103 mm (1.7 to 4.1 in) across, falling at 5 to 6.6 m/s (16 to 22 ft/s). Its one drop test without fins wanted 0.79, which gives a speed 16% lower. So treat a tumbling part’s landing speed as uncertain by at least that much. The simulator doesn’t build the area for you, because its tumble model needs body tubes and fins, and a released part has neither. If the part carries a parachute, give the parachute’s drag area; it is taken as open from the instant the part leaves.
Reading a release back
EventKind::MassRelease(i)among the flight’s events marks release (its place in the list given towith_releases). The event’s sample is the rocket just before the part left.FlightResult::releasedholds each part’s flight (ReleasedFlight): its start, its events, its landing. The separated bodies of a separation or an ejection are elsewhere, inFlightResult::bodies.Simulation::mass_properties(&flight, t)gives the rocket’s mass properties at time as the flight flew it, without every part released at or before .
A worked example
The example
released_ballast.rs
flies the project’s 54 mm (2.1 in) test design
(synthetic-54mm-three-fin.json,
a body 56.3 mm (2.2 in) across) on an I175 motor. The airframe
carries 200 g of ballast, a cylinder 50 mm (2.0 in) long and 30 mm (1.2 in) across. The ballast is on the axis, its
center 0.375 m (1.23 ft) aft of the nose tip. The rocket flies in calm standard air from a site in New Mexico 1,400 m (4,593 ft)
up. A drogue with a drag area of 0.3 m² opens at apogee. At 5 s, well after the 2.5 s burn, the ballast is let
go to tumble down under , the tumble model’s body term.
In the table the transverse inertia is about an axis across the rocket through its center of mass, the one it pitches about. What the example prints:
| time (s) | mass (kg) | center of mass (m aft of the nose tip) | transverse inertia (kg·m²) |
|---|---|---|---|
| 4.00 | 0.8188 | 0.6681 | 0.09556 |
| 6.00 | 0.6188 | 0.7628 | 0.07277 |
By hand, the rest’s center is at
aft of the tip. It moves 0.09474 m (0.3108 ft) aft, because the ballast sat forward of the center. The static margin falls by (the body’s diameter is 0.05630 m (0.1847 ft)), from 4.297 to 2.615: still stable.
At the release the rocket carries 131.5839 kg·m/s of upward momentum. Every point of the airframe moves at , so the momentum divides between the rest, 99.4433, and the ballast, 32.1406. The free-flight test below checks that the flight keeps it so.
| apogee (m) | lands at (s after launch) | landing speed (m/s) | |
|---|---|---|---|
| the rocket, ballast dropped | 1,670.0 | 276.3 | 6.15 |
| the ballast | 1,496.5 | 40.0 | 66.74 |
| the rocket, ballast kept | 1,749.9 | 253.5 | 7.07 |
-
The rocket climbs 80 m (262 ft) less without its ballast. The same drag slows a lighter rocket more.
-
It comes down more slowly under the same drogue, and so lands later. A terminal speed goes as the square root of the mass: .
-
The ballast peaks lower than the rocket, having more drag for its mass. Its terminal speed at the ground is
with the standard air’s density 1.069 kg/m³ at the site (Atmosphere), and gravity 9.79 m/s² there (Gravity). It lands a little faster, 66.74 m/s (219.0 ft/s), because it is still slowing as the air thickens.
Checks, limits and sources
How the model is checked, what it leaves out, and its sources.
How it is checked
The tests are in hpr_sim::releases and hpr_design::mass. The last column gives the value each
test measured, where its comments record one, and in brackets the bound it holds the code to.
| test | what it shows | measured (bound) |
|---|---|---|
a_part_taken_out_of_a_body_leaves_the_hand_computed_rest | a box taken out of a cube leaves the cube’s mass, center and inertia, and putting it back gives the whole | (1e-15) |
mass_properties_after_a_release_match_the_hand_calculation | the example’s rocket, with the ballast 1 cm (0.39 in) off the axis, before and after the release, against the two-body formula and the design built without the ballast; every step flies the rest’s mass and center; the part leaves from its place with | (1e-15 m, kg and kg·m²; 1e-12 m and m/s) |
a_release_conserves_mass_and_momentum_in_free_space | no air or gravity, the motor spent, the rocket turning about all three axes: the rest and the part keep the rocket’s mass, momentum, and angular momentum about their common center of mass | momentum 1.5e-13 (1e-12), angular momentum 7.3e-12 (1e-10) |
two_releases_leave_the_design_without_both_parts | two parts released at different times: between them only the first is gone, after both the rocket is the design built without either | (1e-15) |
a_payload_let_go_under_the_drogue_lands_slower_and_falls_at_its_own_speed | in uniform air, under a drogue, a release at 150 m (492 ft) on the way down: the rest lands at the lighter rocket’s terminal speed, the part at its own | (1e-6 m/s) |
a_release_comes_at_apogee_and_a_part_let_go_climbing_has_its_own | a release at apogee comes at the rocket’s apogee; a part let go climbing records its own apogee, then its landing | (1e-6 m/s at its apogee) |
a_release_at_apogee_on_a_tilted_rail_leaves_one_apogee | off a rail 5° from vertical, in wind, with and without a drogue, the flight records one apogee | exactly one |
a_part_let_go_just_before_apogee_can_make_the_apogee_there | a release that leaves the rest already falling makes the apogee, and fires the drogue, at the release; a part waiting for the apogee, listed before or after, leaves there too | exactly one, at the release |
parts_waiting_for_the_apogee_all_leave_at_it | two parts let go at apogee off the tilted rail, listed either way round, both leave at the flight’s one apogee | exactly one |
a_main_set_above_the_apogee_opens_there_whatever_leaves | off the tilted rail, in wind, a main set 1,600 m (5,249 ft) up, above the 1,533 m (5,030 ft) apogee, opens at the apogee with a part let go there, and a part set to 1,600 m (5,249 ft) leaves there too, listed either way round | at the apogee; landing under 10 m/s (33 ft/s) |
a_release_that_puts_the_rest_on_the_ground_lands_it | under a drogue, a release 5 cm (2.0 in) above the ground steps the rest’s center 9.5 cm (3.7 in) down, below it: the rocket lands at the release; climbing, the release is refused | 1e-8 m, 1e-15 kg |
the_optimum_delay_holds_a_release_on_the_motor_s_charge | a release or a mass shift fired by the motor’s ejection charge is held with the charge when the simulator works out the optimum delay (the delay that fires the charge at apogee), so the answer doesn’t depend on the delay flown | equal |
a_release_and_its_flight_read_back_as_written | a release, and a flight with a released part, write to JSON and read back unchanged | equal |
a_part_let_go_at_the_ground_has_landed | a part let go as the rocket hits the ground, already at or below it, has landed | n/a |
In the free-flight test the ballast leaves 0.146 m/s (0.48 ft/s) away from the rocket center’s velocity, because the rocket turns. Had it left at the nose tip’s velocity, the momentum would be off by 5.0e-3 of itself; at the rocket center’s, by 3.4e-3. The flight keeps it to 1.5e-13. The part’s own spin, which a point mass drops, is 1.5e-3 of the rocket’s angular momentum there.
Every refusal has a test that checks which rule fired, in releases_that_cannot_be_made_are_refused,
parts_with_no_mass_are_refused, triggers_a_release_cannot_have_are_refused_in_its_own_words and
a_release_is_refused_with_partings_or_shifts_in_either_order.
What it leaves out
- Nothing throws the part out. A spring or a charge would add to its velocity and take from the rocket’s, as an ejection’s impulse does (Recovery: ejected pieces).
- The simulator can’t combine a release with a separation, ejections or mass shifts yet.
- The part falls under one drag area from the instant it leaves. It has no devices of its own, such as a parachute, and no opening time.
- The part’s spin is dropped: 1.5e-3 of the rocket’s angular momentum in the free-flight test.
- The simulator doesn’t warn when a release leaves the rocket unstable.
The decision record, ADR-088, sets out these choices:
- the rest flying on from the same state;
- the part leaving at its own velocity and falling under a drag area you give;
- what is refused.
A part that moves along the airframe without leaving it is Moving mass.
References
- [MK] J. L. Meriam and L. G. Kraige, Engineering Mechanics: Dynamics. Chapter 4 (kinetics of systems of particles) sums a system’s momentum and angular momentum over its particles. It also covers their conservation with no external force. Appendix B has the parallel-axis theorem and the inertia tensor.
- The equations of motion the rest flies on: the RocketPy technical documentation, “Equations of Motion” v0 and v1 (Rigid-body flight).
- The tumble model’s body term: the OpenRocket technical documentation, §3.5 (Recovery: tumble).
Flight metrics
Learn how HPR Sim measures the numbers a flight is judged by, such as apogee, top speed, max q, stability margin and landing point.
In short
- What it models: the numbers a flight is judged by. These are the apogee, the top speed and
Mach number, and the peak dynamic pressure (“max q”). Then
come the boost’s peak acceleration and, kept apart, the opening shock. The metrics also give the
stability margin from the rail exit to apogee or the first
deployment. They give the largest
angle of attack that counts toward the envelope’s
high-angle flag (below). They say whether the rocket is unstable
while a motor burns (below). They give the
ejection delay that would fire the charge at apogee, and each
landing’s latitude and longitude. Anything that didn’t happen is
None, never a zero. - Sources: the margin is Barrowman’s center of pressure (to Mach 0.8; faster, as Aerodynamics describes) against the center of mass (the CG). It is defined as RocketPy defines its static margin and stability margin. The peak search is Kiefer’s golden-section search (References). Latitude and longitude come from HPR Sim’s WGS 84 conversions (Geodesy).
- How well it is validated: each number is only as good as the flight it comes from. The flight is checked against RocketPy and OpenRocket (Accuracy), and the metrics add no physics of their own. Tests check each against a hand calculation or against the simulator’s own models evaluated directly (Tests). In a test, the margin in the weakest plane is checked against the simulator’s own scan of 3,600 planes. It is also checked against one OpenRocket run that is not committed. None is validated against a real flight.
- What it leaves out:
- Fin flutter, which has its own page: Fin flutter. Its margin comes from the max q found here.
- File exports: a later part of the same milestone, M1.10c (CSV, JSON, KML and GeoJSON files).
- The descent of a separated body, such as a dropped booster. It gets a landing, but no peaks.
- A damping ratio: how fast a wobble dies out. Both margins here are static quantities.
- The margin at the flight’s angle of attack. Both margins take the air along the rocket’s axis, in the weakest direction it can cross (Stability margins). A rocket meets the air at an angle when it leaves a rail in wind. In the simulator’s model its margin there can be smaller or larger than these, depending on where its body’s lift acts. Stability margins says why they leave it out.
Purpose and use
Why the metrics are built so, and how to ask for them.
Why these rules
Loft, this project’s predecessor, got four things wrong that these metrics are built to avoid:
- It read peaks off a table of recorded rows and missed them, and it counted the opening shock as the boost’s peak acceleration (L34).
- It printed zeros for things that never happened, and never said which height an apogee was counted from (L35).
- It published margins of ±12 to 15 calibers for rockets where a margin has no meaning (L33).
- Its optimum ejection delay depended on the delay flown (L94).
Each is a numbered lesson with a test (Tests).
Getting the numbers
Fly a Simulation with a
FlightMetrics watching it. Then ask the
watcher for a FlightSummary:
let mut metrics = FlightMetrics::new();
let flight = simulation.run(&mut metrics)?;
let summary = metrics.summary(&flight, simulation.environment())?;
let best = hpr_sim::metrics::optimum_delays(&simulation)?;
A watcher keeps one flight. Call metrics.clear() before it watches another; summary refuses a
flight unless the watcher saw each of its steps once.
The example program
flight_metrics.rs
does this for Valetudo, the rocket from Getting started. It flies with a
5 m/s (16 ft/s) wind from the west and one 1.5 m (4.9 ft) parachute. The charge fires 6 s after
burnout (the end of the thrust curve), and the canopy is open 0.5 s
later. Run it with cargo run --example flight_metrics -p fusionspace-hpr-sim. It prints:
Valetudo on a K400C, a 1.5 m parachute fired 6 s after burnout, open 0.5 s later
Not yet validated: see the Accuracy page before trusting these numbers.
Heights are the center of mass's above the launch site; it starts 0.94 m up.
Apogee: 714.0 m above the site (713.0 m of climb) at 11.16 s
Top speed: 112.3 m/s at 3.00 s, 188 m up
Top Mach number: 0.337 at 3.02 s, 190 m up
Max q: 6667 Pa at 2.99 s, 186 m up
Boost acceleration: 47.2 m/s² at 0.03 s, 1 m up
Opening shock: 144.0 m/s² at 9.76 s, 698 m up
Rail exit: 16.2 m/s at 0.37 s, 17.2° off the oncoming air
At rail exit (0.37 s): static margin 3.09 cal, flight margin 3.09 cal at Mach 0.051
Least static margin: 3.09 cal at 0.37 s, 4 m up
Least flight margin: 3.09 cal at 0.37 s, 4 m up
Optimum delay: 10.6 s after burnout at 3.26 s (flown: 6.0 s), for an apogee of 778.7 m at 13.83 s
Landing: 32.990000° N, 106.967084° W: 272.6 m east and 0.0 m north of the site, at 11.6 m/s, at 78.67 s
The 6 s delay is too short:
- The charge fires at 9.26 s, and the canopy opens at 9.76 s: about 4 s (13.83 − 9.76) before the apogee it would have reached.
- The rocket still rises 1.4 s more, to an apogee of 714.0 m (2,343 ft).
- With the charge held, it would have coasted to 778.7 m (2,555 ft) at 13.83 s. That is the apogee of the Getting started flight, whose drogue fires at apogee.
- So the optimum delay is 10.6 s. The opening shock, 144.0 m/s², is three times the boost’s 47.2 m/s², and it is not counted as the boost’s peak.
- Don’t size a shock cord from the 144.0 m/s²; it is no bound either way. The canopy reaches full drag at line stretch, 0.5 s after the charge. It has no filling time (the simulator’s default), so the rocket doesn’t slow while it fills. The shock reads high. The simulator also leaves out a canopy’s drag overshoot near the end of filling: that reads low (The opening load).
Top speed comes at 3.00 s, before the 3.26 s burnout. That is because in the thrust curve’s last moments the motor pushes less than drag and gravity pull back.
Heights and peaks
Which heights a summary gives, and how each peak is found between the integrator’s steps.
Heights
Every height is of the center of mass: its
ellipsoidal height above the launch site’s, the same as
a flight’s height_above_ground_m. The center of mass starts above the site, because the rocket
stands on the rail: 0.94 m (3.1 ft) for Valetudo. So the summary gives both:
apogee.height_above_ground_m: 714.0 m (2,343 ft), above the site.apogee.gain_m: 713.0 m (2,339 ft), the climb from where the center of mass stood at launch. OpenRocket’s altitude counts this way. A flight started in the air (Simulation::run_free) has no launch height, and no climb:None.
After a separation with nothing left to burn, the summary’s apogee
is the apogee of the part that keeps the nose (body 0). If an
ejection parts the rocket, or that part, while it still climbs, the
summary has no apogee (None): what the charge leaves at the nose is lighter, and coasts to a
height of its own. Ejected pieces gives each case.
A flight ends when its center of mass comes back down to the site’s height, so a landing is at height 0 by this measure.
The rail exit speed is the center of mass’s speed over the ground when the aft edge of the aft-most rail button or lug passes the rail’s top, or the rocket’s aft end does with no guides (Flight). On the rail the rocket doesn’t turn, so every point of it moves alike, but the center of mass also slides forward as the propellant burns. So the printed speed reads a little higher than the guides’.
Peaks
Each peak comes with its time and its height. The watcher looks at every step the integrator takes (Time integration and events), not at a table of recorded rows:
- It evaluates the equations of motion at each step’s start, middle and end.
- It fits a parabola through the three values. When the parabola bends down with its top inside the step, the peak may lie inside. A golden-section search then looks for it on the step’s dense output (the integrator’s smooth curve through the step). The search runs to a billionth of the time since launch, or of 1 s early in the flight.
- It keeps the largest of what the search finds and the three samples.
Thrust-curve knots, the times where a motor’s tabulated thrust changes slope, end steps. So a spike in the thrust curve is a step’s end, and is never averaged away. Loft took its peak acceleration from a finite difference of the recorded speed, and read it low. Valetudo in a vacuum shows how much. The watcher’s peak matches the hand value from the motor and the masses within the test’s 1e-6. A finite difference of the speed recorded at 100 Hz reads it more than 1% low.
| Peak | What it is |
|---|---|
| Top speed | The center of mass’s speed relative to the ground, after liftoff |
| Top Mach number | The airspeed over the local speed of sound |
| Max q | The largest dynamic pressure, on the airspeed |
| Boost acceleration | The largest acceleration of the nose tip, from liftoff until a recovery device opens |
| Opening shock | The largest specific force while a device is open: the drag and any thrust over the mass, the opening load over the mass, without gravity. It follows the simulator’s inflation model (Recovery) |
The boost acceleration is of the nose tip, which is the body’s origin in the simulator’s frames. It differs from the center of mass’s only by the rocket’s turning and by the center of mass’s slow drift forward as propellant burns. The turning is small in a straight boost. It is relative to the launch frame and straight from the equations of motion, so it includes gravity’s pull, as a trajectory’s acceleration does.
The opening shock leaves gravity out. Under a canopy the motion’s acceleration is the drag and the
weight over the mass. Falling, the drag points up and the weight down, so the motion’s
acceleration is the drag over the mass less g, and it would read the load low by up to g. The
opening shock is the specific force instead, the drag over the
mass (with a motor still burning, the drag and the thrust together). That is what an accelerometer
reads, and with no motor burning it is the opening force over the mass (Knacke, NWC TP 6575,
p. 5-50, gives the opening force as ). In a canopy’s steady fall it is
1 g, so it reads at least about that once the canopy reaches its steady fall. A canopy opened
slower than its steady fall reads less if it doesn’t get there while it is counted: the flight
reaches the ground first, or an ejection parts the stack or the part
that keeps the nose, which ends the count. After a separation with
nothing left to burn, the part that keeps the nose (body 0) is counted until it ejects a piece
itself or lands, and the part dropped aft never is
(the opening load).
Each separated body has its own figure beside the flight’s, body_max_descent_acceleration_m_s2,
in m/s²: the same specific force over that body’s own flight and mass
(how to read it).
In the example above the canopy opens while the rocket still climbs, with the drag and the weight both pointing down, so the motion’s acceleration there (the
plot’s spike) is close to g above the opening shock of 144.0 m/s².
A test opens a canopy 5 s after apogee, falling, and finds the shock equal to at the
opening to 1e-9. At the ground, in the canopy’s steady fall, the specific force is g and the
motion’s acceleration nearly nothing
(the_opening_shock_is_the_drag_over_the_mass_without_gravity).
Nothing is kept while the rocket sits on the pad. A rocket that never lifts off has no peaks at
all: None, not zero.
Stability
The margin, the largest angle of attack, and the unstable-under-power flag.
Stability margins
The margin is how far the center of pressure lies behind the center of mass, in calibers of the reference diameter :
Here is a station measured aft of the nose tip, and is component ’s normal-force slope. The simulator gives two margins at each instant:
- Static margin: the center of pressure at zero angle of attack and Mach 0, against the center
of mass of that instant. This is RocketPy’s
static_margin. It changes only as propellant burns. - Flight margin: the center of pressure at the flight’s own Mach number, still with the air
along the axis, against that instant’s center of mass. It is defined as RocketPy’s
stability_marginis.
RocketPy’s min_stability_margin takes the least over its whole flight, on the rail and in the
descent too. It reads it at its solver’s steps, so it can differ from HPR Sim’s least below. No
page compares HPR Sim’s margins with RocketPy’s yet.
Against OpenRocket, HPR Sim’s margin at the flight’s Mach number is within 0.016 calibers on 41 of
the 53 flights of OpenRocket’s own examples. That is in calm air at rod clearance, where a rocket
is still slow. HPR Sim’s margin in this comparison has the air along the rocket’s axis (the 0°
plane), as OpenRocket’s does. It isn’t the margin in HPR Sim’s weakest plane (below). On
[C6-7; B6-0] of Pods--powered with recovery deployment, HPR Sim’s margin at rod clearance in
the report is +3.74 calibers along the axis. But hpr sim prints a least margin of −4.21 in the
weakest plane. At rod clearance in the 0° plane, HPR Sim’s margin differs from OpenRocket’s on:
- the Tube fin rocket: 1.08 calibers below, tube fins;
- the three-stage example’s three flights: 0.039 to 0.058 below, cause not yet sized, #185;
- the five of Pods--airframes and winglets: 0.071 to 0.076 above, the flattering side, #325 and #326;
- the three of Pods--powered with recovery deployment: 0.070 above, also not yet traced;
- 35 flights of private designs: from 0.017 lower to 0.11 higher, cause not yet traced (Accuracy).
The Mach number moves the center of pressure. On a rocket with fins only at the tail it generally moves aft until supersonic theory starts for the fins, Mach 1.2 or later. Their slope grows, and from Mach 0.8 their own center moves aft too. Past that their slope falls and the body’s lift can grow, and the center of pressure mostly moves forward again (Your rocket’s center of pressure). Valetudo is slow: at its rail exit, at Mach 0.051, both margins read 3.09 calibers. Near Mach 1, HPR Sim puts the Arcas Robin’s center of pressure up to 2.36 calibers behind the wind tunnel’s (Normal force through Mach 1). So there its flight margin reads high.
Both margins are the weakest direction’s. The air can cross a rocket from any direction around
its axis, and for most rockets the margin is the same in every one. A fin set of one or two fins
breaks that. It carries of its force in the plane at roll angle , for fins at
angles . The share is Niskanen’s (2009, eq. 3.51, as in Fins). So a rocket with one has a margin for
each direction, and the simulator gives the least, the direction it was found in as roll_rad.
Until #329, the simulator’s margins were the 0°
direction’s alone, which can be the strongest. A rocket whose fin sets each have three or more fins,
or that flies a normal-force table, keeps its one margin, bit for bit.
A worked case: the sustainer of OpenRocket’s Pods--powered with recovery deployment example has
a single fin at 0° and a two-fin strake set at 90°. At Mach 0.2, after the booster drops, its
margin is +1.86 calibers with the air crossing at 0°. There the single fin lies edge-on and the
strakes carry the force. At 45° it is +0.17. At 90° the strakes lie edge-on and only the single
fin works: −3.44, unstable. OpenRocket 24.12 was asked for that sustainer at 90° in a scratch run (not
committed). It puts its center of pressure at 0.2954 m (0.969 ft) with 3.49. HPR Sim’s are 0.2993 m (0.982 ft) and
3.47. For one of its staged configurations, [C6-7; B6-0], hpr sim’s least margin was +1.56 calibers and is now −4.21, at 0.86 s. That is the sustainer’s margin at the split itself, the moment
the booster drops. The sustainer’s own motor is just lit and still full, and the air is at Mach 0.07. The −3.44
is a later instant, at Mach 0.2. In the conditions of OpenRocket’s record, both programs’ flights of
that configuration turn over before apogee. OpenRocket’s record has its site at 28.61° N, where the Earth’s rotation tips
HPR Sim’s flight. HPR Sim’s angle of attack passes 90° at 2.25 s. At hpr sim’s default site, on the
equator, nothing tips HPR Sim’s flight: it stays upright and reaches 251.3 m (824 ft)
(the format guide).
The simulator finds the least in closed form, not by a scan
(weakest_margin). Each part’s slope varies as
, so the net slope and its moment do too.
Three directions, 0°, 60° and 120°, give each sum’s , and . The center of pressure
is foremost where
with
and and the coefficients of and . The margin’s conditioning (below) is checked at its own worst direction the same way. Each root and the 0° direction are evaluated through the model, and a direction where no margin can be given wins over any number.
Both margins leave out the angle of attack. In the simulator,
body lift grows with the angle and acts at each body’s side-view centroid, and
the center of pressure moves toward it. Where that centroid lies ahead of the zero-angle center of
pressure, the margin at an angle shrinks. On a long body with small fins it can lie behind, and the
margin grows. No test pins either direction. But the angle is not a steady property of
the rocket. Valetudo leaves its rail 17.2° off the oncoming air in the example’s 5 m/s (16 ft/s) crosswind.
Near apogee the angle swings toward 90° as the rocket slows and tips over. If the least margin
followed the angle, it would land wherever the simulator chose to stop counting large angles. The
simulator models no fin stall that could say where that is. For the
margin at a given angle, call margin with
Flow::new(mach, angle_rad, roll_rad).
The watcher keeps both margins in FlightMetrics::stability(). The series starts at the rail exit
and ends at apogee or when a recovery device opens, whichever comes first. Before the rail exit the
rail holds the rocket, so its margin says nothing about how it flies.
The summary’s least margins cover the same span. Each is looked for inside every step, as a peak is (Peaks). Wherever the margin is defined at a step’s start, middle and end, a parabola goes through the three values. When it bends up with its bottom inside the step, a golden-section search finds the bottom. A later least replaces an earlier one only when lower by more than rounding, so a flat least keeps its first time. A margin with a sharp corner near a step’s end can still hide from the parabola.
- On four test flights, and in the example, both leasts come at the rail exit. There the rocket is heaviest and its center of mass furthest aft. Flown in steps of at most 1 ms, those flights give the same leasts to a millionth of a caliber.
- On a two-stage test flight the least flight margin comes inside a step, after the split. There it matches a scan of every step at 201 points to 1e-7 calibers, and is never above it.
After a powered separation the margins are the sustainer’s, in its own diameter. The split has two entries in the series: the stack’s, then the sustainer’s.
When there is no margin
As the net slope goes to zero, the air’s loads become a pure couple: a turning moment with no line of action. The quotient then runs away. That is how Loft came to publish margins of ±12 to 15 calibers.
The simulator judges the net slope against the sum of its terms’ sizes:
Each part the model adds up acts at a station on the rocket, within its length . The center of pressure then lies within of every station. So a fractional error in one part’s slope moves the center of pressure by at most about (to first order). A part that is a pure couple on its own (below) has no station, and doesn’t count it.
- A rocket whose parts all push the same way has . A 1% error then moves its center of
pressure by at most 1% of its length. All 13 designs in
validation/designs/stay below 1.5. That holds at Mach 0, 0.3, 0.8, 1.2 and 2 and at angles of attack of 0°, 5°, 10° and 20°. - At , a 1% error in one slope can move the center of pressure by a tenth of the
rocket. Past that, or when the net slope is not positive, the simulator gives no margin and no
center of pressure:
None. The limit is a chosen bound on that sensitivity, not a measurement.
The pitch-moment slope about the center of mass is always given, because it stays finite:
A negative turns the nose back into the wind. With a margin defined, .
A worked case, with no fins, pinned by a test:
-
The rocket has a conical nose 0.3 m (0.98 ft) long of radius = 0.05 m, then a 0.5 m (1.6 ft) tube. Last comes a conical boattail 0.4 m (1.3 ft) long, narrowing to a radius . So = 0.1 m.
-
Barrowman gives the nose a slope of 2 at 0.2 m (0.66 ft). The boattail gets , at a distance in meters of
-
So , with . The margin is given for , an aft radius of 34.66 mm (1.4 in) or more.
-
The center of mass is at 0.5 m (1.6 ft).
| Boattail’s aft radius | Net slope, per rad | ratio | Margin | Pitch-moment slope , per rad |
|---|---|---|---|---|
| 40 mm (1.6 in) | 1.28 | 2.13 | −7.46 cal | +9.55 |
| 35 mm (1.4 in) | 0.98 | 3.08 | −11.2 cal | +10.98 |
| 34.5 mm (1.4 in) | 0.952 | 3.20 | none (the quotient: −11.7 cal) | +11.11 |
| 21.5 mm (0.85 in) | 0.370 | 9.82 | none (the quotient: −37.1 cal) | +13.72 |
| 5 mm (0.20 in) | 0.020 | 199 | none (the quotient: −741 cal) | +14.82 |
With no fins, every one of these rockets is unstable: its center of pressure lies ahead of its center of mass, and is positive. The cut is not about how large the margin is. The 35 mm (1.4 in) and 34.5 mm (1.4 in) rows have margins near −11 calibers; what differs is whether the quotient can be trusted.
A component can be a pure couple on its own. A step down in radius followed by a flare back up cancels its own slope and still turns the rocket. keeps its moment, which a test also checks.
The largest angle of attack
max_angle_of_attack_rad is the largest angle between the rocket’s axis and the air flowing past
it, in radians. Its span is the one the envelope’s high-angle flag watches
(Validation plan: the operating envelope;
ADR-179):
-
from more than 1 s after the rail exit, as the first second off the rail is the expected transient in a crosswind;
-
to apogee or the first deployment, the span of the least margins above;
-
only at instants where a 15° angle would give a normal force of at least a fifth of the rocket’s weight:
with the dynamic pressure, the reference diameter and the flight margin’s normal-force slope.
The angle is read at each step’s start, middle and end. Unlike the peaks, it has no search between them, so an excursion inside one step can be missed. Above 15°, the flight’s
envelope_flags include high_angle_of_attack.
The floor is there because near apogee every flight whose path turns over passes 15°. There the air
is too weak to turn it: gravity does. Valetudo, one of RocketPy’s examples, launched off an 84° rail
in calm air, passes 15° about 0.9 s before apogee. It is then at 16.7 m/s (55 ft/s) through the air, a little faster
than its 16.2 m/s (53 ft/s) rail exit. There a 15° angle would give a normal force of 1.0% to 1.5% of its
weight. So an error in the aerodynamics at that angle barely moves it. A wind layer met at speed is
different. Valetudo climbing into 30 m/s (98 ft/s) of wind 300 m (984 ft) up passes 15° where that force is 62% of its
weight. The flag is raised. On the tests’ RocketPy rockets, turn-overs give 0.7% to 5.0% and
wind layers met at speed 62% to 141%. The floor of a fifth, chosen rather than measured, sits between. The
tests a_tilted_calm_climb_passes_15_degrees_only_with_too_little_force,
a_wind_layer_met_at_speed_raises_the_high_angle_flag and
a_wind_layer_met_in_a_fast_coast_raises_the_high_angle_flag (in the flight engine’s metrics.rs) fly
these cases.
Unstable under power
A flight that is unstable while a motor burns raises one of two flags, and its apogee is not a prediction (#335). Unstable means the air turns the rocket away from its path instead of back. Where it ends up then depends on small disturbances, and on aerodynamics that hold only at small angles of attack. The simulator still flies it, and the flag changes no number: it marks the flight’s path and apogee as not a prediction. A flight raises at most one of the two flags.
unstable_under_power: the static margin falls below zero while a motor burns. The center of pressure is then ahead of the center of mass.unstable_without_margin: no static margin can be given while a motor burns (When there is no margin), and the pitching moment’s slope is above zero. It is raised only when the first flag isn’t.
min_powered_static_margin_cal is the margin the first flag reads. It is the least static margin
in the weakest plane (Stability margins), over the moments a motor burns.
The span runs from the rail exit to apogee or the first deployment. The margin is found inside steps, as the other least
margins are. A step counts when the thrust at its middle is above zero. The simulator ends a step at
every ignition, thrust-curve point and burnout. So a motor that burns at a step’s middle burns
through all of it, and the margin at the burnout itself counts. A margin of exactly zero raises
nothing; any margin below it does.
max_powered_moment_slope_per_rad is what the second flag reads. The simulator gives no margin where the
parts’ normal-force slopes nearly cancel, or their sum is not positive. There the center
of pressure would be noise. The moment about the center of mass is still well defined there:
with and the normal-force slope and station of part , their sum, and the center of mass. Every station is aft of the nose tip, and is the reference diameter. A negative turns the rocket back toward its path; a positive one turns it away. The simulator keeps the largest at each powered step’s start, middle and end where the margin is undefined, without searching between them. A of exactly zero raises nothing; any above it does. Without this flag, a rocket so unstable that its margin is undefined would raise no warning at all, while a milder one would.
Only the moments under power count. A rocket that turns then is driven along its new heading by
its own motor, so the path flown follows the turn. A rocket that is unstable only in the coast,
after its motors burn out, raises neither flag. It has no thrust to carry it off its path. The
least static margin over the whole span, min_static_margin_cal, still prints its margin
there.
For example, OpenRocket’s example Pods--powered with recovery deployment, flown on [C6-7; B6-0]
or [C6-7; 2× A3-4, B6-0], separates at 0.86 s. The sustainer left has a static margin of −4.21 calibers with its C6 still burning. On [C6-7; B6-0]:
static margin 2.05 calibers off the rail; least -4.21 calibers, at 0.86 s, before apogee
apogee 251.3 m above the site at 5.74 s, not a prediction: unstable under power
warning: unstable: the static margin falls to -4.21 calibers at 0.86 s while a motor burns. The rocket is unstable under power: the air turns it away from its path rather than back, and its apogee is not a prediction
For the second flag, take RocketPy’s Valetudo with its fins taken off. Give it a conical tail that narrows from the body’s 40.45 mm (1.6 in) radius to 22 mm (0.87 in) over 0.08 m (0.26 ft). At the rail exit its net slope is 0.59 per radian against a sum of sizes of 3.41. That is too small for a margin, but is +43.9 per radian:
apogee 399.1 m above the site at 8.46 s, not a prediction: unstable under power
warning: unstable: while a motor burns, the pitching moment turns the rocket away from its path (C_mα +43.9 per radian at 0.25 s). HPR Sim can give no static margin then. The rocket is unstable under power, so its apogee is not a prediction
With the tail ending at 30 mm (1.2 in) instead, the margin is defined, −34.37 calibers, and the first flag
fires in its place. These figures are from a run on October 6, 2026; the test
(sim_flags_a_rocket_unstable_where_it_has_no_margin) pins only the flag and a slope above 1.
hpr sim prints the warning: unstable: line and marks the apogee for either flag. Its JSON
lists the flag under flags. The library has it in FlightSummary::envelope_flags, and Python in
Flight.envelope_flags. When this was written (October 6, 2026), none of the 25 public .ork files
and 12 validation designs that hpr sim flies offline raised either flag. That was on their default
configurations off an 85° rail in calm air and in 8 m/s (26 ft/s) of wind. No test or report pins that
count.
What it leaves out:
- A rocket unstable only after its motors burn out raises no flag, as above.
- It reads the static margin and at Mach 0, not at the flight’s Mach number.
- is read only at each step’s start, middle and end, not searched between. A moment slope above zero for less than half a step, with no margin, can pass unseen.
- A flight that tips over above 15° raises the high-angle flag (The largest angle of attack) as well. A stable rocket in a strong wind can raise that one alone.
Five of the tests in Tests pin these flags, four at their edges. In hpr-cli,
sim_flags_a_rocket_unstable_where_it_has_no_margin flies the Valetudo example above.
Ejection and landing
The delay that fires a charge at apogee, and where each body lands.
Optimum ejection delay
The optimum delay is the time from a motor’s burnout to apogee: the delay that fires its charge at
the top. optimum_delays flies the rocket again
with every recovery charge held, so that it coasts to the apogee it would reach untouched. So the
answer belongs to the rocket, its motors and its air, not to the delay flown. A charge that fires
too early cuts the coast short. Loft’s optimum then came out too short as well, which advised an
even shorter delay. HPR Sim gives the same optimum for delays of 1 s and 20 s.
- A separation with nothing ahead of it left to burn is part of the recovery, so it is held too. A two-stage rocket that separates some seconds after its last burnout gets the same optimum for delays of 3 s and 30 s.
- A powered separation still happens. The motors in the booster it drops have no optimum: their charges fire in the booster, which never reaches the sustainer’s apogee.
- A motor that burns out after the apogee, or never lights, has none either. A flight that never
reaches an apogee (it never lifts off, or hits its time cap) gives
None.
Landing points
A landing is where the center of mass came back down to the site’s height. It is given as a WGS 84 latitude and longitude, and as east and north meters from the site in its local frame. The speed at the ground hit is given too. The flight’s own landing is the stack’s (the whole rocket before any separation), or after a powered separation the sustainer’s. Each separated body that lands has its own landing, with its body number. Body 0 keeps the nose, and 1 is the stages aft of the split.
A flight that did not land has no landing and no ground-hit speed: None. A test checks this for a
flight stopped by its time cap, and the JSON it writes, where the missing values are null.
Tests and references
The tests that pin these metrics, and the sources they follow.
Tests
In crates/hpr-sim/src/metrics.rs, unless named otherwise:
| Test | What it pins |
|---|---|
static_margin_undefined_when_cn_alpha_near_zero | The boattail table above, against Barrowman by hand, to 1e-9 relative, on both sides of the limit (L33) |
ordinary_rockets_keep_their_margin | All 13 validation designs keep their margin at Mach 0, 0.3, 0.8, 1.2 and 2 and at 0°, 5°, 10° and 20°, with below 1.5 |
a_pure_couple_keeps_its_moment | The step and flare above: against the hand value, to 1e-9 |
a_normal_force_table_gives_its_own_margin | A table’s margin and against its own numbers |
the_least_margin_is_the_weakest_plane_s | Six layouts of a single fin and a two-fin set, at Mach 0.1, 0.6 and 1.5 and three centers of mass: the least margin is never above any of 3,600 scanned planes’, and within 1e-5 calibers of the scan’s least, including where the weakest plane lies between the fins’ planes; fin sets of three or more fins keep the margin along the axis, bit for bit |
peak_acceleration_is_analytic_and_excludes_opening_shock | The boost’s peak in a vacuum against the hand value, to 1e-6; a 100 Hz finite difference reads it more than 1% low; an opening shock over three times the boost’s is kept apart (L34) |
the_opening_shock_is_the_drag_over_the_mass_without_gravity | A canopy opened falling, 5 s after apogee: the opening shock is at the opening to 1e-9, about g above what the motion’s acceleration reads there by the hand relation ; at the ground, in its steady fall, the specific force is g up to 1e-3 and the motion’s acceleration under 1e-3 g (#1258) |
the_part_that_keeps_the_nose_has_its_own_opening_shock (in recovery.rs, as the next two rows’ tests are) | After a separation with nothing left to burn, the stack having opened nothing: the summary’s shock is the nose part’s at its instant opening to 1e-9, at that opening’s time and height, and not the aft part’s, which is more than 1.5 times larger (#1519) |
the_nose_parts_shock_tops_inside_a_step_under_a_filling_canopy | The nose part under a canopy that fills over 1 s in an 8 m/s (26 ft/s) crosswind: each step’s specific force is the sample’s drag area, airspeed and mass by hand to 1e-12; the summary’s shock is the top of a scan of the steps that meet the filling, 2,000 intervals each, no lower to 1e-9 and no more than 1e-6 higher, where the steps’ starts, middles and ends alone read more than 1e-5 low |
a_split_with_an_ejection_keeps_the_lead_pieces_shock_out, the_nose_parts_shock_stops_counting_where_an_ejection_parts_it | An ejection that parts the stack or the part that keeps the nose ends the count: a nose cone ejected at the split, its device opening at over 50 m/s (164 ft/s), leaves the summary no shock; one ejected after the nose part’s drogue opened leaves the drogue’s to 1e-9, though the cone’s own shock is more than 5 times larger |
an_ejection_in_the_part_dropped_aft_leaves_the_flights_shock_alone (in recovery.rs) | Each separated body’s own opening shock (#1532), at an instant opening to 1e-9 over that body’s own mass: the two pieces of a dropped part that parts at a charge of its own, each more than 1.5 times the flight’s shock, which is the same to the bit with that charge and without. The tests of the rows above pin the same for the part dropped aft at a separation, the airframe behind an ejected nose cone’s joint and the cone itself |
each_bodys_own_shock_is_its_largest_step_peak_and_a_nan_stays, a_summary_refuses_separated_bodies_steps_from_another_flight | A body’s figure is the largest of its steps’ peaks and the first of equals; a step with no load makes no entry; a step’s peak that is not a number stays. The summary refuses a watcher that saw a step of a body the flight doesn’t have, or not each step of a body it has once |
a_nose_cone_ejected_on_the_climb_after_a_split_leaves_the_summary_no_apogee (in recovery.rs) | After a separation with nothing left to burn, the part that keeps the nose pushes its nose cone off 5 s later, still climbing at over 30 m/s (98 ft/s): the cone tops out more than 50 m (164 ft) below the whole part’s apogee, and the summary’s apogee is None; with the charge at the part’s apogee or 3 s after it, the summary keeps the whole part’s apogee (#1531) |
the_nose_parts_kept_peaks_are_a_running_maximum_with_the_same_shock (in recovery.rs), body_0s_kept_peaks_are_the_first_of_equals_and_each_larger_one | The watcher keeps a step’s peak for the nose part only when it beats the last one kept. On three separation flights (an instant opening, a drogue then a pushed-off nose cone, a canopy filling in a crosswind) the summary’s shock, time and height equal those from every step’s peak, with at most a twentieth of the steps kept; equal peaks keep the first, and smaller ones add nothing (#1533) |
unlanded_flight_has_no_ground_hit_speed_and_outputs_name_datum | None and null for an unlanded flight; the launch height against the rail’s geometry, to 1e-9 relative (L35) |
optimum_delay_independent_of_flown_delay | Delays of 1 s and 20 s give the same optimum, equal to a flight with no recovery (L94) |
peaks_are_refined_inside_steps | On three rockets, max q and top Mach are above every row of a 1 ms record, and the record’s best row is within 0.01% of them; on Valetudo max q comes before top speed, and top speed before top Mach |
landings_are_placed_on_the_ellipsoid | A landing more than 100 m (328 ft) downwind, against the radii of curvature at the site, to second order |
stability_is_kept_from_rail_exit_to_apogee | The series’ ends; the static margin at the rail exit and, in a crosswind, the flight margin at the flight’s Mach number, against the model and the masses directly, to 1e-12; the least flight margin is at or below every entry |
least_margins_do_not_depend_on_where_steps_end | Valetudo in calm air off a vertical and an 84° rail and in a crosswind, and Prometheus: both leasts are at the rail exit, and agree with steps of at most 1 ms to 1e-6 calibers |
a_least_margin_between_step_ends_is_found | A margin of across a step: the search finds 2 at 0.37 s; a margin falling across the step, or undefined in its middle, is not searched |
a_summary_needs_the_flight_it_watched | A watcher refuses a flight when it missed some of its steps or also watched another flight, naming the steps it saw, and sums up one that ended without a step; a flight started in the air has no launch height, and one started on its way down keeps no stability |
the_powered_margin_counts_only_while_a_motor_burns | A margin falling 1 caliber a second across a burnout at 1 s: −2⁻³⁰ calibers at the burnout raises the flag, +2⁻³⁰ doesn’t, nor does −1 in the coast after; a least inside a powered step is found by the search; a NaN under power is kept, one in the coast isn’t; a margin of −10⁻¹³ replaces +10⁻¹³ though the two are closer than the tie |
a_moment_slope_without_a_margin_counts_only_while_a_motor_burns | With no margin, a of +2⁻³⁰ per radian under power raises unstable_without_margin, −2⁻³⁰ doesn’t, nor does +2⁻³⁰ after the burnout at 1 s; a NaN under power is kept; a slope where the margin is defined doesn’t count; a margin below zero as well raises only unstable_under_power |
a_rocket_without_fins_is_unstable_under_power | Valetudo with its fins taken off raises unstable_under_power at or before its burnout; stock, its least margin under power is above 1 caliber and it raises nothing |
envelope::tests::the_stability_flag_starts_just_below_a_zero_margin | The flag from the least negative f64 down; none at 0, −0 or above |
envelope::tests::the_moment_flag_starts_just_above_zero_and_only_without_the_margin_flag | unstable_without_margin from the least positive f64 up, and for a NaN; none at 0, −0 or below; never beside unstable_under_power |
staging::tests::metrics_follow_a_powered_separation | Both landings; the sustainer’s diameter after the split, with its own entry there; both leasts against a scan of every step at 201 points, to 1e-7 calibers, the flight margin’s inside a step; no optimum for the booster’s motor |
staging::tests::a_held_flight_holds_a_separation_after_the_last_burnout | A split after the last burnout is held: the same optimum for delays of 3 s and 30 s |
References
- J. Kiefer, “Sequential minimax search for a maximum”, Proceedings of the American Mathematical Society 4(3), 502–506, 1953. The golden-section search.
- J. S. Barrowman and J. A. Barrowman, “The theoretical prediction of the center of pressure”, NARAM-8 research and development report, 1966. The slopes and stations, as Aerodynamics uses them.
- S. Niskanen, Development of an Open Source model rocket simulation software, MSc thesis, Helsinki University of Technology, 2009, eq. 3.51. A fin’s share of its force in the plane the air crosses in, which makes a one- or two-fin set’s margin depend on that plane.
The decision behind these choices is ADR-077, from the M1.10a milestone.
Fin flutter
See how HPR Sim applies Martin’s criterion for fin flutter, where bending and twisting feed each other, to your fins and your rocket’s flight.
In short
-
What it models: whether a fin may flutter, meaning its bending and twisting feed each other until the fin shakes itself apart. HPR Sim gives two readings of one criterion. The first is Martin’s own chart check: is the fin on the flutter side of the line his flight data draws? The second is the ratio of the criterion’s flutter speed to the rocket’s airspeed at the flight’s peak dynamic pressure. The first decides; the second alone is not a safe line. When fins flutter, a guide, reads both on the guides’ rocket.
-
Sources: D. J. Martin’s criterion in NACA TN 4197 (1958), eq. 18, and his figure 3 (References). The figure separates missile and wind-tunnel wings that fluttered from those that didn’t. The fin’s stiffness enters as its shear modulus. The simulator has one, with its source, for 14 of its built-in materials.
-
How well it is validated: HPR Sim reproduces Martin’s formula and both of his worked examples (Tests). That includes his verdicts on three metals and his titanium design. His safe/unsafe line is a band that this project measured off his printed chart: 0.25 to 0.31 (The line in Martin’s data). His unfailed wings flew to at least Mach 1.3. Nothing here is checked against a hobby rocket, but for one fin seen fluttering in flight whose material is inferred (below; evidence row G22). Where the source allows two readings, the simulator takes the one with the lower flutter speed. That doesn’t make the whole result conservative: nothing shows that it is. Of the published tests the project has set against HPR Sim’s speed, at least four kinds of fin or wing fluttered below it, the flattering side. Each figure is HPR Sim’s speed (from eq. 18, with the thickness ratio taken over the root chord) over the measured onset, so above 1 means HPR Sim’s speed is too high:
- plies that couple bending to twist, as an off-axis layup’s do: two of MIT’s three laminated plates (M2 and M3), 1.13 to 1.42 over the thesis’s two sets of ply properties (measured flutter onsets, §2);
- built-up wings, a skin over spars: the RAE’s rocket-flown designs of ARC Report 2944, 0.92 to 1.41 over all 22 wings (Mach 0.44 to 0.98), median 1.13, 21 above 1, and 1.24 to 1.41 on the wings with a 25% spar flown at Mach 0.75 to 0.98, the top resting on one reading of the report’s stiffness column (measured flutter onsets, §3); and up to 1.47 on ARC Report 2949’s swept wings, their stiffness taken normal to the sweep (transonic flutter onsets, §4);
- stiffness inboard with the tip and trailing edge soft, such as a fin that tapers in thickness or a stiff core with soft edges: Langley’s rocket-model wings W2 (1.05), W4 (1.14) and D2 (1.43 or more, a lower bound) (fin flutter tests, §2);
- solid swept fins: in Langley’s transonic tunnel, tested at Mach 0.66 to 1.42, each wing’s worst point 1.21 to 1.37, from a 60° compreg wing (1.37), a 45° resin-paper wing (1.31) and a 45° solid magnesium wing (1.21), and the 60° wings read high at every Mach number tested; other readings of the 60° wing’s stiffness move its worst point anywhere from 0.91 to 1.80 (transonic flutter onsets, §2 and §3); and ARC Report 2949’s four solid spruce swept wings, rocket-flown, 1.17 to 1.31, or up to 1.42 with their stiffness taken normal to the sweep (the same note, §4).
A tunnel wing in light air reads high too: AGARD wing 445.6’s weakened model, 1.24 to 1.50 at Mach 0.90 to 1.07, where the air was thinnest; eq. 18 has no term for the air’s mass against the wing’s, so it reads high there (measured flutter onsets, §5, a test too different from a fin to count).
Flat plates and other fins of one material read below 1, the safe side, as tested: 0.14 to 0.65 on the counted plates, all clamped at the root (measured flutter onsets), and 0.35 to 0.84 on the uniform fins of fin flutter tests, a few held more softly (the ASROC plate clamped over 6.0 in of its 8.9 in root, Liège’s plates not rigid in plunge). A hobby rocket’s fin seen fluttering in flight, PSAS’s LV2c, reads 0.49 to 0.82 if its fins were G10, as inferred, and 1.23 to 1.51 if they were aluminum, at the speed it was seen fluttering, which may lie above the onset (§5). A softer root lowers the onset: the ASROC missile fin’s plate with its root restraint cut reaches 1.10 on discarded data (§3), and on two root tests the highest safe-side ratios, 0.82 to 0.84, would become 0.90 to 1.09 (§4, an inference). None of these was a fin glued to a tube, and the figures are not a bound: a fin of one of these kinds may flutter further below HPR Sim’s speed than any of them did.
-
What it leaves out: sweep, and how the fin is mounted. Martin’s wings were clamped at the root, and a fin glued to a tube is less stiff there. Also left out are stall flutter at high angles of attack and Mach-number effects, such as a dip near Mach 1. So are the rocket body’s own bending and fins that aren’t trapezoids. G10/FR-4, the commonest fiberglass fin sheet, has no built-in modulus (Shear moduli).
The model
What flutter is, Martin’s criterion for its speed, and what that speed means against the line his data draw.
What flutter is
Air pushing on a fin twists it a little. The twist changes the fin’s angle to the air, so the push changes, and the fin bends. Below a certain speed the fin’s stiffness damps this out. Above it, each cycle feeds the next, and a fin can fail within a second. The speed depends on the fin’s shape and thickness, how stiff its material is in shear, and the air it flies through.
The criterion
Martin starts from Theodorsen and Garrick’s flutter speed for a wing that bends and twists (his eq. 1, from their NACA Report 685 of 1940). He reduces it to a few numbers from one fin’s outline. For a trapezoidal fin with root chord , tip chord , span and thickness :
| Symbol | Meaning | For a trapezoid |
|---|---|---|
| Panel aspect ratio: span over the chord halfway out | ||
| Taper ratio: tip chord over root chord, 0 to 1 | ||
| Thickness ratio | ||
| The fin’s effective shear modulus, Pa | the material’s (Shear moduli) | |
| , | The air’s static pressure and speed of sound | from the atmosphere |
| Where the section’s mass sits: this fraction of the chord behind the quarter chord | 0.25, at mid-chord | |
| Air’s ratio of specific heats | 1.4 |
Eq. 18 gives a flutter speed through a denominator , in pascals:
Martin prints the constant in pounds per square inch (psi) at sea-level pressure ,
which he rounds to 39.3. His (eq. 19) is psi, and . The constant is derived, not fitted. Stiffer or thicker fins flutter faster: grows as and as . At a fixed speed of sound, thinner air raises it as .
A flutter dynamic pressure. The air enters only through , and the dynamic pressure is . So the criterion fixes a dynamic pressure at , the same at every height:
A fin flying at dynamic pressure is below by the ratio . That makes the flight’s least ratio the one at its peak dynamic pressure, “max q”, which Flight metrics already finds between the integrator’s steps.
The line in Martin’s data
Eq. 18’s is not the speed at which a fin is known to flutter. Martin plots against for missiles and wind-tunnel models (his figure 3). Wings that fluttered or failed lie above a shaded band, and wings that flew to at least Mach 1.3 without known failure lie below it.
This project measured the band on a 250 dots-per-inch scan of the figure. Both log axes were calibrated on their tick marks. The band’s edges were traced in 69 pixel columns from = 0.05 to 10 × 10⁶ psi. The band runs at = 0.25 to 0.31 all along that range, from wood to steel. In eq. 18’s terms that is = 3.2 to 4.0, so Martin’s line sits where is 1.8 to 2.0 times the speed of sound. HPR Sim calls this ratio the figure 3 ratio:
| Figure 3 ratio | Martin’s data |
|---|---|
| above 0.31 | mostly wings that fluttered or failed (a few that didn’t lie there too) |
| 0.25 to 0.31 | the band: marginal |
| below 0.25 | wings that flew to at least Mach 1.3 without known failure |
Martin takes where the wing flies. At the launch site’s pressure, the highest a flight sees, the ratio is at its largest. Figure 3’s axis runs from 0.05 to 20 × 10⁶ psi (0.34 to 138 GPa) in . Balsa’s modulus is left of it, so its ratio is an extrapolation.
Which reading decides. The figure 3 ratio does: it is Martin’s own check, and a fin must be below the band. alone is not a safe line, at 1 or at any fixed number. At the flight’s max q the two are tied by , with the Mach number there. So the band is at from about to . A fin is below the band only if is above about : 1.5 at Mach 1.3, but 4.0 at Mach 0.5. Martin’s data show nothing about a fin above the band on a rocket slower than Mach 1.3: treat it as not shown to be safe.
The halved constant. Loft, this project’s predecessor, wrote the constant as per psi, half of . So its flutter speeds were too high, about 41%, on the unsafe side (a lesson from Loft). Apogee Components’ Peak of Flight newsletter printed the same halved form in issues #291 (2011) and #411 (2016), and corrected it in #615 (2023). When fins flutter shows what it does to the guides’ rocket.
Worked examples
Martin’s two examples, then a rocket’s fins in a flight.
Martin’s worked examples
Martin gives two examples (pp. 6–7). The first is a wing with , 4% thick, untapered and ground-launched. He reads its off his figure 4 as “about 1.25 × 10⁶ psi” and judges the wing by material. The second picks titanium and holds figure 3’s ordinate to 0.8 × 10⁶ psi, well under titanium’s modulus, “to allow a reasonable margin of safety”. It then asks how thick the wing must be at each aspect ratio.
| Example | Martin | HPR Sim from eq. 19, psi or % | Difference |
|---|---|---|---|
| for , 4% thick | “about 1.25 × 10⁶” psi | 1.228 × 10⁶ psi | −1.8% |
| Titanium at 0.8 × 10⁶ psi, | 2.5% thick | 2.54% | +1.6% |
| Same, | 4.5% | 4.61% | +2.4% |
| Same, | “about 6.5”% | 6.43% | −1.1% |
Martin read these off a log-scale chart. He printed them on grids of 0.05 × 10⁶ psi and half a percent (his thicknesses all end in .5). Each of HPR Sim’s values rounds to his on that grid.
His verdicts on the first wing are the margin half of the example. The titanium row is his second example, at the ordinate he chose. HPR Sim checks them with the moduli Martin marks on figure 3’s axis, each a small box read off the same scan:
| Material | Martin’s mark, 10⁶ psi | Figure 3 ratio | Martin says | Against the band |
|---|---|---|---|---|
| Magnesium | 2.40 to 2.63 | 0.47 to 0.51 | “in the flutter region” | above |
| Aluminum | 3.82 to 4.28 | 0.29 to 0.32 | “marginal” | on it |
| Steel | 8.92 to 11.3 | 0.11 to 0.14 | “probably safe” | below |
| Titanium, his second example at 0.8 × 10⁶ psi | 5.78 to 6.34 | 0.13 to 0.14 | his design, with “a reasonable margin of safety” | below |
A rocket’s fins
The example program fin_flutter (in crates/hpr/examples/) takes the repository’s synthetic
54 mm (2.1 in) rocket. Its three fins are 3.175 mm (0.125 in) thick. Each has a 150 mm (5.9 in) root, a 60 mm (2.4 in) tip
and a 70 mm (2.8 in) span.
It flies the rocket on an I175 motor from a site 200 m (656 ft) up, and prints:
Panel: aspect ratio 0.667, taper ratio 0.400, thickness ratio 0.0212
Max q: 72455 Pa at 2.09 s, 432 m above the pad
Top speed: 355 m/s at 2.10 s; top Mach number: 1.05 at 2.10 s
Martin's band (figure 3): D/G_E from 0.25 to 0.31
material G (GPa) q_f (kPa) V_f 0 m (m/s) V_f 3 km (m/s) V_f/V at max q D/G_E
aluminum_6061 26.200 836.3 1169 1356 3.40 0.083
carbon_fiber 4.826 154.1 502 582 1.46 0.450
birch_plywood 0.750 23.9 198 229 0.57 2.893
basswood 0.511 16.3 163 189 0.47 4.246
balsa 0.138 4.4 85 99 0.25 15.680
The columns V_f 0 m and V_f 3 km are eq. 18’s flutter speed in standard air at sea level and
3 km (1.9 mi) above it. D/G_E is the figure 3 ratio at the launch site’s pressure.
- Aluminum passes both readings. Its figure 3 ratio is well below the band, and at max q the rocket flies at under a third of . A ratio below the band is no guarantee on its own: Langley’s D2 wing, its stiffness inboard, sat below it at 0.17 to 0.18 and fluttered from about Mach 1.69 (fin flutter tests, §2).
- Carbon fiber at 3.175 mm (0.125 in) has of 1.46. But its figure 3 ratio, 0.45, is above the band, where most of Martin’s wings fluttered or failed: not shown to be safe. Its modulus is a unidirectional ply’s of one aerospace prepreg. A ±45° layup of it would be stiffer, but wet-laid or woven hobby sheet may be softer.
- Plywood, basswood and balsa fins of this size fail both: at max q the rocket flies at 1.75 times plywood’s .
CI checks that the program still prints exactly this.
In code, with a FlutterPanel (its API page
has a worked example that CI runs):
// `fin_set` is a design's `FinSet`; `summary` a flight's `FlightSummary` (Flight metrics).
let panel = FlutterPanel::of_fins(&fin_set)?;
let g = materials::shear_modulus_of(&fin_set.material).unwrap().shear_modulus_pa;
let chart = panel.figure_3_ratio(g, launch_pressure_pa)?; // against FIGURE_3_BAND
let margin = panel.margin(g, &summary)?; // V_f/V at max q; `None` if it never flew
FlutterPanel::new takes , and directly. Martin’s figure 4 covers from 0.5 to 3
and from 1% to 10%. The example’s 0.667 is inside. Outside that range the numbers are an
extrapolation.
Readings and materials
Readings and shear moduli.
Readings where the source leaves room
Most of these give the lower of the flutter speeds the source allows. Two can go the other way: an airfoiled fin’s modulus, and a booster’s max q.
- Thickness ratio at the root. Martin’s wings keep one thickness ratio from root to tip. A hobby fin keeps one thickness, so its ratio grows toward the tip. The simulator takes the root’s, the smallest.
- A solid fin’s is its material’s . Martin says a solid wing of aluminum plots at aluminum’s modulus (p. 6), and the simulator does the same. His definition, (eq. 12), assumes a thin airfoil’s torsion constant (eq. 10). A flat plate’s is , which would double and raise the flutter speed by . The simulator keeps the lower reading. The exception runs the other way. For a fin with a NACA four-digit section, eq. 12 gives . The simulator’s for such a fin is then up to 2.9% high (rounded up from ).
- Martin’s taper factor. His derivation carries a factor . Here corrects the twisting frequency for taper (his eq. 8) and gives the chord three-quarters of the way out (his eq. 14). He replaces the factor with . The two agree at and are 3% apart at . Between, is up to 47% larger (at ), which lowers there by up to 17.5%. The simulator keeps his form, since his figure 3 was drawn with it.
- Every fin set sees the whole flight’s max q. A booster’s fins leave at the separation, so the flight’s max q can come after they are gone. Their true is then at least the one given. That holds as long as the booster’s own dynamic pressure after the separation stays below the flight’s peak. The simulator doesn’t check that.
Shear moduli
The criterion needs the fin’s shear modulus in its own plane. hpr_design::materials::SHEAR_MODULI
gives it for 14 built-in materials, each with its source, page and the web address it was read
from. shear_modulus_of finds a design’s copy of a built-in material by its name and density. Where a source gives a
range, the lower value is kept. Metals are given in ksi (1,000 psi) and Msi (10⁶ psi); 1 Msi is
6.895 GPa.
| Material | shear modulus (GPa) | Source | Basis |
|---|---|---|---|
| Aluminum 6061 | 26.2 | MIL-HDBK-5J, Table 3.6.2.0(b1): 3.8 × 10³ ksi | stated |
| Aluminum 7075 | 26.9 | MIL-HDBK-5J, Table 3.7.6.0(b1): 3.9 × 10³ ksi | stated |
| Steel (plain carbon) | 75.8 | MIL-HDBK-5J, Table 2.2.1.0(b): 11.0 × 10³ ksi | stated |
| Titanium Ti-6Al-4V | 42.7 | MIL-HDBK-5J, Table 5.4.1.0(b): 6.2 × 10³ ksi (TIMET: 6.2 and 6.66 Msi) | stated |
| Carbon fiber/epoxy | 4.83 | NCAMP (a composite-material qualification program) report on Hexcel 8552 AS4 tape: in-plane 0.70 Msi, room temperature | stated |
| Birch plywood | 0.750 | Riga Wood Plywood Handbook, Table 4.11: panel shear | stated |
| Birch (yellow) | 1.04 | Wood Handbook ratio × bending modulus × 1.10 | derived |
| Oak (northern red) | 1.11 | same | derived |
| Maple (sugar) | 0.873 | same | derived |
| Spruce (Sitka) | 0.725 | same | derived |
| Basswood | 0.511 | same | derived |
| Balsa | 0.138 | same | derived |
| Acetal (Delrin) | 1.06 | data sheet | derived |
| Nylon 6/6 | 0.490 | data sheet , conditioned | derived |
How the derived values are made:
- Woods: is the shear modulus in the plane along the grain and along the growth rings. The simulator takes the Wood Handbook’s ratio (Table 5-1) and multiplies it by an estimate of , the stiffness along the grain. As the table’s footnote says, that estimate is the wood’s bending modulus at 12% moisture raised by 10%. is the smaller of the two in-plane ratios for every wood listed. Eastern white pine is not in Table 5-1, so it has none. Martin marks solid wood at 0.070 to 0.120 × 10⁶ psi (0.48 to 0.83 GPa). The handbook’s birch and oak are above that.
- Plastics: an unfilled plastic taken as isotropic (the same in every direction), from its data sheet’s tensile modulus and Poisson’s ratio . Nylon soaks up water. Its conditioned value, measured after it has, is less than half the dry one.
- Carbon fiber: a unidirectional ply’s in-plane . That is a 0/90 laminate’s in-plane shear modulus. Plies at ±45° raise it several times, so for such a laminate this reads low.
No source found states a shear modulus for G10/FR-4: its data sheets give flexural moduli only. There is none for PLA, ABS, PETG, polycarbonate or acrylic either. For those, pass your own from a measurement or your supplier. A woven glass/epoxy laminate is not isotropic, so doesn’t apply to it.
Tests and references
The tests that pin the criterion, and the sources it comes from.
Tests
In crates/hpr-sim/src/flutter.rs, unless named otherwise:
| Test | What it pins |
|---|---|
flutter_denominator_matches_tn_4197_eq_18 | The constant against Martin’s 39.3 psi, and against eq. 18 on three panels at two pressures, to his rounding; twice Loft’s constant (its lesson) |
martins_worked_examples | Both of Martin’s examples on his grid, and his three verdicts and his titanium design against the band, through figure_3_ratio (the tables above) |
scaling_laws_in_thickness_shear_modulus_and_pressure | as , , and , to 1e-12; the same in three atmospheres |
the_halved_constant_reads_a_higher_flutter_speed | The halved constant printed in Peak of Flight #291 and #411, and Loft’s, reads above eq. 18’s flutter speed on three panels in two airs, and higher by the same factor: the flattering side, which When fins flutter marks |
taper_factor_against_the_frequency_factors | against : 3% at , at most 47% at |
the_margin_is_the_flights_least_at_its_peak_dynamic_pressure | On the flight of Valetudo (a RocketPy example rocket), the margin is at max q and at or below every row of a 1 ms record; from each row’s pressure and speed of sound agrees with , to 1e-12; no peak gives None, a peak that isn’t a number is refused |
a_trapezoidal_fin_set_gives_its_panel, out_of_range_inputs_are_refused | A fin set’s , and ; elliptical and reverse-tapered fins, a taper outside 0 to 1 and inputs that aren’t positive are refused by name, from code and from JSON |
hpr_design::materials::tests::shear_moduli_reproduce_the_sources | Each built-in modulus against its source’s numbers |
References
- D. J. Martin, Summary of Flutter Experiences as a Guide to the Preliminary Design of Lifting Surfaces on Missiles, NACA TN 4197, 1958. Appendix, eqs. 1 to 19, pp. 11–15; examples, pp. 6–7; figures 3 and 4, p. 19.
- T. Theodorsen and I. E. Garrick, Mechanism of Flutter: A Theoretical and Experimental Investigation of the Flutter Problem, NACA Report 685, 1940. Martin’s ref. 6, the source of his eq. 1; not read for this project.
- MIL-HDBK-5J, Metallic Materials and Elements for Aerospace Vehicle Structures, 2003.
- Forest Products Laboratory, Wood Handbook, FPL-GTR-190, 2010, Tables 5-1, 5-3a and 5-5a.
- NCAMP, Hexcel 8552 AS4 Unidirectional Prepreg Qualification Statistical Analysis Report, NCP-RP-2010-008 Rev D, 2011, Table 3-3.
- Riga Wood, Plywood Handbook, 2022, Table 4.11.
- Celanese, Zytel 101L NC010 data sheet, 2023; Delrin 100P NC010 data sheet.
The decision behind these choices is ADR-078, from the M1.10b milestone.
Flight-log readings
See which readings HPR Sim takes from a flight log alone, the bound each states, and when it withholds one instead of guessing.
In short
- What it models: the readings taken from a flight log on its own, with no design file and no simulation. They are liftoff, apogee and its time, the top speed in the climb, and landing. The rest are the flight time, the mean rate of descent, and each canopy’s descent rate with the main’s opening. They come from any logger’s height track. The logger’s own barometric altitude will do. So will a pressure turned into a height by the 1976 standard atmosphere, or an altitude kept in a column of its own. Two logs of one flight go on one timeline. An accelerometer along the rocket’s axis adds the top acceleration and burnout. Without one, burnout is a floor: the top speed’s time less its bound. Each reading states a bound on its error and where it came from, or is withheld with one of 28 reasons. It never guesses. A GNSS (GPS) height gives no reading.
- Sources: the running median is the Hampel filter at threshold zero, as Pearson and colleagues define it. An accelerometer’s trace is cleaned by the same filter at threshold five. The landing’s thresholds and the least climb are those of Debrief, the project owner’s earlier flight-log analyzer. The flat top of a clipped accelerometer and the marks that tell the main’s descent from the drogue’s are Debrief’s too, each with HPR Sim’s changes. The bounds’ terms come from the noise model of the synthetic flights and the hypsometric equation. They also come from the safety codes’ 3:1 thrust to weight and 20° rail. Another source is the National Weather Service’s rate for a rapid change of pressure. Another is the drag that sets a canopy’s rate and slows its fall after it opens. The last is the 1976 standard atmosphere’s density scale height (References). The rest are HPR Sim’s choices, recorded in ADR-281, readings on every logger, and ADR-283, the rest of the readings.
- How well it is validated: on the synthetic flights’ tuning set, every reading given stayed within its bound. The set is 171 flights logged by a barometer. Each was logged again at 36 rates and steps and cut 6 ways. The 71 of them with an accelerometer were read again with it at 500, 100 and 20 samples a second. Thirty-eight were read with it set to ±8 g. The largest share of its bound any error took was 0.737, on a top acceleration, and 0.717 on an apogee (Checked against). The bounds were tuned on those same flights, so this shows they are wide enough there, not on flights held apart. On an invented PerfectFlite log, every reading lands within its bound. Each but burnout’s floor also lands within the tighter one its test works out (evidence row G10). A real log has no truth beside it. The 1,058 records of the project’s sample logs show which readings each logger gives (an apogee from 592 of them), not how right they are. All twelve readings’ 90% intervals pass the two-sided test of ADR-257, calibrated intervals on the synthetic sets A and B, after their points were fitted on 2,000 flights of their own, and a floor’s lower end passes that test’s lower tail, a clipped top’s on tops written near an imposed clip (evidence row G34).
- What it leaves out: the Mach number and dynamic pressure; a lower end on an apogee floor, a top speed floor or a top whose burn the log ends in (#1071). Loggers noisier than the tuning set’s six simulated logger profiles and rockets slower off the pad than 2 g can be read outside their bound. Air more than 15 K from standard is out too, and so is any correction for the day’s air, which sits in the bound instead. Where the log records the pad’s temperature and its height above sea level (from its pressure, an altitude above sea level, or a stated ground elevation), a day past 15 K is noted with its size (A day past 15 K). A canopy’s filling time isn’t in the opening’s bound (#779). A fall under no canopy is read as one canopy’s (#780). A canopy far above the tropopause is out. Accelerometer noise that runs from sample to sample is out; it would narrow burnout’s bound (#787). A top clipped at the high-g part’s range is out; no tuning flight reaches one. A board’s three axes give no top acceleration (#781; What it leaves out).
The method
Why these rules
Code: hpr_flightdata::readings
(API reference); on the command line
hpr analyze; from Python, FlightLog.readings()
(Reading your own logger). The readings came with
M4.2d, the milestone that added hpr analyze, on
PerfectFlite’s logs alone (ADR-108, the decision on how a log is read).
M7.2b, readings on every logger, takes them from every
logger’s height track and gives each a bound held on the synthetic flights
(ADR-281). M7.2c, the rest of the readings, adds the top acceleration and
burnout from an accelerometer along the rocket’s axis. It adds the flight time as a reading
of its own, and the descent under each canopy (ADR-283).
A barometric altimeter’s height track is a good record of a flight’s heights, with flaws a reading must survive:
- Steps. It moves in steps of its resolution, a foot for a PerfectFlite, so the top of the climb sits flat for several samples.
- Pulses. When the ejection charge fires, the pressure inside the electronics bay jumps. For a tenth of a second the height swings tens of feet away from the truth. Take the highest sample as the apogee and you read that swing.
- Noise and drift. The sensor’s noise is correlated from one sample to the next, so it doesn’t average away quickly, and its zero drifts.
- The day’s air. A logger turns pressure into height by the standard atmosphere. So on a day warmer or colder than standard, every height is off by a share of itself.
So every height and time comes from the track after a running median, which removes the pulse. Each reading states a bound that covers the rest. Each has a rule that says when the log can’t support it.
The height track
Every reading of a height or a time comes from one track, the first of these the log holds. The
code each reading names as its source says which:
source | the track | its zero |
|---|---|---|
barometer | the logger’s own barometric altitude, the record’s primary track | the logger’s zero, which it sets on the pad |
pressure | a pressure channel, turned into a height by the 1976 standard atmosphere, as every logger documented does it (the height formulas note) | the pad, found from the samples |
altitude_channel | a barometric altitude kept in a channel, above the ground or above sea level | the ground for the first; the pad, found from the samples, for the second |
gnss | a GNSS receiver’s altitude | none: no reading is taken |
accelerometer | not a height: the accelerometer along the rocket’s axis, for the top acceleration and burnout alone (The accelerometer) | a fall in vacuum reads 0 and the pad +1 g, gravity put back where the logger took it out |
A GNSS height gives no reading. A receiver’s navigation filter lags a climb and overshoots its top
by more than a barometer’s bounds allow (receiver_lag). Its fix drops out or lags at liftoff
(receiver_dropout). An altitude whose sensor the log doesn’t state, such as a table’s Altitude
column read by its header, gives none either (unstated_sensor). A barometer’s bounds can’t be
stated for it. A column mapping can mark such a column as the barometer’s own track
(Reading your own logger).
A track’s step is the logger’s resolution where its reader knows it, a foot for a PerfectFlite. Otherwise it is the smallest gap between two of the track’s values. A pressure’s step becomes a step in height that grows as the air thins, , with the standard atmosphere’s density at that height. At sea level, 10 Pa is 0.83 m (2.7 ft).
The running median
The running median replaces each sample with the median of the samples within places of it. The window is cut short at either end of the log. The code sets from the log’s own sample interval so that the window spans 0.3 s. At a PerfectFlite’s 20 samples a second, , seven samples.
Pearson and colleagues define the Hampel filter by the window’s median and its scale
A sample more than from is replaced by . At every sample is replaced, and the filter is the running median (§2, eqs. 1 and 2).
Two properties make it the right tool here:
- It removes any pulse up to samples wide. Such a pulse holds at most of the window’s samples, so the median is never one of them. On the public log below, the ejection pulse’s high side is two samples wide.
- It reads a clean peak a little low, and never high. At 20 samples a second, the apogee of a
noise-free trace reads at most 0.077 m (0.25 ft) low. The steps behind that number:
- At the highest sample, of the window’s samples lie within places of it ( is rounded up). So the median is no lower than the altitude that far away.
- The true peak lies within half a sample of the highest sample, so that altitude is at most from the true peak in time.
- At apogee the vertical speed is zero, so drag has no vertical part and only gravity curves the path. In that time the height falls at most .
- With and , that is , or .
Debrief uses the Hampel filter at over the same window. FusionSpace HPR doesn’t, because of what the public Pnut log shows. Around its ejection pulse the trace dips below itself just before the pulse and stays lower after it. Those samples sit in the pulse’s own window and widen its scale . So the Hampel filter keeps the pulse. The result’s highest value is the pulse’s 1,028 ft above the altimeter’s zero, against the 1,009 ft apogee the altimeter states. After the running median, the apogee reads 1,010 ft above the zero, which is 1,009 ft above the pad.
The pad and the climb
The readings measure heights from the pad, so the pad must be found first, and only from samples taken before the rocket moved. Three rules do it, each with a number set from the noise:
-
The allowance. The filtered track may sit up to 2 m (6.6 ft) from the pad and still be on it. If the pad’s own filtered samples stray farther, the allowance is that far instead. One step is added to either. The 2 m (6.6 ft) is four times the synthetic flights’ fast correlated barometer noise, 0.5 m (1.6 ft), HPR Sim’s choice. Half a foot, the rule before M7.2b, read liftoff up to 6 s early on a noisy 500 Hz barometer. The noise lifted the pad’s last samples above it. An allowance of 1 m (3.3 ft) read one tuning flight 6.8 s early, against a 4.5 s bound. One of 2 m (6.6 ft) never did.
-
The climb begins at the first filtered sample twice the allowance and a step above where the log starts. That is 4.61 m (15.1 ft) on a PerfectFlite, whose step is a foot. The pad’s noise lifts the filtered track by at most the allowance, from below at the start or from above at the climb. So twice that is out of its reach. Bad samples at the log’s very start would lift that start, so the first three are judged first. One or two of them are bad, and the readings leave them out, if they stand more than this rise and 9 m (30 ft, three times the barometer’s noise) above the second lowest of the samples after those three, over the median’s window and at least five. Two cases are left alone:
- All three stand that far above. That is a fall of the track’s own, which reads like a pressure pulse on the pad at ignition.
- The track stays at their level again, for at least as long as a rocket at 2 g takes to leave
that band, before a top further above it than a coast through the band reaches. That level is
the pad. A low stretch far below it counts in the pad’s reach, so the apogee is withheld as
no_climb.
Eight sample logs have good first samples and then fall 31 to 654 m (102 to 2,146 ft) into the climb: a disturbed pad, below.
Samples low at the start are not left out, as a logger’s zero before the climb looks the same. At 5 and 2.5 samples a second they read the apogee high. At those rates on a log from launch, and more so the faster the rocket climbs, two high samples at a level the climb itself soon reaches can read it low, past its bound (an open issue).
-
The pad is the median of the samples up to the last one within half that rise of the start, before the climb. Half the rise is 2.30 m (7.6 ft) on a PerfectFlite. The median means that no one sample’s jitter sets the pad, and the half rise means the climb lends it few samples. A track that rests at two levels before the climb is read as two levels, below.
The pad’s error. A log that starts just before liftoff holds little of the pad, and a rocket may already be moving when its first sample is taken. Take a rocket that leaves the pad at or more and is moving at when the log starts. It climbs in the time the track stays within half the rise of its start. That climb can’t pass the rise , the noise allowed at either end. So its samples bound , and with it how far up the rocket may already be:
That much enters the liftoff, apogee and landing bounds. The acceleration is the least the safety codes allow. The NAR’s high-power code asks that a rocket weigh no more than a third of its motor’s certified average thrust. Tripoli’s allows less than 3:1 only with an active stability system. Thrust three times the weight leaves twice gravity to climb with. The tuning set’s slowest rocket averages 30 m/s² over its first 5 m (16 ft).
On the public Pnut log, for example, the filtered track stays within 2.30 m (7.6 ft) of its start for 0.40 s. Suppose a rocket at climbed no more than the 4.61 m (15.1 ft) rise in that time. It was moving at no more than 7.60 m/s (24.9 ft/s) when the log started, from . So it can’t have been more than , or 1.47 m (4.8 ft), up. That is within the allowance, so the pad stands, and the 1.47 m (4.8 ft) is part of the apogee’s 27.4 m (90 ft) bound.
A short pad. Where the pad’s error could pass the 2 m (6.6 ft) allowance, the pad is short
(short_pad). Either the log starts after liftoff, as a logger that records from launch writes its
zero and then the climb. Or it holds too little of the pad to tell liftoff by. What happens next depends on
the track’s zero:
- A zero set on the pad, the logger’s own altitude as its format’s reader reads it: the heights are read from that zero. Liftoff is withheld unless a sample before apogee sits within the allowance of the zero. The top speed is withheld too if it peaks within 0.5 s of the log’s start. A faster climb may have come before the first sample there.
- A zero only a word vouches for. A mapped table’s altitude, or a channel whose header calls
it above the ground (#646, a
wrong unit or a wrong zero in a mapping). Such a zero may sit anywhere within 19.9 m (65 ft) of
the pad (below). With no pad of samples, nothing places it better
than the first sample does. That sample reads
sabove the zero after a climb of up to the pad’s errorC. So the zero stands betweensbelow the pad andC − sabove it. The heights are read from it, as from a zero set on the pad. The larger distance,max(|s|, min(19.9 m, C − s)), enters the liftoff, apogee and landing bounds as the pad’s error. A log too sparse to bound the climb before it takes the whole 19.9 m (65 ft). - Any other track, a pressure or an altitude above sea level: no zero places the pad, so every reading is withheld. The top acceleration is withheld too, as it is searched for up to apogee.
A disturbed pad. A rocket on the pad doesn’t sink below it. Yet some logs fall tens to hundreds
of meters straight into the climb, by its look a pressure pulse at ignition
(#1101). If the fall’s samples
counted as pad, every height would read high. Where the filtered track falls below its start by more
than the rise plus 0.015 m/s (0.05 ft/s) of drift since the log began, then climbs without resting,
the top speed is withheld (disturbed_pad). To rest is to stay within half the rise of one height
for as long as a rocket at takes to cross the rise, 0.69 s on a PerfectFlite; a fall to a level
the track holds is no disturbance. The apogee is still read, from the samples resting before the
fall, else the logger’s zero; with no zero, nothing is. Liftoff’s bound reaches back over the fall
to the last sample on the pad, with no 90% interval; with none, liftoff is withheld. On the two such
records that state their apogee, the reading comes within about 0.3 m (1 ft) of it; the first sample as the pad
reads up to 268.8 m (882 ft) high, the fall’s end up to 339.9 m (1,115 ft)
(the survey’s report).
Two levels. A logger switched on above the pad and carried down to it rests at two levels, and
so does a reading the pressure moves before liftoff. The track can’t tell the two apart. Where it
falls as above and the medians of its stay at the start and of its last rest before the climb lie
more than the rise apart, the pad is that last rest, read back from the rest’s end while its
samples stay within the rise of each other. The gap between the two levels enters the pad’s
error, as either may be the pad, so the bounds hold whichever of the two it was, while the pad’s
noise stays within the rise and bar the short stay below. The pad reported is the last rest’s
level alone (#1158). A synthetic log resting
30 m (98 ft) up for 5 s, then 3 s on the pad, reads its 98.1 m (322 ft) apogee as 97.96 m
(321 ft) on the logger’s zero, with a bound of 40.9 m (134 ft)
(the_pad_is_the_last_rest_before_the_climb). The climb is still found from the log’s start. A
fall from the last rest into the climb is a pulse, as one from the start is.
Each reading
Each reading names its method and its provenance. The provenance is measured when the
reading is read straight off the track, and derived when it is worked out from it. It is
clipped for a top acceleration at its part’s range or held flat at its top. Such a top is a
floor, its clip saying which (The accelerometer). There are nine methods:
| reading | rule | method | provenance |
|---|---|---|---|
| liftoff | the last sample before apogee whose filtered height is within the pad’s allowance | last_on_the_pad | measured |
| apogee | the filtered track’s highest value; its time the middle of the run of samples that hold it | highest_filtered | measured |
| time to apogee | apogee’s time less liftoff’s | ||
| top speed | the steepest least-squares slope of the filtered track over 0.5 s, from liftoff to apogee | steepest_slope | derived |
| landing | the first sample after apogee back within the pad’s allowance that stays below it, 3 m (9.8 ft) and a step for a second, and no sooner than a fall from rest in vacuum could lose that height | back_on_the_pad | measured |
| flight time | landing’s time less liftoff’s | liftoff_to_landing | measured |
| mean descent rate | the filtered height lost from apogee to landing, over the time taken, part of landing’s reading | ||
| top acceleration | the axial accelerometer’s highest reading over the burns, searched from liftoff’s earliest time (the log’s start if liftoff is withheld), gravity in; a floor where it clipped, or where the thrust doesn’t end on the channel | highest_reading | measured, or clipped |
| burnout | from the accelerometer: where its reading is least after it falls through zero, the end of the thrust’s fall | least_after_thrust | measured |
| without it: a floor, the top speed’s time less its bound; the reading is the top speed’s time | speed_peak | derived | |
| drogue descent | the filtered height lost from apogee to the main’s opening, over the time taken | leg_chord | derived |
| main descent | the same from the main’s opening, found back from landing, to landing; from apogee where the descent shows one canopy | leg_chord | derived |
Liftoff is the last sample before the track shows the rocket climbing out of the pad’s reach. So it comes after the true liftoff by the time that climb took.
A floor holds one way only, and has up to three numbers. The reading is where the rule lands. For
burnout without an accelerometer, that is the top speed’s time, 2.20 s on the invented PerfectFlite flight
below. The floor is that reading less its bound: 2.20 s less
1.32 s, 0.88 s, which hpr analyze prints as “no sooner than 0.88 s”. The truth is at or after
the floor, or for a top acceleration at or above it. It may be later, or higher, by any amount.
The third, the lower end, is tighter: the figure the truth stayed above in about 19 of 20
synthetic flights (A floor’s lower end). The floor is the limit nothing fell
below on the tuning set. The errors the tuning set reports for a floor are the reading’s, not the
floor’s (Checked against; the glossary).
The top speed is HPR Sim’s own, worked out from the heights rather than read from a speed
column a logger writes. Every logger’s track can give one, and its bound can be stated. A 0.5 s
fit averages the barometer’s correlated noise down to a few meters a second. It is short enough to
keep most of the peak. It needs at least 5 samples in the fit, so a log sampled slower than every
0.125 s has none (sampled_too_slowly). It is withheld at 227.7 m/s (747 ft/s) and above
(transonic). That is Mach 0.8 in the coldest air the bounds allow below 20 km (12 mi). The
standard atmosphere’s 216.65 K less 15 K gives that air. From Mach 0.9 the
pressure behind an ogive’s shoulder jumps on its way to Mach 1.0 (the Mach error note §1–2).
So a speed derived from the heights there can be far off. Debrief’s two refusals stay (implausible_speed and noisy_speed; When a reading is
withheld).
Landing is the first sample within the pad’s allowance, at least Debrief’s 2 m (6.6 ft), that meets one more test. From it, the track stays under the allowance and 3 m (9.8 ft) more, and a step, for Debrief’s second. So it comes before touchdown by the time the last few meters took. That is about 0.4 s under a main at 6 m/s (20 ft/s) on a PerfectFlite’s log. A barometer drifts during a flight, so the ground can read a little above or below the pad. The mean descent rate covers the drogue and the main together. Each canopy’s own rate is read from the shape of the descent (The canopies).
The flight time is a reading of its own, flight_time: landing’s time less liftoff’s, its
bound the sum of theirs, so it needs both. Landing’s reading doesn’t carry it.
The top acceleration comes only from an accelerometer, never from the heights. Differencing
twice turns a track’s steps into spikes: at 20 samples a second, a one-foot step differenced twice
is , over 12 g. So a log with no accelerometer gives none
(no_accelerometer), and its burnout is a floor: the top speed’s time less its bound.
The accelerometer
The top acceleration and burnout come from an accelerometer along the rocket’s axis, and only from
one the log names as that axis (ADR-283 §1–4). A table in the code lists each logger
family’s axial column, such as AltOS’s acceleration or the Raven’s Axial Accel (Gs). It also
lists whether the family says its readings hold gravity, and the part’s range where the family
states one. A column whose name holds the word axial, as a table’s or a mapping’s may, is read
with neither known. A board’s three axes don’t say which lies along the rocket, and their
magnitude never falls below zero at burnout. So they give neither reading (axis_unstated).
AltosUI writes acceleration for every board, but an EasyMini or a TeleMini has a barometer and
no accelerometer (the Altus Metrum manual’s specifications). So on one the column is the board’s
estimate from its barometer, not a sensor’s reading. It gives no reading here. Each AltOS board
with an axial accelerometer adds columns to the file. They are an inertial unit’s (accel_x and
on: TeleMega, EasyMega) or a GPS receiver’s (latitude and on: TeleMetrum). So an AltOS CSV with
neither is taken for a barometer-only board’s and gives no top acceleration
(no_accelerometer). Its burnout comes from the top speed. An export that lost those columns
loses its reading too.
A TeleGPS, a GPS receiver with no accelerometer, would pass if its export wrote the column. On
the sample logs 17 records are so withheld, 16 AltOS CSV and one AltOS table.
What an accelerometer reads. It doesn’t feel gravity’s pull. It feels every other force on the
rocket, over its mass: the specific force. Along the axis that is
the thrust less the drag, over the mass. Standing on the pad, the part reads +1 g, the pad’s push.
Coasting, it reads the drag’s pull back, below zero. Falling in vacuum, it would read 0. Some
loggers write what the part reads; others take gravity’s 1 g out on the pad, so the pad reads 0. HPR
Sim puts the 1 g back where it was taken out, so every reading is the specific force, +1 g on the
pad. So is the top acceleration: it holds the 1 g, where hpr sim’s max_acceleration_m_s2 is the
rocket’s own acceleration, from the equations of motion. Less 1 g, the top acceleration is the
rocket’s own acceleration up on a vertical climb.
Which way up, by three witnesses. A part mounted nose down writes the thrust negative, and its readings are turned over. Which way up is settled as gravity is (below), by three witnesses. Each is read on the trace as written, before it is turned. Each rests on physics that holds whether or not the logger takes gravity out. Each reads within 0.25 g of its level:
- the pad, the steady level before the trace first moves 1 g from it, either way. That counts if it comes no later than liftoff’s latest time by the heights. At rest a part that holds gravity reads +1 g nose up and −1 g nose down. One that takes it out reads 0 either way. So about 1 g says nose up, about −1 g nose down, and about 0 says nothing;
- the coast, the last 1 s before apogee’s earliest time, read only where a coast was flown. The window is after liftoff’s latest time (the log’s start, where liftoff is withheld). It is also after the trace first moves from its pad, and before an apogee the log doesn’t end at. Coasting, a part reads the drag’s pull back, , or where gravity is taken out. It is never above 0 nose up while it coasts, its thrust ended and no canopy open, and the mirror nose down. So 0.75 g or more below 0 says nose up, and 0.75 g or more above it says nose down. A drag only pushes the reading further. Nearer 0 says nothing;
- the thrust, on the cleaned trace, found as the burns are (both below), from liftoff’s earliest time. The first span, in either sign, that holds past 2 g for 0.5 s says its sign. The exception is a span of the other sign that comes first. A short burn’s span does so before a heavy drag’s, and a knock’s rebound before the thrust. The thrust then says nothing. Where no span holds that long, the sign every span shares says, a short burn’s; spans both ways, or none, say nothing. The span that says must rise by liftoff’s latest time, as the thrust is what lifts the rocket. Where liftoff is withheld because the log starts in the climb, it must rise within 0.5 s of the log’s start. One that rises later is a drag after a thrust too weak to read past 2 g, or a second burn, and says nothing.
The way is settled when the pad or the thrust says and no witness disagrees. A thrust read at the
start of a log whose liftoff is withheld settles only beside a coast that says the same way. A log
that starts after burnout has the drag there instead, past 2 g the other way. With no pad to
tell by, nothing else could catch it. The coast alone
settles nothing. Its second can hold a weak thrust still burning or a canopy opened early,
either of which reads the other way. So it can only disagree. Otherwise the top
acceleration and burnout from the accelerometer are withheld (direction_unstated), and burnout
comes from the top speed. So are they where the trace, turned and with gravity put back, never
passes 2 g, as a rocket leaving the pad does. Such a trace shows no thrust. The thrust’s witness reads the
trace as written. So on a log that takes gravity out, a thrust under about 3 g reads under 2 g and
says nothing, and the pad decides. Where the pad says nothing too, as on a log that takes gravity
out, both readings are withheld. Three AltOS CSV records of the sample logs are withheld so: their short
burn comes before a heavy drag. A knock on the pad before liftoff’s earliest time
isn’t searched, and a canopy’s shock, however large, comes after the thrust.
On the tests’ short burn, gravity in, the part reads 40 g for 0.3 s. Then a drag of −8 g eases to
nothing by 6 s. The drag’s span holds past 2 g for about 1.7 s and the burn’s for 0.3 s, but the
burn’s comes first. So the thrust says nothing. The pad’s 1 g says nose up, and the top reads 40 g.
Turned by the drag’s span alone, as an earlier rule turned it, the top read 7.9 g. Six sample
logs are withheld as direction_unstated; Checked against says why.
A sample that isn’t a number or has no time is left out. So is one that repeats the time of the
last kept, the first kept, as the height track keeps AltOS’s rows that share a time. A part sampled
faster than every 0.002 s, 500 times a second, the fastest the bounds were checked at, gives neither
reading (sampled_too_fast). Burnout then comes from the top speed.
A cleaned trace. A charge’s shock or one bad sample could turn the readings over, end the thrust early or pass for burnout. So those are found on a cleaned trace. A Hampel filter over 0.1 s puts each sample back to the window’s median if it is more than five robust standard deviations from it. A robust standard deviation is 1.4826 times the window’s median absolute deviation, as Pearson and colleagues define it. The filter takes out a spike narrower than half its window and keeps a step or a steady run as it was. The 0.1 s and the five are HPR Sim’s choice. The top acceleration is read off the samples themselves, not the cleaned trace.
Gravity, by three witnesses. Whether the 1 g is in the readings is settled by three witnesses, each within 0.25 g of the level it reads:
- the family’s word, where the logger’s maker says;
- the pad, read off the accelerometer itself: the steady level before the thrust lifts it by 1 g. That counts if it comes no later than liftoff’s latest time by the heights. About 1 g holds gravity; about 0 doesn’t;
- the coast, the last 1 s before apogee’s earliest time, where a rocket falls freely but for a small drag. About 0 holds gravity; about −1 g doesn’t. It is read only where a coast was flown: after the trace first moves from the pad and before an apogee the log doesn’t end at. Unlike the direction’s coast, it isn’t also held to liftoff’s latest time: coarse heights put that time late, past a coast that was flown, and a family’s word the coast would contradict then settled alone.
A witness that reads neither level, such as the pad of a log that starts in the thrust, says
nothing. Gravity is settled when at least one witness says and none disagrees, with one exception:
a coast at about −1 g doesn’t settle it alone. A part that holds gravity reads its drag there, and
a rocket still fast at apogee, arcing over, can drag about 1 g, which reads as gravity out would.
Putting 1 g back on that log would read its top 1 g high
(#806). A coast at about 0 still
settles it alone: without gravity a coasting part reads −1 g or below, drag only pushing it further
down, so reading within 0.25 g of 0 takes a net push forward, thrust less drag, of between about
0.75 and 1.25 g. A motor still burning in the coast’s second gives such a push. On a part that
takes gravity out, with no family word and no pad, that reads gravity in and the top 1 g low,
outside its bound: a risk left open, and no test pins it (#1131).
Otherwise the top acceleration is withheld (gravity_unstated), and burnout comes from the top
speed. The 0.25 g is HPR Sim’s choice, set out in What each bound holds.
The pad is read off the accelerometer rather than as the samples before liftoff’s earliest time by
the heights. Most Raven logs start about 0.5 s before liftoff, against a liftoff bound near 0.9 s.
That rule, tried when this one was chosen, withheld 69 of the 80 Raven CSV records. The coast
settles the Raven’s logs that start in the thrust, whose family doesn’t say (ADR-283).
On the sample logs no record’s gravity rested on a coast at −1 g alone, or on a coast read off the
pad: with both rules the committed report reproduces, its per-family counts of readings given
and withheld unchanged.
The top acceleration is the highest specific force while the motor burns. A burn runs from a cleaned reading past 2 g to where the cleaned trace, averaged over 0.05 s, next falls through zero. Where it doesn’t, the burn runs to apogee. A span counts as a burn only if the cleaned trace holds past 2 g for 0.5 s in all. A canopy’s or a charge’s shock or a knock doesn’t. Where none does, the first span is the burn, a short motor’s. This was measured once, when the rule was chosen, on the sample logs. Of the spans after the first, every one that started within 3 s of apogee held past 2 g for at most 0.47 s. Every longer one started more than 3 s before it, though nothing beside those logs says which of the longer ones are burns. The 0.5 s is HPR Sim’s choice. The burns are searched from liftoff’s earliest time by the heights, or from the log’s start where liftoff is withheld. A rocket at rest reads 1 g, so anything more before it moves is a knock or a bump on the pad. A charge or a canopy’s shock in a coast lies outside the burns, so it isn’t taken for the top. A second burn, an air start’s or a sustainer’s, is searched too. No top or burnout earlier than liftoff’s earliest time is given. Its bound adds the part’s own errors, the noise around the top and what a peak between samples can hide:
Here is a tenth of the reading , for the part’s scale. is 0.05 g of bias. is how far the pad strays from the level it witnessed. , 0.06 g, is the share of gravity a part that zeroes on a tilted rail takes out. It is counted only where the logger took gravity out. is the noise, measured within 0.5 s either side of the top. is a step, and is the jump to the sample either side. On the tests’ trace, a thrust rises to a top of 6 g, 58.8 m/s². The scale alone is 5.9 m/s² of the bound, and the bias 0.49 m/s².
Clipped. A part reads no higher than its range. A top is clipped, for one of two causes the
JSON’s clip keeps apart. It is range where the top reaches the part’s range as its family
states it, within two steps and 0.25 g. The part read no more. Otherwise it is flat where the
top holds flat for 4 samples or 0.05 s, whichever is more samples. That is how Debrief tells a part that
clipped. A part that clipped at a range other than the one stated, or with none stated, writes
such a top. Flat means within Debrief’s 0.3% of the top or 0.25 m/s². That is narrowed to half the part’s
noise where that is less, and never below half a step. A part at its range writes one value, while
a thrust’s plateau read by a quiet part still scatters by its noise. Debrief’s tolerance alone was tried when the rule was
chosen, before the tuning set held a log whose tops reach its part’s range. It
called 82 of its 284 tops clipped (ADR-283). A clipped top is a
floor: the truth is no lower than the reading less its bound, and may
be higher by any amount. The JSON marks it is_floor, its provenance clipped and its cause in
clip, and gives the part’s range as range_m_s2 where the family states one. hpr analyze
says “clipped at the part’s range” only for range. For flat it says the top held flat at its
top, so it may have been clipped. Either way the top may have been higher.
A thrust held in part. A top is a floor too where the accelerometer holds the thrust only in
part. With no end to it, the last burn never falls through zero before the accelerometer’s
samples end or apogee. That happens when the log, or the accelerometer alone, stops while the
motor still pushes. The top may lie past the samples. Burnout isn’t read off such a trace, and comes from
the top speed instead. With no start, the trace is already past 2 g at its first sample searched,
as when a log starts in the climb. The top may have come before it, as a motor’s ignition
spike can. Either way it is measured, its clip null, and hpr analyze says the
accelerometer holds the thrust only in part. The synthetic report counts this cause apart, as
thrust_in_part; no tuning-set top reads so, as every tuning log starts on the pad.
Burnout from the accelerometer. In the climb the reading is , the thrust less the drag over the mass . It is above zero while the thrust beats the drag, below zero once it doesn’t, and after burnout , which eases as the coast slows. So the reading falls through zero as the thrust tails off. It is least at burnout, where the thrust’s fall ends and the drag’s easing begins. Debrief takes the fall through zero as burnout, which comes earlier, by as long as the thrust takes to tail off below the drag. The cleaned trace is first averaged over about 0.05 s, an odd number of whole samples. That is 27 at 500 samples a second, 7 at 100 and 3 at 20. Their first and last lie intervals apart, 0.052, 0.06 and 0.10 s. That cuts its noise by the square root of the samples averaged. With five times the averaged noise and a step,
an averaged sample lies within of its truth but about once in 1.7 million samples. So the samples next to burnout read within of the least. The thrust falls steeply and the coast’s drag eases slowly, so burnout lies near the first of them. The reading is that first sample, less half the window, intervals, since the average reads the least late by that much. Its bound is the span of those samples, an interval, and the window’s intervals, at least two intervals. If the averaged trace never climbs back above its least before apogee, the accelerometer gives no burnout. It gives none either if the least lies within of zero, too little drag to see. Nor does it after more than one burn. The tuning set’s ten designs each fly one motor in one stage, so it holds no bound for the end of a second.
Take the same trace, sampled 100 times a second with a noise of 0.087 m/s². The thrust falls through zero to −0.6 g at burnout, 4.1 s. The drag eases to nothing by apogee, 8 s. Averaged over seven samples, , 0.16 m/s². The drag eases by 0.6 g over 3.9 s, 1.5 m/s² a second. So the samples within of the least span about 0.22 s. With an interval and the window’s 0.06 s, the bound is about 0.3 s. The reading falls within a sample, 0.01 s, of 4.1 s.
Burnout from the top speed. A rocket gains speed only while the thrust beats the drag and its
weight. So the top speed comes at or before burnout, the last burn’s end. Where the accelerometer
gives no burnout, or the log has none, burnout is a floor. Its reading is the top speed’s time,
and the floor is that time less its bound. Burnout came no sooner than the floor, and may have come
later by any amount. A motor whose thrust tails off below the drag and the weight burns on after
the rocket stops gaining speed. The bound adds three times. The first is the time a coast slowing
at takes to lose twice the speed’s 5 m/s (16 ft/s) noise. The fit can place the peak that
much late. The others are half the 0.5 s fit and an interval. On the invented PerfectFlite
flight, which has no accelerometer, the first is . That, half the fit’s
0.25 s and the 0.05 s interval add to 1.32 s. So hpr analyze reads burnout no sooner than 0.88 s, the top speed’s time, 2.20 s, less that bound. The true burnout is 2.10 s, 0.10 s before the top
speed’s time. The JSON gives such a burnout’s reading as time_s and its bound as bound_s, and
marks it is_floor. A top speed withheld, as transonic on a fast flight, withholds it too.
The canopies
Each canopy’s descent rate comes from the filtered height track, its legs split where the main opens. The opening starts from Debrief’s walk back from landing and its marks (ADR-283 §6). HPR Sim compares rates at the ground’s density, smooths them with a running median, and since ADR-366 takes the opening at the likeliest single change of the descent, not the walk’s first stop.
The main’s opening. Near the ground the rocket hangs under its main. The descent’s rate is
the least-squares slope of the filtered track over 1 s, widened where needed to hold four of the
track’s steps. A fit that would need more than 10 s is refused (step_too_coarse). The main’s
rate is the median of that rate over the last 2 s before landing, or the fit’s span where that
is longer. The last 0.25 s is left out.
Walking back from landing, the run of samples whose rate stays within 1.6 times the main’s is the
main’s descent. The limit is 3 m/s (9.8 ft/s) more than the main’s rate if that is more. Its first sample is the opening.
These marks are Debrief’s, set on its own logs.
That walk stops at the first rate past the limit, however short. A real descent passes it more than once: the rocket swings under its main, and a coarse log’s rates scatter. So HPR Sim asks where one change in the descent is likeliest (ADR-366). Call a rate slow if it is within the limit and fast if it is past it. Split the descent’s rates, from apogee to landing, at , with slow ones among the before the split and among the after it. If the rates were independent, slow with one chance before the split and another after, the split’s log-likelihood at the best two chances would be
Here is for a side of rates with slow ones, and a term with nothing in it counts as zero. This is the change-point of a two-valued sequence (D. V. Hinkley and E. A. Hinkley, “Inference about the change-point in a sequence of binomial variables”, Biometrika 57, 1970, pp. 477–488). A side that is all slow or all fast has , the most it can be. A side that mixes them has less, and the more evenly it mixes, the less. The main’s descent starts at the split with the greatest . HPR Sim adds one condition: the later side must hold the larger share of slow rates, since the main is the slower canopy. Of two splits as likely, the one nearer landing is taken.
- Where the rates go from fast to slow once, after the slow start from rest at apogee, the split is the walk’s. A test tries every such descent of its sizes.
- A fast stretch under the main is weighed against the slow rates before it. Moving the split past it would put those slow rates into the drogue’s leg. Which costs more depends on the two lengths and on how long the drogue’s leg is: the worked case below shows one balance.
- The split is never later than the walk’s. Every rate after the walk’s start is slow, and adding slow rates to an earlier side that holds a fast one only lowers its .
A worked case: 100 fast rates of a drogue, then 8 slow, a bounce of 10 fast, and 30 slow to landing. The walk stops after the bounce, after 118 rates. There : eight slow rates sit in the drogue’s leg. After 100 rates, the first slowing, : ten fast rates sit in the main’s. The split is there. With a drogue’s leg of 20 rates and 4 slow ones before a bounce of 6, the balance falls the other way, and the split is after the bounce.
The rates aren’t independent, since they are a running median of overlapping fits. So the likelihood is the rule’s reason and gives no confidence of its own. The opening’s bound, under The opening’s bound below, is derived for a descent whose rates go from fast to slow once. Where they change more often, the tests here hold the split’s opening to that same bound, and nothing proves it. One shape is known to break it: a drogue falling near the limit, slow for a few seconds and then fast just before the main opens, reads its opening seconds early (issue #1593, the bound where the split is earlier than the walk).
Three tests hold the rule to the cases that showed the walk wrong (#903). Two invent a flight with a drogue at 18 m/s (59 ft/s) and a main opened 750 m (2,461 ft) up.
- A swing. Under a main at 5 m/s (16 ft/s), 40 s after it opened, the rocket holds its height for 2.25 s and then falls 4.5 m/s (14.8 ft/s) faster than the main’s rate for 2.5 s. The walk stopped at the swing. The split reads the opening and each leg’s rate within its bound, on a smooth log at 20 Hz, one in 0.3048 m (1 ft) steps, and one at 5 Hz.
- A coarse log. 732 logs at 5 Hz in 0.93 m (3.1 ft) steps, with noise within 1.7 m (5.6 ft) either way: the main at 4 to 7 m/s (13 to 23 ft/s) in steps of 0.05 m/s (0.16 ft/s), each under 12 draws of the noise, 61 rates by 12 draws. The split reads two canopies on all 732, the opening and each leg’s rate within its bound.
- The real flight that showed the fault, a StratoLogger CF’s log from a public forum thread (cited in the issue, not committed; the test reads it where it is cached, and reads nothing elsewhere). Its rocket swings under the main. The issue measures the drogue’s descent at about 17.3 m/s (56.8 ft/s) and puts the opening between 87 and 92 s, the log’s header giving the main charge at 87.15 s. The walk read the opening at 108.45 s and the drogue’s descent at 14.6 m/s (48 ft/s). The split reads 90.00 s, with a bound of 0.76 s, and 17.3 m/s (57 ft/s), within 1.4 m/s (5 ft/s). The charge fired 2.85 s before the reading: the bound leaves out the time a canopy takes to come out and fill.
That is one real flight with a logged charge time (evidence row G10). A second, the public Genesis flight, has a simulation beside its log: the walk read the log as one canopy, and the split reads the main’s opening 806.18 m (2,645 ft) up, where the simulation opens it at 797.33 m (2,616 ft). No bound is stated for that height, and the simulation’s drogue rate is outside the log’s interval, so this shows the two agree roughly, no more (the residuals report). How the split’s opening compares with a logged charge time on others hasn’t been measured, and a canopy’s filling time is still outside the bound (#779). The survey’s real logs have no truth to hold a reading to. On them the rule reads a drogue’s descent on more logs than the walk did, and on fewer in no family of loggers; ADR-366 has the counts, and the survey’s report the readings as they stand.
The rates it splits are their running median over 2 s, or twice the fit where that is longer. So a spike of the fit’s noise on a long leg is taken out, while a step, the opening, stays where it is. The raw rate was tried when the rule was chosen. On 2 of the 87 tuning flights whose main’s opening their own logs give, the walk missed the drogue. A noise spike on a 125 s main leg stopped it 125 s after the opening.
At the ground’s density. A canopy falls at the speed where its drag balances the weight, (the descent rate). So its rate goes as . Up high, in thinner air, one canopy falls faster than it does near the ground. From a high apogee its early descent would read as a drogue’s. So HPR Sim scales each rate, read at the height above the pad, to the ground’s density:
is the troposphere’s least density scale height, 7,000 m (22,966 ft). In the 1976 standard atmosphere, whose temperature falls by , 6.5 K/km, the density falls as near any height. Here for air’s gas constant and the temperature . At the coldest the bounds allow, the tropopause’s 216.65 K less 15 K, is 7,289 m (23,914 ft). It is taken down to 7,000 m (22,966 ft). Where the air cools with height, as through the standard troposphere, a canopy’s rate grows by no more than at the least . So the scaling can only slow a rate read high up, never quicken it, and one canopy doesn’t read as two. A surface inversion, air that warms with height, is the exception, as is negative there and shrinks. At 260 K, warming by 20 K/km, is about 4,800 m (15,748 ft). Over an inversion 300 m (984 ft) deep, a canopy’s rate then grows by 3.2% from the ground to its top. The scaling, with at 7,000 m (22,966 ft), takes out 2.1%. So a rate read there is about 1% quicker than near the ground, which is small beside the mark’s 1.6. When the rule was chosen, comparing each rate at its own density named a main on a tuning flight that opened one canopy at apogee.
A drogue, or one canopy. A drogue came before the main only where the descent shows its leg.
That needs two things. First, the 2 s just before the run, at the ground’s density, fell faster
than the run’s mark. This is HPR Sim’s addition: a drogue whose rate crosses the mark leaves the
run’s start inside the drogue’s leg. Second, the descent from apogee to the opening fell faster
than 1.4 times the main’s rate, by its median, as Debrief asks. Otherwise the descent shows one canopy (one_canopy): the
drogue’s descent is withheld, and the main’s runs from apogee to landing. So a drogue no faster
than the mark reads as one canopy, whatever its ratio to the main. The main’s descent is then
the whole descent’s. In the tests, a drogue at 15 m/s (49 ft/s) over a main at 10 m/s (33 ft/s)
reads as one canopy. The main’s mark is 16 m/s (52 ft/s). Debrief’s ratio of 1.4 alone would tell
them apart. A rocket that came down under none reads the same way.
Each leg’s rate is the filtered height it loses over the time it takes. The drogue’s leg runs
from apogee to the main’s opening, and the main’s from there to landing. A leg that loses no more than 3 m
(9.8 ft) or a tenth of its top’s height, Debrief’s least, is withheld (short_leg). Its bound is
the error two heights of the same track can hold between them, over the leg’s time
(What each bound holds).
The opening’s bound. A fit centered half a window before the opening sees only the drogue’s descent, faster than the mark. So the run starts no sooner than half a window and a sample before the opening. After the opening the main slows the fall as quadratic drag slows any falling body (Taylor, Classical Mechanics, §2.4),
and from any speed it reaches the mark within
where is the main’s rate at the opening’s height, the rate near the ground grown by . So the run starts no later than , half a window and a sample after the opening. The bound is , half the 1 s fit and two sample intervals. One interval is for the sample the run starts on, and one more is HPR Sim’s margin. A canopy’s filling time isn’t in it: the synthetic flights open each canopy at once (#779, the opening’s bound and a canopy’s filling time).
On the invented PerfectFlite flight, the main’s rate near the ground is 6.0 m/s (20 ft/s), so the run’s mark is 9.6 m/s (31.5 ft/s). That is 1.6 times the rate, more than 3 m/s (9.8 ft/s) above it. The run back from landing starts at 21.40 s, 148.4 m (487 ft) up. There the main’s rate is 6.06 m/s (19.9 ft/s), the rate near the ground grown by . From there the main slows any fall to the mark within
so the opening’s bound is , as hpr analyze prints it.
The main truly opened at 21.14 s, 150 m (492 ft) up. The reading is 0.26 s late, as the 1 s fit
still sees some of the drogue’s faster fall just after the opening. The drogue’s leg loses
241.7 m (793 ft) in 11.125 s, 21.7 m/s (71 ft/s). That is below the drogue’s true 25 m/s
(82 ft/s), as the leg starts at apogee, where the rocket falls from rest. Over the same span the
true rate is 21.74 m/s (71.3 ft/s).
Bounds and refusals
What each bound holds
Each reading states the bound its error stays within. A bound is a sum of terms, each the size of one error the synthetic flights draw, or measured on the log itself. Most of an apogee’s bound is the day’s air.
-
Apogee height. The day’s air and the barometer’s gain as shares of the height . The noise, the pad’s error and the drift since the log began. Last, a step at the pad and one at the peak, and the median’s peak bound:
-
Apogee time. The time the top of a coast takes to fall by the noise and a step, . Plus the longer interval either side of the peak’s flat run.
-
Liftoff. The time a rocket at takes to climb the allowance and the pad’s error, once above the pad and once below, . Plus the longer interval either side of the sample, twice.
-
Top speed. The day’s air and the gain as shares of the speed . The port’s error (the port is the hole that lets the outside air in to the barometer) while the rocket accelerates at , . The fit cutting the peak, . Here and are the climb’s change of speed before and after it, measured on the fits. Last, the noise in a speed.
-
Landing. The time the descent takes to fall the allowance, the noise, the pad’s error, the logger’s height above the ground, a step and the drift. It takes the descent at its rate near the ground, taken slow by a step and twice the noise. Plus the longer interval either side of the sample, twice.
-
Flight time. Liftoff’s bound and landing’s, added.
-
Mean descent rate. The apogee’s height bound and the height landing is read early by, then the rate times the apogee’s and landing’s time bounds. All of it is over the descent time.
-
Top acceleration. The part’s scale as a tenth of the reading, its bias and how far the pad strays. A tilted rail’s share for a part that took gravity out. Last, five times the noise, a step and the jump to a neighboring sample (The accelerometer). A clipped top’s bound is one-sided: the truth is no lower than the reading less it.
-
Burnout. From the accelerometer, the span of the averaged samples within of the least. Add an interval and the averaging window, or two intervals if that is more. From the top speed, a floor: , half the fit and an interval.
-
Each canopy’s rate. The day’s air and the barometer’s gain as shares of the height the leg loses. The noise at either end, the drift over the leg and a step at either end. For a leg from apogee, add the median’s peak bound. All of it is over the leg’s time.
-
The main’s opening. The time the main takes to slow the fall to the run’s mark, half the 1 s fit and two intervals (The canopies).
| term | size | source |
|---|---|---|
| , the day’s air | 6.92% | a height read by the standard atmosphere is off by of itself over the layer it spans (the hypsometric equation); is the synthetic flights’ 15 K range of air (ADR-280 §2), and no colder than the standard atmosphere’s 216.65 K below 20 km (12 mi). Near the ground it is about 0.35% a kelvin |
| , the barometer’s gain | 0.25% | an MS5607 barometer chip’s ±1.0 mbar over the 400 mbar span its datasheet states it on, the widest of the synthetic flights’ parts; reading that error as a gain is an inference (ADR-280 §3) |
| , the noise | 3 m (9.8 ft) | the fast and slow correlated noise, the part’s white noise, the pad’s median and the port’s error at apogee’s sideways speed, added and tuned on the tuning set |
| , the drift | 0.015 m/s (0.049 ft/s) | the synthetic flights’ fastest drift, 3 Pa in 30 s (ADR-280 §3), at the density of air 5 km (3.1 mi) up, 0.74 kg/m³ |
| , a step | the track’s step | the rounding of the logger’s numbers; a pressure’s step at the height it is read at |
| , the median’s peak bound | 0.077 m (0.25 ft) at 20 samples a second | gravity’s bend over the median’s reach (The running median) |
| , the pad’s error | up to 2 m (6.6 ft) | how far up the rocket may be when the log starts (The pad and the climb) |
| , the allowance | at least 2 m (6.6 ft), and a step | four times the fast correlated noise, HPR Sim’s choice |
| the logger above the ground | 3 m (9.8 ft) | a tall rocket’s electronics bay on a rail, HPR Sim’s choice: it lands lower than it started by as much |
| the port, while accelerating | a pressure coefficient of 0.02 | the ogive-cylinder’s measured −0.02 one caliber behind its shoulder below Mach 0.9 (the Mach error note §1–2), the largest the synthetic flights draw |
| , the fit’s width | 0.5 s | HPR Sim’s choice; a fit cuts a peak by about , and twice that is allowed |
| the noise in a speed | 5 m/s (16 ft/s) | tuned on the tuning set |
| , the accelerometer’s scale | 10% | the ADXL375 accelerometer chip’s ±10% sensitivity (its datasheet, p. 3, in the sensor noise note, read once and not re-read against the sheet), the widest of the synthetic flights’ parts (the acceleration) |
| , the accelerometer’s bias | 0.05 g | the bias the synthetic flights leave after the pad’s zero, the top of the 0.01 to 0.05 g the sensor noise note calls a guess, as no source states one |
| a tilted rail | 0.06 g, | the 20° from vertical the NAR’s and Tripoli’s high-power safety codes allow a rail (the NAR’s model rocket code allows 30°, 0.13 g): a part that zeroes on the pad takes out |
| the accelerometer’s noise | 5σ | measured on the log, within 0.5 s of the top, or from the top to a second past the fall through zero for burnout; a normal noise passes it, either way, about once in 1.7 million samples |
| gravity’s witnesses | 0.25 g | a 20° rail’s 0.06 g, a part’s zero offset and the small drag near apogee, HPR Sim’s choice |
| the descent’s fit | 1 s, widened to hold four steps, at most 10 s | a canopy’s rate changes slowly, so a fit twice the climb’s averages the noise down; four steps keep a step from reading as a spike, HPR Sim’s choice |
| , the density scale height | 7,000 m (22,966 ft) | the 1976 standard atmosphere’s 7,289 m (23,914 ft) at its coldest less 15 K, taken down (The canopies) |
The two tuned terms are the 3 m (9.8 ft) and the 5 m/s (16 ft/s). They were set on the same flights the bounds are held on (Checked against).
A worked example
The invented PerfectFlite log is the one the command line’s own example reads
(hpr analyze prints it). It reads an apogee of 390.144 m (1,280 ft), 10.275 s into the
log, on a track in one-foot steps sampled 20 times a second. Its filtered track stays within
2.30 m (7.6 ft) of its start for 0.80 s. That is longer than the 0.69 s a rocket at rest would need to
climb the 4.61 m (15.1 ft) rise at 2 g. So the pad’s error is zero. The bound adds up so:
| term | worked out, in m, m/s or s | bound term, m |
|---|---|---|
| the day’s air | 0.06924 × 390.144 m | 27.01 |
| the barometer’s gain | 0.0025 × 390.144 m | 0.98 |
| the noise | 3.00 | |
| the pad’s error | 0.00 | |
| the drift | 0.015 m/s × 10.275 s | 0.15 |
| a step at the pad, and one at the peak | 2 × 0.3048 m | 0.61 |
| the median’s peak bound | 0.08 | |
| the bound | 31.83 |
hpr analyze prints it rounded up, as it prints every bound: “within 31.9 m (105 ft)”. The flight’s true apogee is 390.31 m
(1,280.5 ft), so the reading is 0.17 m (0.56 ft) low. That is about a two-hundredth of its bound, as it
should be on a log written from the true heights with no noise. About 85% of the bound is the day’s
air, which a real log can’t rule out.
The 90% intervals
A bound is the size every error stayed within on the tuning set. A 90% interval is narrower: it
says where the truth usually lies, over the days and loggers the synthetic flights draw. Twelve
readings state one. hpr analyze prints each after its bound, rounded outward, such as a 90% interval of 369.8 to 410.3 m
(1,213 to 1,346 ft), and a floor’s lower end as “95% lower end”. hpr analyze --json and Python’s
readings() carry each as low and high, under its reading’s key: liftoff.interval_s, apogee.height_interval_m,
apogee.time_interval_s, max_speed.interval_m_s, landing.interval_s,
flight_time.interval_s, landing.mean_descent_rate_interval_m_s,
max_acceleration.interval_m_s2, burnout.interval_s, drogue_descent.interval_m_s,
main_descent.interval_m_s and main_descent.opening.interval_s. A floor has no interval: a
clipped top acceleration states lower_end_m_s2 and a burnout floor lower_end_s, as
A floor’s lower end sets out; an apogee or top speed floor states neither.
An interval need not hold its reading. Liftoff is read late, so its interval lies before the reading: the worked example’s liftoff reads 0.80 s, with an interval of 0.41 to 0.64 s.
Each interval comes from the reading’s own bound. The synthetic flights’ calibration set is 2,000 flights on a seed no other set shares (the sets). Each of its flights’ own logs was read; 362 of them are the GNSS-only tracker’s, which give none of these readings, so 1,638 are left for the height track’s. The top speed is also withheld at or above 227.7 m/s (747 ft/s), where the barometer’s port may read the transonic flow over the nose (Each reading), which leaves 576 top speeds. The rest have fewer for reasons of their own: 641 logs hold an accelerometer, 564 of them read a burnout that isn’t a floor, and 781 flights opened a drogue, so 781 give its rate and the main’s opening. Each reading’s error was then taken as a share of its bound: the reading less the truth, over the bound . The interval runs from the reading less the 95% point of those shares times the bound, to the reading less the 5% point times the bound:
Each point is the -th from its end of the sorted shares, the split-conformal rank (Lei and colleagues, 2018): the 81st of 1,638, the 28th of the 576 top speeds. Each tail then misses about 5% on average over flights drawn as those are.
| reading | 5% point , share of the bound | 95% point , share of the bound |
|---|---|---|
| liftoff | 0.203 | 0.482 |
| apogee height | −0.631 | 0.637 |
| apogee time | −0.331 | 0.227 |
| top speed | −0.218 | 0.265 |
| landing | −0.335 | 0.156 |
| flight time | −0.379 | −0.132 |
| descent rate | −0.475 | 0.495 |
| top acceleration | −0.495 | 0.568 |
| burnout | −0.065 | 0.0689 |
| drogue rate | −0.622 | 0.612 |
| main opening | 0.138 | 0.567 |
| main rate | −0.574 | 0.586 |
Some points lean. Liftoff is the last sample within the pad’s allowance, which the rocket leaves
only after climbing it, so it is read late, and both its points are above zero: its interval lies
wholly before the reading. The flight time runs from that late liftoff to a landing read early, so
it reads short, and its interval lies wholly after the reading. The apogee time’s errors reach
further early than late, so its interval reaches further after the reading than before it. The
main’s opening is read after the canopy has slowed the descent, so it is read late, and its interval
lies wholly before the reading. cargo xtask synthetic fits the points again and fails unless they equal the library’s.
A worked example. The invented PerfectFlite log’s apogee of 390.144 m (1,280 ft) has a bound of 31.83 m (104.4 ft) (above). Its interval runs from 390.144 − 0.637 × 31.83 = 369.87 m to 390.144 + 0.631 × 31.83 = 410.23 m (1,213 to 1,346 ft). The true apogee, 390.31 m (1,280.5 ft), lies inside. Most of the width is the day’s air, as most of the bound is. The same log’s flight time reads 45.00 s with a bound of 2.91 s, so its interval runs from 45.00 + 0.132 × 2.91 = 45.38 s to 45.00 + 0.379 × 2.91 = 46.10 s. It doesn’t hold the reading: the flight time reads short, so the interval says the flight most likely lasted a little longer.
Checked against sets A and B. The two test sets, which the points never saw, each pass the test of ADR-257, calibrated intervals (the report). The truths below an interval and those above it are each counted, so an interval that misses on one side only fails. Each count gets its 99.9% Clopper-Pearson band, the range of shares that count rules in. The test fails unless both sides’ bands hold 5% and the inside count’s holds 90%:
| set | reading | readings compared | truths below | truths inside | truths above |
|---|---|---|---|---|---|
| A | liftoff | 820 | 35 | 729 | 56 |
| A | apogee height | 820 | 55 | 720 | 45 |
| A | apogee time | 820 | 34 | 746 | 40 |
| A | top speed | 286 | 12 | 258 | 16 |
| A | landing | 820 | 38 | 745 | 37 |
| A | flight time | 820 | 40 | 745 | 35 |
| A | descent rate | 820 | 47 | 728 | 45 |
| B | liftoff | 845 | 52 | 739 | 54 |
| B | apogee height | 845 | 38 | 759 | 48 |
| B | apogee time | 845 | 35 | 764 | 46 |
| B | top speed | 286 | 9 | 262 | 15 |
| B | landing | 845 | 24 | 788 | 33 |
| B | flight time | 845 | 32 | 766 | 47 |
| B | descent rate | 845 | 40 | 755 | 50 |
| A | top acceleration | 356 | 12 | 322 | 22 |
| A | burnout | 307 | 10 | 286 | 11 |
| A | drogue rate | 428 | 32 | 379 | 17 |
| A | main opening | 428 | 22 | 383 | 23 |
| A | main rate | 820 | 44 | 737 | 39 |
| B | top acceleration | 368 | 18 | 330 | 20 |
| B | burnout | 325 | 24 | 281 | 20 |
| B | drogue rate | 436 | 25 | 392 | 19 |
| B | main opening | 436 | 14 | 392 | 30 |
| B | main rate | 845 | 41 | 760 | 44 |
The GNSS-only logs, 180 of A’s and 155 of B’s, give none of these readings, and the transonic mark withholds 534 more top speeds on A and 559 on B. So the top speed is tested on fewer than 300 readings a set, where a tail passes with a wider share of misses either way: 4 to 28 of 286 (1.4% to 9.8%), against 22 to 63 of 820. Every interval narrowed to 0.8 of its width fails the test, and so does every one widened to 1.25 or shifted down one standard error, the top speed’s included. Past the mark, though, the rule lets through only the top speeds that came out low. The two Calisto designs mostly fly past it, and of the 17 top speeds they gave on A and B, 8 left the truth above the interval (the report’s By design).
Six of the readings have a flattering side: a reading too low makes the flight look safer than it was. A low apogee height flatters a waiver, and a low top speed a fin’s margin. The top speed is vertical; a fin’s airspeed is higher on an angled climb, by 6% on a 20° one. A low top acceleration flatters the load the airframe took. A low mean descent rate, or a low rate under either canopy, says the descent was gentler than it was. The mean rate runs from apogee to landing, drogue and main together, so it is no landing speed: that is the main’s rate. The report gives each one’s mean error, the reading less the truth, with its sign and at the figures of its largest error, as its later digits differ from one computer to another. The apogee height’s is +1 m (3 ft) on A and, on B, less than half a meter and not below zero, against errors up to 237 m (778 ft). The top speed’s is +1.2 m/s (3.9 ft/s) on A and +1.3 m/s (4.3 ft/s) on B, against errors up to 26.8 m/s (88 ft/s). Neither is low on average. The descent rate’s is −0.01 m/s (−0.033 ft/s) on both, a hundredth of a meter per second low against errors up to 6.81 m/s (22.3 ft/s). The other three are as small: under 0.5 m/s² (1.6 ft/s²) on the top acceleration, against errors up to 15.7 m/s² (51.5 ft/s²), and 0.02 m/s (0.066 ft/s) or less on each canopy’s rate, against errors up to 1.51 m/s (4.95 ft/s) on the drogue’s and 5.87 m/s (19.3 ft/s) on the main’s.
The test pools the five loggers that give these readings and the ten designs. The 90% is over the days the flights draw, spread evenly within 15 K of the standard atmosphere, and the misses aren’t spread over those days. A barometric height is off by about the day’s offset from standard over its temperature, and so are the speed and the rates taken from it. On days within 10 K of standard, no height and no rate of descent missed, and 4 of 360 top speeds did. On days warmer than that, above about 25 °C (77 °F) at a sea-level field, a warm day reads low, so the truth lay above the interval: for the height, 45 of 137 on A and 48 of 156 on B (#1055); for the descent rate, 45 of 137 and 50 of 156; for the main’s rate, 39 of 137 and 44 of 156; for the drogue’s, 17 of 69 and 19 of 80; for the top speed, 16 of 57 and 15 of 69 (#1061). On a hot day, then, expect each of them above its interval’s top far more often than 1 time in 20. So for a waiver, take the apogee plus its bound; for a fin’s margin, the top speed plus its bound; for a landing, the main’s rate plus its bound; for a load, the top acceleration plus its bound. None of these holds if the reading is a floor, which has no upper figure. Each bound holds the day’s air to 15 K. The bounds, too, were measured only on synthetic flights.
The times lean by logger. On the AltOS logs, whose rate drops from 100 to 10 samples a second at apogee, 31 of 185 apogee times on A and 30 of 186 on B lie later than the interval (#1056). Liftoff on the PerfectFlite and EggTimer logs leaves its truth above the interval (18 of 144 and 23 of 181 on A), and on the AltOS and 500 Hz IMU logs below it. On the 500 Hz IMU logs, landing and the flight time leave theirs above it, 18 of 171 and 24 of 171 on A (#1062). The top acceleration leans most. Its one pair of points serves two accelerometers: on the AltOS logs 34 of 185 truths on A and 38 of 186 on B lie outside the interval, 22 and 20 above it, the flattering side, and on the 500 Hz IMU’s none of 171 and 182 do (#1070). The report’s bold rows mark each group whose counts alone fail. The report gives each logger’s and each band’s counts. A day more than 15 K from standard, or a logger noisier than these, can see more misses still. No real flight has checked an interval (evidence row G34).
A floor’s lower end
A floor’s truth may lie any amount above it, so it can’t state an interval. It states a lower end instead, the figure the truth stayed above in about 19 of 20 synthetic flights: the reading less its own 95% point times its bound, . That end is tested alone. The band on the share of truths below it must hold 5%, the lower tail of the same test. As that test is two-sided, too few truths below fail it as too many do. The probes are deliberately wrong lower ends: raised by one standard error, or lowered by two, each must fail. The standard error here sizes those probes. It is the 95% point less the median, times the bound, over 1.645, as an interval’s is its width over twice 1.645. Lowering by one isn’t enough to fail on a few hundred floors: of 211, a band still holds 5% with 2 truths below.
| floor | floors fitted | 95% point , share of the bound | median, share of the bound | where the lower end falls |
|---|---|---|---|---|
| burnout, from the top speed’s peak | 437 | −0.0335 | −0.194 | just after the reading |
| top acceleration, clipped | 348 | 0.259 | −0.124 | just below the reading |
| set | floor | floors compared | truths below | truths below, raised one standard error | truths below, lowered two |
|---|---|---|---|---|---|
| A | top acceleration | 181 | 3 | 52 | 0 |
| A | burnout | 211 | 11 | 55 | 0 |
| B | top acceleration | 187 | 3 | 44 | 0 |
| B | burnout | 213 | 7 | 48 | 1 |
Every floor as stated passes, and every raised or lowered one fails.
Why a clipped top is fitted near the clip. No synthetic flight’s accelerometer reaches its own range, so the top acceleration’s floors come from each flight’s log written again with the accelerometer clipping at 8 g. The AltOS part has no such setting; its log clips there too, to reach a count the test can fail on, and its reader tells the clip by its flat top.
How far past a clip a top goes depends on the design, and no log says. A first fit, on tops as flown, found most of them far past it, so its 95% point came out negative and put the lower end above the reading. It held on A (8 of 252 below) and failed on B (31 of 285): one of the ten synthetic designs, the Bella Lui, whose tops only just pass 8 g under B’s model, left 21 of 22 truths below it.
So the fit takes the one place where the log’s own error can put a truth below a clipped reading: a top under the clip that reads as clipped. A part’s scale error, its gain, can be off by up to , ±3% on the 500 Hz IMU and ±10% on the AltOS part. The reader calls a top clipped from 0.25 g under the range, and the part’s bias of up to 0.05 g helps it there, so a truth from of the clip can be read as clipped: 0.934 of it on the IMU and 0.875 on the AltOS part. Past of the clip, 1.03 and 1.11, every such part clips.
Each flight’s true top is moved to a point of its own in that window, a different point on the calibration set and on each of A and B. A top that then reads whole isn’t a floor and isn’t counted; the report gives how many. Of the rest, only a top under the clip that the gain carried up to it can miss. A top truly past the clip lies above the reading: on the tops as flown, none of A’s 252 and none of B’s 285 lie below the lower end. That check is close to certain by construction, so the test on the moved tops is what the result rests on.
So read the lower end as how far the part’s own gain can carry a reading above the truth, not as how far past the clip the top went. The result rests on the window as well as on the flights. The window’s edges come from the parts’ stated scale errors and the reader’s own threshold, but they were set after A and B had been read, so these two sets don’t hold it apart as they do the other points (ADR-308). Probes not in the report show how far it moves: with both parts’ window at 1.00 to 1.10 of the clip, no top lies under it and the 95% point goes to −0.0496, a lower end above the reading that the test no longer supports; at 0.90 to 1.10 it is 0.236 against this window’s 0.259. On A and B the lower end misses less than its 5%, 3 of 181 and 3 of 187, all on the AltOS logs: an error to the safe side, and the test’s band still holds 5%. It is stated only on a clipped top: a floor whose burn the log ends in has none, as an apogee floor has none, since no set reads one to test (#1071).
A burnout floor’s lower end lies a little after the reading, by 0.0335 of the bound, as burnout usually comes after the top speed. How far after depends on the motor’s tail-off, so it can lean by design: on the Bella Lui, 8 of 61 truths lie below it on A (#1070).
A worked example. With an invented clipped top reading 78.5 m/s² (8.00 g) and a bound of
9.00 m/s², the lower end is 78.5 − 0.259 × 9.00 = 76.2 m/s² (7.77 g). The floor, the reading less the
whole bound, is 69.5 m/s² (7.09 g). The true top is most likely above the first and, on what the
tuning set held, no lower than the second. Both are lower limits: neither sizes a load, as the true
top may be much higher than either. Use the reading plus its bound only for a top that isn’t a floor
(is_floor false).
- J. Lei, M. G’Sell, A. Rinaldo, R. J. Tibshirani and L. Wasserman, “Distribution-free predictive inference for regression”, Journal of the American Statistical Association 113(523), 2018, §2.2, for the split-conformal rank that sets each interval’s points. V. Vovk, A. Gammerman and G. Shafer, Algorithmic Learning in a Random World, Springer, 2005, ch. 2, for its origin.
A day past 15 K
Each bound holds the day’s air to 15 K from standard. This section covers what the readings do on
a day further off. It is a note beside the readings, not a correction of them, and it assumes the
offset measured at the pad holds up the whole climb. It is tested only on invented flights in air
offset from standard by the same amount at every height (Ussa76::with_offset), not on a real log.
Standard air is 15 °C at sea level, less 6.5 °C a kilometer of height. So 15 K over standard is reached at these temperatures at the pad:
| Pad’s height above sea level | Standard there | 15 K over standard |
|---|---|---|
| sea level | 15 °C (59 °F) | 30 °C (86 °F) |
| 1,000 m (3,281 ft) | 8.5 °C (47.3 °F) | 23.5 °C (74.3 °F) |
| 1,500 m (4,921 ft) | 5.25 °C (41.45 °F) | 20.25 °C (68.45 °F) |
Past that, the bound may not hold. A barometric height then can read low by more than the bound allows for the day’s air, and so can a speed or a rate of descent worked out from the heights. That is the flattering side: an apogee too low for a waiver, a descent too slow. Where the log records the pad’s temperature and its height above sea level, the readings check the day against the 15 K (#1259).
What it compares. The day’s offset is the log’s temperature at the pad less the 1976 standard atmosphere’s at the pad’s height above sea level. The standard’s temperature falls 6.5 K a kilometer from 288.15 K at sea level, to 216.65 K at 11 km (6.8 mi), and holds that to 20 km (12.4 mi). The code holds it above 20 km (12.4 mi) too, where the standard warms again, which errs toward a larger share:
is the median of the log’s temperature samples over the span the pad is read from. The pad’s height above sea level, , is the first of three. A pressure channel over the same span, turned into a height by the standard atmosphere, gives the pad’s pressure altitude, the height whose standard temperature the logger’s conversion assumes. Next comes an altitude channel above sea level, then the ground elevation the logger states.
When it notes. When is more than 15 K. hpr analyze then prints a line above the
readings with the log’s temperature, the offset and where the pad’s height came from. Below the
apogee, the top speed, landing’s mean rate and each canopy’s rate, it prints a note with the size.
On a low flight a day just past 15 K can move the readings by less than the bound’s own 6.92%,
as the size below shows. The note then says the day is past 15 K but within the bound’s share at
this flight’s height. Its JSON carries the comparison as day_air whenever the log has one, with
offset_k, covered and share.
The size. By the hypsometric equation, , the height between two pressures goes as the air’s mean temperature between them. So a height read by the standard atmosphere is off by of itself, where is the standard’s mean over the layer (the height formulas note). The note takes the standard’s temperature at the apogee’s height above sea level, , the pad’s plus the apogee’s reading: the coldest air the climb spans. So its share is the largest the layer allows. Where the apogee is only a floor, as when the log ends on the climb, the top may lie higher, so the note takes the standard’s coldest, 216.65 K, instead:
On a hot day the true value may lie up to of the reading above it; on a cold day, below. The bound’s own term is , 15/216.65 = 6.924%. A speed or a rate is a height over a time, so it takes the same share.
A worked example, with invented numbers. The pad’s pressure altitude is 1,190 m (3,904 ft) and the log reads 308.15 K (35 °C) there. The standard there is 288.15 − 0.0065 × 1,190 = 280.415 K, so is 27.735 K, past the 15 K. The apogee reads 2,738 m (8,983 ft) above the pad, 3,928 m (12,887 ft) above sea level, where the standard is 262.618 K. So is 27.735/262.618 = 10.561%, 289.2 m (949 ft) of the reading. The bound allows 6.924% of it for the day’s air, 189.6 m (622 ft). The difference, 3.637% of the reading, is 99.6 m (327 ft): the day’s air alone may put the true apogee that far past the day’s-air part of the bound.
A note, not a wider bound. A logger’s temperature channel is often the board’s or the sensor chip’s, in the electronics bay. The sun and the electronics warm it, so on a hot pad it can read above the air. Widening every bound to it would move the bounds, and the 90% intervals calibrated on the synthetic flights, by a figure that may be the bay’s. So the bounds stay as they are, and the note gives the size for the flyer to weigh against the field’s own weather reading.
Its limits.
- A log with no temperature, or with no pressure, altitude above sea level or stated ground elevation, gets no check. Nothing then says whether the day was within 15 K.
- A temperature channel whose samples are all one value over the whole log, and that value a unit’s zero read as kelvin within 0.01 K, isn’t taken for the air: 0 K, 273.15 K (0 °C) or 255.372 K (0 °F, ). A logger with no sensor writes zeros, and the readers turn them into kelvin first, so zeros in °C and °F read as plausible air. A channel of one other value is read: a logger quantized to a degree can read one value over a short log. A real sensor that reads exactly 0 °C or 0 °F throughout is refused too, and gets no check. A temperature outside −100 °C to 100 °C isn’t taken for the air either.
- A stated ground elevation may be the field’s surveyed height, not its pressure altitude. The two differ by up to a few hundred meters with the weather, a kelvin or two of . An altitude channel above sea level has the same catch. A logger may set it by an altimeter setting, the day’s sea-level pressure, so it reads nearer the true height than the pressure altitude.
- The offset is taken at the pad and held up the climb. Where the true offset shrinks with height, the note overstates; where it grows, it understates. A hot afternoon’s air often cools faster than the standard’s 6.5 K/km. It tends toward the dry adiabatic lapse rate, 9.8 K/km, found in any meteorology text (References). So a hot pad’s note leans high. Under a morning inversion, where the air near the ground is cooler than the air above it, a hot pad’s offset grows with height and the note leans low. On a cold pad the two swap: an inversion makes the note lean high, and air cooling faster than standard makes it lean low.
hpr_flightdata::readings::day_airpins it. On an invented flight from a 1,190 m (3,904 ft) field, in air 30 K over standard at every height, the note fires and its share matches the rule. The true apogee lies past the reading plus its bound, and within the reading plus the note’s share. The same flight 30 K under standard notes the other way, and 10 K over is covered. An offset of exactly 15 K is covered, and 15.01 K isn’t. A log ending on the climb takes its share at 216.65 K. Columns of one value, zeros in kelvin, °C or °F, give no check.
Before any reading
A log passes four checks before any reading is taken from it. Each keeps the readings inside the range the bounds were checked over, or catches a track that isn’t what it says:
- It is sampled no slower than every 2 s and no faster than every 2 ms, the slowest and
fastest rates on the tuning set. Those are half a sample a second (
sampled_too_slowly) and 500 a second (sampled_too_fast). A clock a part in a thousand faster than 500 a second still reads, as a logger’s rounding of its own clock may make it. One sample log, a Raven’s CSV at 800 samples a second, is withheld as too fast. The check is on the median interval, so a short burst of faster samples can still sit in a log that passes. - Its step is no coarser than 10 m (33 ft), or 100 Pa for a pressure (
step_too_coarse), the coarsest checked on the tuning set. The coarsest the readers meet are a MARSA’s 8.8 m (29 ft) heights and an ARTS2’s 92 Pa raw counts. - Its clock increases (
clock_out_of_order). A reader keeps a channel’s clock as the file writes it. That clock can repeat or run back, as a GNSS receiver’s fixes or a team’s merged table do. - Its climb slows as a coast does. A coast loses in the last before its top, 78.5 m
(257 ft) in 4 s, gravity slowing it and drag only adding. A track must lose more than twice its
noise and step in the 4 s before its top, or it is withheld
(
slower_than_free_coast). The threshold is 6.6 m (22 ft) on a PerfectFlite. It isn’t a coast’s 78.5 m (257 ft), since a flight whose motor burns into those 4 s loses less.
A burst of samples. The rate check above is on the median interval, so a hostile or damaged file can hold a short burst of faster samples. Without a limit, a fit would walk the whole burst for each sample in it, and the time would grow as the square of the burst. So each least-squares slope reads at most twice its window’s steps at 500 samples a second, plus one: 501 samples for the 0.5 s top-speed fit, 1,001 for the descent rates’ usual 1 s fit, and 10,001 at the descent fit’s 10 s limit. A window holding more is read at every n-th sample, n the smallest whole number that brings the count within the cap. A log sampled no faster than 500 a second is read whole. The descent rates’ running median sizes its window from the descent’s median interval, but never from one shorter than the rate check allows. The landing’s search moves forward only.
Tests pin each of these. They count the samples a burst’s window is read at, and check the median’s window at a burst’s interval. A descent with a burst in its main leg still reads its drogue’s leg. Landing over a burst of 600,000 samples that dips to the pad and rises past the landing ceiling is held under 5 s; a walk over the burst for each sample took 47 s there once, on a fast desktop. The fits read at every n-th sample weren’t checked against the bounds, as the tuning set holds no log with a burst.
A disturbed top. A top that isn’t the coast’s is withheld as disturbed_top, by either of
two checks. Which point is the apogee can’t be told, so the apogee, the top speed and landing are
withheld; liftoff is still given.
- A fall before the top. A coast doesn’t fall and rise again. Take a track that falls more than twice its noise and step below a peak in the 4 s before its top. If it then climbs to that top, it holds a top that a disturbance after apogee made. An example is a deployment’s pressure bump that lasts longer than the 0.3 s median takes out. A top such a bump holds after apogee can put the apogee’s time past its bound.
- A spike at the top. A coast slows into its top at gravity and drag. Near the top drag is smaller than gravity. So it climbs no more than in its last , as a body slowing at twice gravity would. And nothing falls from its top faster than gravity pulls it. A track holds a spike, such as a charge’s, if two things happen near its top. Near means within a second either side, or two samples on a slower track. It climbs into the top by more than in its last . And it falls from it faster than a body at rest there can. Each exceeds its limit by more than twice the track’s noise and step. The fall allows for the filtered top trailing the true one. That allowance is the speed a fall from rest gathers within the median’s window and twice the noise and step. Then comes gravity’s fall from there.
The ballistic coefficient is the mass over the drag coefficient times the frontal area. Drag’s upward share stays under gravity over a last second for any ballistic coefficient over 150 kg/m², even at 120 m/s (394 ft/s) across. A rocket 29 mm (1.1 in) across, of 0.3 kg, has about 800. That covers a 1 s span. On a slower track the span is two samples, up to 4 s at half a sample a second. There the argument holds only over about 380 kg/m² on a vertical coast, and about 700 kg/m² at 120 m/s (394 ft/s) across. Below that a coast can climb into its top faster than the check allows. So a good top that a charge then drops fast may be withheld. The check only withholds, so it never reads such a top wrong.
On a PerfectFlite logging 20 times a second, twice the noise and step is 6.6 m (22 ft). So a coast climbs at most 16.42 m (54 ft) in its last second. In the tests, a step 20 m (66 ft) above a coast’s top is 0.6 s wide. It falls 29.0 m (95 ft) from the filtered top in one sample. A body at rest there falls at most 20.9 m (69 ft), so the track is withheld.
Either half of a spike alone is read, as a good top makes each. A parachute open before apogee slows the climb into the top harder than a coast does, but not the fall from it. The tests’ chute, opened at 40 m/s (131 ft/s), climbs 20 m (66 ft) in its last second, then falls at gravity. A charge that raises the bay’s pressure at the top drops the track fast, but only after the coast’s own climb. That climb is 50 m (164 ft) for half a second in the tests. Both read their apogee within its bound.
Two public logs of a charge’s transient show both outcomes (#702, a transient read as the peak; Public logs of faulty flights). A TeleMetrum log from a forum thread, whose raw peak was one sample of a pressure spike after the charge, now reads the coast’s peak. The median takes the one sample out. An MIT-licensed Blue Raven log of a breakup is withheld by the spike check. The tests rebuild both shapes with invented numbers.
Another check guards a height that is above the pad only by a word. A column mapping can call a
column an altitude above the ground, and a column’s header can say so, but neither proves it. Such
a track must start within 19.9 m (65 ft) of its zero (starts_off_the_pad). A logger zeroes on the
pad, and its zero moves with the weather and the noise before launch. The 19.9 m (65 ft) is an
hour on the pad plus the 3 m (9.8 ft) noise. The hour’s rate is the National Weather Service’s for
pressure rising rapidly or falling rapidly, 0.06 inHg (203.2 Pa) an hour. At sea level’s density,
1.225 kg/m³, an hour’s 203.2 Pa is 16.9 m (55 ft) of height, and the noise makes up the rest. The
hour is HPR Sim’s choice.
That check closes the first half of #646: an altitude above sea level mapped as one above the ground. Its second half, a clock in milliseconds read as seconds, is caught by the checks above. The samples come a thousand times too far apart, slower than every 2 s at any logger rate below 500 a second. And a track on such a clock loses less than a tenth of a millimeter in the 4 s before its top. A coast loses 78.5 m (257 ft) in the same time. A test holds both halves both ways: the wrong unit withheld by name, the same flight in its right unit read.
When a reading is withheld
A withheld reading has a code and a sentence with the log’s own numbers. Only the readings that need what is missing go. A log that starts in the air on the logger’s own altitude loses its liftoff, and with it the flight time. It keeps its apogee, top speed and landing. There are 28 reasons:
| code | when | readings withheld |
|---|---|---|
too_short | the track has fewer than 3 samples; or the accelerometer has fewer than 3 before apogee | all; or the top acceleration, and burnout from the accelerometer |
no_climb | the filtered track never climbs twice the allowance and a step above its start, or 3 m (9.8 ft) above the pad, or the allowance and a step if that is higher; or, for landing, falls too little past its step and noise to time the descent | all, or landing |
starts_off_the_pad | a track above the pad only by a mapping’s or a column’s word starts more than 19.9 m (65 ft) from its zero | all |
short_pad | the first samples can’t rule out a rocket already more than 2 m (6.6 ft) up | liftoff, and a top speed at the log’s start, on a track with a zero, the logger’s own or a word’s; all on any other track |
ends_before_landing | the log ends before the track is back within the pad’s allowance and stays down for a second | landing, the flight time and each canopy’s descent |
faster_than_free_fall | the track comes down to the landing sample sooner after apogee than a fall from rest in vacuum could lose that height, , allowing a step in and a sample for the apogee’s time | landing, the flight time and each canopy’s descent |
implausible_speed | the top speed is above 4,000 m/s (13,123 ft/s), Debrief’s ceiling | the top speed, and burnout from its time |
noisy_speed | from liftoff to apogee the speed swings below zero by more than 20% of its top | the top speed, and burnout from its time |
transonic | the top speed reaches 227.7 m/s (747 ft/s) | the top speed, and burnout from its time |
sampled_too_slowly | the samples come further apart than 2 s; or, for the top speed, than 0.125 s; or, for the canopies, too far apart for 5 samples in the descent’s fit, every 0.25 s for a 1 s fit | all; or the top speed and burnout from its time; or both canopies’ descents |
sampled_too_fast | the samples come more often than every 2 ms, 500 a second, the fastest rate the bounds were checked at | all, where the heights come that fast; where the accelerometer does, the top acceleration and burnout from it |
step_too_coarse | the step is coarser than 10 m (33 ft) or 100 Pa; or so coarse for the descent near the ground that a fit holding four steps would span more than 10 s | all; or both canopies’ descents |
slower_than_free_coast | the track loses no more than twice its noise and step in the 4 s before its top | all |
disturbed_top | the track falls more than twice its noise and step below a peak in the 4 s before its top, then climbs to that top; or, within a second either side, it climbs into its top faster than a coast and falls from it faster than a body at rest | apogee, the top speed, landing, and the readings that need them |
disturbed_pad | the track falls before the climb and climbs without resting | the top speed; liftoff with no pad before the fall; all on a short pad with no zero |
clock_out_of_order | the height track’s clock doesn’t increase; or the accelerometer’s runs back | all; or the top acceleration, and burnout from the accelerometer |
no_height_track | the log holds no altitude, pressure or GNSS track | all |
unstated_sensor | the log’s only height doesn’t say whether a barometer or a GNSS receiver measured it | all |
receiver_lag | the only height is a GNSS receiver’s, whose filter lags a climb and overshoots its top | apogee, the top speed, and burnout from its time |
receiver_dropout | the only height is a GNSS receiver’s, whose fix drops out or lags at liftoff | liftoff, and the flight time |
needs | the reading needs another that was withheld, such as landing on a GNSS track | as the sentence says |
bad_record | the record breaks what every reader guarantees: tracks as long as their clocks, on finite times that increase. No file reader produces one; only a record built by hand in code can | all |
no_accelerometer | the log has no accelerometer | the top acceleration; burnout comes from the top speed’s time |
axis_unstated | the log’s accelerometers don’t say which lies along the rocket’s axis, such as a board’s three axes or a table’s column read by its header | the top acceleration; burnout comes from the top speed’s time |
gravity_unstated | the axial accelerometer’s readings may or may not hold gravity’s 1 g, and neither its family, nor its pad, nor its coast to apogee settles which, or they disagree, or only a coast at −1 g says | the top acceleration; burnout comes from the top speed’s time |
direction_unstated | which way up the axial accelerometer reads isn’t settled: of its pad (about 1 g nose up, about −1 g nose down), its coast to apogee (−0.75 g or less nose up, 0.75 g or more nose down) and its thrust (the first span past 2 g to hold there for 0.5 s, unless a span the other way comes first), none says or two disagree; or, turned as they settle and gravity put back, the trace never passes 2 g from liftoff’s earliest time to apogee, so shows no thrust | the top acceleration and burnout from the accelerometer; burnout comes from the top speed’s time |
one_canopy | the descent shows no drogue’s leg: at the ground’s density, its rate in the 2 s before the main’s leg never passes the main’s mark, 1.6 times the rate near the ground or 3 m/s (9.8 ft/s) more if that is more, or the descent before that leg doesn’t fall, on median, faster than 1.4 times that rate. A drogue no faster than the mark reads as one canopy, whatever its ratio to the main, and so does a rocket under one canopy or none | the drogue’s descent; the main’s is read from apogee, the whole descent’s |
short_leg | a leg of the descent loses no more than 3 m (9.8 ft) or a tenth of its top’s height; or the whole descent loses too little, or falls too slowly near the ground, to time a leg by | that leg’s descent; or both |
“All” means liftoff, apogee, the top speed and landing, with the flight time, burnout and each
canopy’s descent that need them. The top acceleration is searched for up to apogee, so a reason
that withholds the apogee withholds it too. The exception is a log with no axial accelerometer,
which is said first (no_accelerometer or axis_unstated). A burnout the accelerometer can’t give falls
back to the top speed’s time, and carries the top speed’s reason where that is withheld too.
An apogee within half a window of the log’s end is read, but marked is_floor: the log may have
stopped before the rocket did. The top speed and the smoothed apogee are then floors too, with no
interval. Only a test’s cut flight has checked this: no synthetic log ends on the climb.
Two logs on one timeline
Each logger counts from a zero of its own, so two logs of one flight need their clocks lined up before they can be read together. Every board in a stack leaves the pad at the same instant, so each log’s liftoff reading is the same moment on its own clock, the method Debrief used (MIT; its reasoning and the rules it measured and deleted). The offset is the second’s liftoff less the first’s:
with each log’s liftoff and its bound. is the most the two errors can add to. Its 90% interval runs from to , the two shares the 5% and 95% points of the error over the bound on two-logger flights of their own (ADR-257, calibrated intervals, §1, and ADR-312, two logs on one timeline).
A worked example, RocketPy’s Prometheus flight. The TeleMetrum reads liftoff at 0.23 s within 0.71 s, the TeleMega at 0.18 s within 0.83 s. So = 0.18 − 0.23 = −0.05 s, within about 1.53 s (the command adds the unrounded bounds). The interval is −0.05 − 0.0515 × 1.53 = −0.13 s to −0.05 + 0.0526 × 1.53 = 0.03 s; the command, from the unrounded figures, prints −0.13 to 0.04 s. Each receiver’s UTC second, taken where it ticks in its log, puts the TeleMega’s clock less the TeleMetrum’s at −0.13 s. Over all 238 paired ticks that scatters from −0.24 to −0.03 s, and over the 72 at 100 samples a second from −0.15 to −0.11 s. A fixed difference between the receivers’ delays can’t be seen. So this offset is about 0.08 s away, and the interval’s low end, −0.129 s, is too close to that figure to say which side it falls. Both logs start at the boost, so an offset of zero would miss by 0.13 s, against this offset’s 0.08 s: a weak check, and one flight can’t show the interval’s coverage.
Checked against. On two-logger synthetic flights (their sets), every one of the 1,383 offsets given stayed within its bound, by 0.13 of it at most, the error’s median 0.03 s and its largest 0.21 s. A log with no barometer gives no liftoff, so its flight gives no offset: 617 of the 2,000. On the two-logger sets A and B the interval held the truth 622 of 703 and 612 of 680 times, passing the coverage test, and narrowed to 0.8, widened to 1.25 and shifted down it fails. All 135 offsets the 200 staged flights gave stayed within their bounds; there the interval missed none, so it is wider than it need be on those flights (the report).
What it leaves out. One number per pair: a clock running fast or slow isn’t corrected, by about 15 ms over a 300 s flight at a crystal’s 50 ppm. A board that wakes late or a log cut before liftoff has no liftoff to line up by. Nothing checks that the logs are of one flight. Two boards can agree and both be off by the same day’s air, so the spread says how far apart they lie and no more. On one real pair only (evidence row G35), and on no real staged flight (evidence row G36).
Validation and limits
Checked against
The synthetic flights’ tuning set. The synthetic flights are flights
HPR Sim simulated, each with its truth and the log a simulated logger would write. Of the tuning
set’s 200 flights, 171 carry a barometer; the other 29, a GNSS tracker’s, give no reading by rule.
cargo xtask synthetic reads each of the 171 as its own logger wrote it. It then reads each
again 36 ways in all. They cover every rate from 500 to half a sample a second. They cover every
step from none to 10 m (33 ft) or 1 to 100 Pa. Last, it reads each cut 6 ways, as
loggers that record from launch write them. Each is 20 samples a second, in feet or in 10 Pa
steps. Each starts 0.3 s before liftoff, 0.1 s after, or 0.5 s after with the zero first.
The 71 flights whose logger has an accelerometer are the AltOS-like and the IMU profiles. They are read
again with it at 500, 100 and 20 samples a second. The 500 Hz IMU profile’s 38 are read once more with
its part set to ±8 g (The acceleration). Some
tops then clip at the part’s range and the rest don’t. Every reading given stayed within its bound,
and the check fails the build if one doesn’t. A floor holds while it is no more than its bound
above the truth. The largest share of its bound any error took, from the
report
and its JSON:
| reading | largest share (of the bound) | on the log | its error, against its bound |
|---|---|---|---|
| liftoff | 0.603 | 500 samples a second, heights with no step | 0.387 s within 0.643 s |
| apogee height | 0.717 | 20 samples a second, heights with no step | −151 m (−495 ft) within 210 m (689 ft) |
| apogee time | 0.562 | 20 samples a second, pressure in 100 Pa steps | −1.04 s within 1.85 s |
| top speed | 0.544 | 20 samples a second, pressure in 100 Pa steps | 13.7 m/s (44.9 ft/s) within 25.1 m/s (82.3 ft/s) |
| landing | 0.572 | 5 samples a second, pressure in 100 Pa steps | −3.89 s within 6.8 s |
| flight time | 0.507 | 500 samples a second, pressure in 100 Pa steps | −1.89 s within 3.73 s |
| descent rate | 0.594 | 100 samples a second, heights with no step | −1.16 m/s (−3.8 ft/s) within 1.95 m/s (6.4 ft/s) |
| top acceleration | 0.737 | its accelerometer at 20 samples a second | −13.7 m/s² within 18.6 m/s² |
| burnout | 0.544 | 20 samples a second, pressure in 100 Pa steps, a floor from the top speed | 0.718 s within 1.32 s |
| drogue rate | 0.702 | 5 samples a second, heights with no step | −0.944 m/s (−3.10 ft/s) within 1.35 m/s (4.43 ft/s) |
| main opening | 0.641 | 100 samples a second, pressure in 10 Pa steps | 0.617 s within 0.963 s |
| main rate | 0.7 | 500 samples a second, heights with no step | −1.17 m/s (−3.84 ft/s) within 1.68 m/s (5.51 ft/s) |
The report also gives each reading’s errors over every tuning flight and every log together. It gives them beside the mean bound the readings stated (Errors on the tuning set). An error is the reading less the truth. Each error is held to its own reading’s bound. That bound differs from flight to flight and log to log, so the least or the most may pass the mean bound. The mean is for scale. A canopy’s rates are compared with the truth over the span the reader chose, its leg’s ends. So an opening read early or late shows in the opening’s error, not in the rates’. A floor is counted apart, as it may lie any amount below the truth. A floor is a burnout from the top speed, a top speed on a log cut on the climb (none in these sets), or a top acceleration that clipped or whose thrust has no end on the channel. The least, the most and the mean bound are to three figures, nearest. A mean is given to the decimal place of its largest error’s third figure, the digits every platform shares:
| reading | given readings | mean error | least | most | mean bound |
|---|---|---|---|---|---|
| flight time | 7,007 | −0.73 s | −5.06 s | 3.48 s | 5.82 s |
| top acceleration | 290 | 0.6 m/s² | −13.7 m/s² | 13 m/s² | 16.3 m/s² |
| top acceleration, a floor | 32 | −48.1 m/s² | −75.9 m/s² | −1.58 m/s² | 12.9 m/s² |
| burnout, from the accelerometer | 296 | −0.0104 s | −0.0943 s | 0.0476 s | 0.544 s |
| burnout, a floor | 1,237 | −0.24 s | −1.03 s | 0.718 s | 1.3 s |
| drogue rate | 2,842 | 0.04 m/s (0.13 ft/s) | −1.61 m/s (−5.28 ft/s) | 1.35 m/s (4.43 ft/s) | 1.79 m/s (5.87 ft/s) |
| main opening | 2,842 | 0.73 s | −0.778 s | 5.3 s | 2.03 s |
| main rate | 5,424 | 0.04 m/s (0.13 ft/s) | −5.47 m/s (−17.9 ft/s) | 4.83 m/s (15.8 ft/s) | 1.71 m/s (5.61 ft/s) |
Burnout from the accelerometer lands within 0.0943 s of the truth, to three figures, against a mean bound of 0.544 s. Without it, the top speed’s time comes 0.24 s before burnout on average, as a speed’s peak should. It ranges from 1.03 s before it to 0.718 s after, within its bound. The floor, that time less its bound, about 1.3 s on average, lies earlier still. The main’s opening is read late on average, by 0.73 s. Its bound holds the time a canopy takes to slow the fall and half the fit.
No tuning flight’s true top acceleration reaches the range its own part clips at: the nearest comes to 0.492 of it, the report says. So the 500 Hz IMU profile’s 38 flights are logged once more with the part set to ±8 g. The BMX160 and the MPU-6000 offer that full scale. Of the 38 flights’ true tops, 28 reach that range, and 10 don’t. Of the 32 tops read as floors, 28 are clipped at the range, all on that log, each a floor that holds. The floors’ mean error, −48.1 m/s², is mostly how far those clipped tops lie below their truth, as a floor may by any amount. The other 4 are held flat at their top, all on the AltOS-like profile’s ADXL375-class part read at 20 Hz. That is consistent with its noise there, 19.8 mg by the synthetic flights’ noise model, being under half its 49 mg step. So it writes most of a thrust’s plateau as one value. But no test pins a quiet part that reads as flat (ADR-283). No tuning-set top reads as a thrust with no end.
On their own logs, the main’s opening was found on 87 tuning flights with a barometer, each within
its bound. On no log was a main named on a flight that opened one canopy or none. Those are
counted as none to read. On logs sampled once a second or slower, the
canopies are read only where coarse steps widen the descent’s fit enough to hold 5 samples.
Elsewhere they are withheld, most as sampled_too_slowly, some as ends_before_landing (up to 11
of 171 at half a sample a second) and one as step_too_coarse.
The same report counts each reading withheld, by reason. At 20 samples a second and faster, the top
speed is withheld as transonic on 117 or 118 of the 171 flights. At 5 samples a second and
slower, it is withheld as
sampled_too_slowly on all of them but the one withheld whole below. At half a sample a second, up to 11 flights end before their
landing is seen. In 10 m (33 ft) steps one flight’s track is withheld whole as
step_too_coarse. The logs written again are read as tables a column mapping states, so their
heights are above the pad only by the mapping’s word. Of the cuts, heights from 0.1 s after liftoff
withhold liftoff as short_pad on 36 flights. Heights from 0.5 s after, the zero first, withhold it on all
171. Both give the apogee on all 171, within its bound with the zero’s possible error in it, at up
to 0.695 and 0.674 of it. A pressure has no zero set on the pad, so a pressure cut after liftoff withholds every
reading on all 171. A pressure cut from 0.3 s before liftoff does so on 3. No tuning flight is withheld as
disturbed_top or slower_than_free_coast.
The tuning set shows the bounds hold on the flights they were tuned on. It doesn’t show how often they would hold on others, nor on real logs. The flights are HPR Sim’s own, with a noise model taken from datasheets and a few public logs (Synthetic flights).
An invented flight. The file
synthetic-pnut.pf2
holds a flight made up for the tests. It sits on the pad for half a second, then accelerates at
50 m/s² for 1.6 s and coasts with no drag. It falls from rest to 25 m/s (82 ft/s). It descends at 25 m/s (82 ft/s) to
150 m (492 ft) and at 6 m/s (20 ft/s) to the ground. It is written as a Pnut writes one, rounded to whole feet and
feet per second. It has an ejection pulse of the public log’s shape a second after apogee. Every
reading is known in closed form. The
tests
hold each within its stated bound, and within a tighter one worked out beside it for this log
(evidence row G10):
| reading | true | HPR Sim reads | its bound | the test’s tighter bound |
|---|---|---|---|---|
| liftoff | 0.50 s | 0.80 s | 0.81 s | from 0.50 s to 0.814 s, once the rocket has climbed 2 m (6.6 ft), a foot and the half foot that rounds it up |
| apogee | 390.31 m (1,280.5 ft) | 390.14 m (1,280 ft) | 31.9 m (105 ft) | 0.23 m (0.75 ft): half a foot of rounding and the median’s 0.077 m (0.25 ft) |
| apogee time | 10.258 s | 10.275 s | 0.88 s | one sample, 0.05 s: the middle of the flat run at the top |
| top speed | 80.0 m/s (262 ft/s) at 2.10 s | 78.3 m/s (257 ft/s) at 2.20 s | 20.6 m/s (68 ft/s) | no higher than the truth, and no lower by more than the fit’s cut across burnout, 3.7 m/s (12 ft/s), and half a foot a second |
| landing | 46.14 s, touchdown | 45.80 s | 2.11 s | up to 0.38 s early: 2 m (6.6 ft) at 6 m/s (20 ft/s) is 0.33 s, and a sample more |
| flight time | 45.64 s | 45.00 s | 2.91 s | follows from liftoff and landing |
| mean descent rate | 10.93 m/s (35.9 ft/s) over HPR Sim’s span, 10.275 s to 45.80 s | 10.92 m/s (35.8 ft/s) | 2.1 m/s (6.9 ft/s) | the two heights’ bounds over the span |
| burnout | 2.10 s | no sooner than 0.88 s: the top speed’s time, 2.20 s, less its bound | 1.32 s | none tighter: a floor, no more than its bound after the truth |
| drogue rate | 21.74 m/s (71.3 ft/s) over HPR Sim’s span, 10.275 s to 21.40 s, the fall from rest at apogee in it | 21.7 m/s (71 ft/s) | 2.2 m/s (7.2 ft/s) | the two heights’ bounds over the span |
| main opening | 21.14 s, 150 m (492 ft) up | 21.40 s, 148.4 m (487 ft) up | 1.06 s | on this log, whose drogue falls far faster than the mark: no sooner than the truth, and no later by more than half the 1 s fit and a sample, 0.55 s |
| main rate | 6.0 m/s (20 ft/s) | 6.0 m/s (20 ft/s) | 0.8 m/s (2.6 ft/s) | the two heights’ bounds over the span |
The middle of the flat run at the top falls between two samples here, so the apogee time is
10.275 s. hpr analyze prints times to two decimals, as 10.28 s and
9.47 s after liftoff. The first sample of the flat run at the top would read the apogee over 0.2 s
early. A test shows that too, so the rule of taking the run’s middle is pinned. The file’s highest
sample is the pulse’s, 400.5 m (1,314 ft). The Hampel filter keeps it, and the median sets it
aside; a test holds both.
A real flight. Debrief ships a public PerfectFlite Pnut log, trimmed from a publicly shared
flight. Its terms upstream are unclear, so it isn’t committed here, and CI doesn’t have it. Where
it has been fetched (cargo xtask refs fetch), a
test reads it. The test
holds the apogee above the altimeter’s zero, the highest sample, the pad, and each reading with
its bound:
| the altimeter states | HPR Sim reads | |
|---|---|---|
| apogee | 1,009 ft above the pad | 1,009 ft (307.5 m) above the pad, within 27.4 m (90 ft); 1,010 ft above the altimeter’s zero, its pad a foot above it |
| highest sample | 1,028 ft above the zero, the ejection pulse, set aside | |
| top speed | 264 ft/s (80.4 m/s), within 29.7 m/s (98 ft/s), derived from the heights | |
| liftoff | 0.40 s, within 0.98 s | |
| landing | 72.70 s, within 3.25 s |
The altimeter’s apogee comes from the same pressure trace. So the agreement shows that HPR Sim reads the trace as the altimeter does, not that either is the true height. A Featherweight Raven flew on the same flight, and Debrief reports it agreeing at about 1,009 ft.
The sample logs. cargo xtask logs takes the readings from every record the project’s sample
logs hold. Those are other flyers’ files kept outside the repository. The command counts each reading given or
withheld, by logger family and by reason
(the survey’s report).
Of the 1,058 records, summed over the report’s families, an apogee is given from 592, liftoff from
549 and the top speed from 353. Landing is given from 471, the flight time from 404 and burnout
from 426. The top acceleration is given from 160, the drogue’s descent from 277 and the main’s
from 458. Each of the 28
reasons has a case. For 24, the case is the first file the survey withholds a reading of for it, by an
anonymous id. For the four that none of
the sample logs triggers (bad_record, faster_than_free_fall, starts_off_the_pad and
step_too_coarse), the case is an invented file under
validation/fixtures/logs/readings/.
A test reads it to its reason. The invented fall, for one, drops at 15 m/s (49 ft/s) for 3 s
after apogee, then at 300 m/s (984 ft/s) to the ground. These counts show what each logger can give. They don’t show how
right a reading is: none of the sample logs has a truth beside it.
Four reasons stand out. The top speed is withheld as transonic on 197 records: many of these
flights are fast. Liftoff is withheld as short_pad on 157, 71 of them from loggers whose files
start close to liftoff. Those are 37 of 51 RRC3 CSV records and 34 of 44 Eggtimer CSV records. And the
apogee, top speed and landing are withheld as disturbed_top on 75. The top speed is withheld as
disturbed_pad on 10, liftoff on 5.
The new readings’ reasons follow the loggers. The top acceleration is withheld as no_accelerometer
on 682 records, 17 of them the AltOS files above. It is withheld as
axis_unstated on 136, whose boards or tables don’t say which accelerometer lies along the rocket.
It is withheld as gravity_unstated on 10, and as direction_unstated on 6. On one, nothing says which way up the
accelerometer reads. It never passes 2 g either way, and the log holds no pad or coast to tell by.
On one, the coast reads near +1 g, nose down, against a pad and a thrust that say nose up. On three
AltOS CSV records, gravity taken out, the pad says nothing and a short burn comes before a heavy
drag. So the thrust says nothing either. On one, the accelerometer’s thrust rises after liftoff’s
latest time by the heights, its clock running late against theirs. The drogue’s descent is withheld
as short_leg on 12, and as one_canopy on 173, where the descent showed no drogue’s leg. With no
truth beside the logs, that doesn’t say how each rocket came down.
What it leaves out
- The day’s air. A logger’s height is its own conversion of the pressure, which assumes a
standard atmosphere. On a warm day a barometric altimeter reads low, 6.5% on a day 20 K warmer
than standard (Atmosphere).
HPR Sim doesn’t correct it: it widens the bound by 6.92% of the height instead, which covers air
up to 15 K from standard. On a day further off, a height can pass its bound. Where the log
records the pad’s temperature and its height above sea level (from its pressure, an altitude
above sea level, or a stated ground elevation),
hpr analyzenotes such a day with its size, and leaves the bound as it is (A day past 15 K). - Loggers unlike the tuning set’s. The bounds hold on the tuning set’s six simulated logger profiles, at their noise. A logger noisier than they are, or a rocket slower off the pad than 2 g, can be read outside its bound. A pad that drifts within the 2 m (6.6 ft) allowance, early one way and late the other, can read liftoff outside its bound. A review measured up to 1.22 times the bound at ±2 m (6.6 ft) on a synthetic climb. On a short pad, a zero only a word vouches for is placed by the first sample unfiltered. So its error can be understated by that sample’s noise, up to 3 m (9.8 ft) (#773, the pad error’s noise budget).
- Rockets slow off the pad. The liftoff bound and the pad’s error assume at least 2 g off the pad. A rocket slower than that is read later than its liftoff bound. It may already be further up, when a log starts, than its pad’s error allows.
- Fast flights’ top speeds. The top speed is withheld from 227.7 m/s (747 ft/s), and so is a burnout taken from its time where no accelerometer gives one. The heights aren’t checked for the port’s error near the speed of sound. The apogee, read near the top where the rocket is slow, stays within its bound on the tuning set, whose fastest flight reaches Mach 1.12.
- A short stay on the pad. The climb’s first rise counts toward a rest, so a short stay on the pad after a carry down is read as a pulse from the higher level. After a 30 m (98 ft) carry and before a 4 g climb, that is up to 0.2 s from the stay’s first sample to its last at 20 samples a second (0.15 s on a pressure track), up to 0.35 s with the pad’s noise 2.3 m (7.5 ft) either side, two samples at 5 and at 3.3 a second, and one at 2.5. The apogee then reads low by the drop, past its bound on a 98 m (322 ft) flight at 20 samples a second for a drop of more than about 10 m (33 ft).
- Wide pulses. A pulse wider than half the median’s window passes it. The bounds were held on the synthetic flights’ pulses, which are shaped like the public Pnut log’s and scaled by 0 to 2. A wider or taller one isn’t covered.
- The deployments, the Mach number and dynamic pressure. The main’s opening is read from the descent’s rate, not from a deployment the log records, and the drogue’s leg is read from apogee. The Mach number and dynamic pressure aren’t read: they need the speed and the air all along the climb, which the readings don’t reconstruct.
- A canopy’s filling time. The opening’s bound holds the time an open canopy takes to slow the fall, not the time it takes to fill. The synthetic flights open each canopy at once, so a main that fills slowly can be read later than its bound (#779).
- A fall under no canopy. A rocket that came down under no canopy has its fall read as one
canopy’s
main_descent: the rate alone doesn’t tell a canopy from none. The tuning set’s flights of Cavour, a design with no parachute, read that way (#780). - A descent from far above the tropopause. The scaling to the ground’s density slows a rate read high up and never quickens it. The exception is about 1% in a surface inversion (The canopies). This holds while the density from the pad up falls no faster than . Through the troposphere it falls slower, as its scale height is at least 7,289 m (23,914 ft). Above it, about 11 km (36,000 ft) up, the scale height is about 6,340 m (20,800 ft). On a day 15 K cold it is 5,903 m (19,367 ft). From a pad at sea level, the 1976 standard atmosphere’s density stays above to 34.6 km (113,500 ft) up. On a day 15 K cold it does so only to 21.3 km (69,900 ft). From a pad 1,500 m (4,921 ft) up, the limits are 28.3 km (92,800 ft) and 17.7 km (58,100 ft) above it, each rounded down. A canopy from higher could read faster than it falls near the ground, and one canopy as two. The heights are the standard’s geopotential heights, a little less than a height measured straight up, which puts the limits low, not high. The tuning set’s apogees reach 4,420 m (14,500 ft), so it can’t show this.
- More than one burn. An air start’s or a sustainer’s second burn is searched for the top. But the tuning set’s ten designs each fly one motor in one stage, so its bound isn’t checked on one. Burnout then comes from the speed’s peak, a floor. A second burn that holds past 2 g for less than 0.5 s is taken for a shock. So its top is missed and burnout is the first burn’s end. A shock that holds there longer reads as a burn. Where liftoff is withheld, a knock on the pad wider than the cleaning takes out joins the burn. The knock can be taken for the top (#789). A part that reads above zero all through the coast, as a part that zeroed off its pad’s level can, never ends its burn. So its top is searched to apogee and given as a floor, and its burnout comes from the speed’s peak.
- Noise that runs from sample to sample. Averaging samples cuts the noise by only where each sample’s noise is its own. A part whose noise runs on, as its own low-pass filter or a slow drift makes it, keeps more of it through the average. So comes out too small and burnout’s bound too narrow. The synthetic flights draw each sample’s noise apart, so they can’t show this (#787).
- Clipping at the high-g part’s range. Clipping at a part’s range is held on the tuning set only on the low-g IMU part set to ±8 g, where 28 tops clip. No tuning flight’s true top reaches its own part’s range, ±32 g or ±180 g (the loggers). So a high-g part’s top clipped at its range is held only by the unit tests. A clipped top is a floor either way.
- The coast’s witness. It assumes the drag in the last second before apogee’s earliest time is under 0.25 g. A rocket still fast at apogee, arcing over, reads its drag there. The witness then says nothing or, past 0.75 g, can disagree with a family’s word and withhold the top acceleration (ADR-283). Alone at −1 g it settles nothing (#806). A net push forward of between about 0.75 and 1.25 g (thrust less drag) still acting in that second reads as gravity in, and the top then reads 1 g low (#1131, untested).
- A board’s three axes. A log whose accelerometers don’t say which lies along the rocket gives
no top acceleration (
axis_unstated), and its burnout comes from the top speed’s time. The axes’ magnitude could give a top acceleration, but not burnout, as it never falls below zero (#781). - Intervals. A bound is a worst case held on the tuning set, not a 90% interval with a tested chance of holding the truth. Twelve readings state one too, a floor a lower end in its place (The 90% intervals).
- A GNSS track. A log whose only height is a GNSS receiver’s gives no reading. The receiver’s lag and overshoot aren’t modeled, so no bound can be stated for it.
- Disturbed tops, both ways. Some bumps come less than about a second after apogee, before the track has fallen past its noise and step. Such a bump can’t be told from the top unless it is a spike. The bump’s time may pass the apogee’s time bound. A transient that only climbs in fast, or only falls out fast, is read as the top. That is because an early parachute and a charge make those shapes on a good top. A spike that climbs in no faster than a coast is read as the apogee, however high it stands. The other way, a brief dip in the coast in the last 4 s before the top withholds a good apogee. How many of the sample logs’ 76 such tops are good isn’t measured (#762). The synthetic flights model no charge’s transient, so the bounds aren’t tested against one (#761).
Tests and references
Tests
hpr_flightdata::readings: a plain flight read within its bounds. The same flight read alike from a pressure channel, an altitude channel above sea level and the logger’s own track. A GNSS altitude withheld by name. Each withheld code on a log built to trigger it, only the readings that need it going. The pad’s rules, with a jitter in the first samples, noise up to the allowance and a slow noisy pad. A pad short by its samples and one read from the logger’s zero. A vacuum fall rounded to feet landing at 10 to 100 samples a second and one at 1.3 g refused. #646, a wrong unit or a wrong zero in a mapping, both ways. A mapped track’s short pad read from its zero within the allowance, its apogee’s bound grown by the distance, and withheld past it. A top held by a fall or a spike withheld, each by its own rule. A top with an early parachute or a later charge read. The shapes of the two public logs of #702, with invented numbers. The step and the clock at their edges. The top speed’s guards, each on its own. A property test of the median’s peak bound for every from 1 to 6 and every place the peak can fall between samples.hpr_flightdata::readings::accelerometer: a noisy axial trace’s top and burnout read within their bounds, burnout within a sample of the thrust’s end. A part mounted nose down, with gravity taken out, read alike. A dip, and a knock with its rebound first, on the pad not turning the trace over. A short burn before a heavy drag read nose up, gravity in and out, and nose down when mirrored. A pad that disagrees with the thrust withheld. A weak thrust on a log without gravity settled by its coast, or withheld where a heavy drag’s span disagrees. A coast before the trace moves, or in a log that ends in the thrust, saying nothing. Three traces that show no thrust withheld, each by its own words. The thrust’s witness and the pad’s and the coast’s levels, each way they say. A top held at the part’s range marked clipped at the range, the truth above the reading less its bound, and a quiet plateau not. An accelerometer that ends in the thrust giving its top as a floor and no burnout. Gravity left unsettled withholding the top acceleration and sending burnout to the top speed’s floor. The coast settling gravity where the log holds no pad. A repeated time keeping its first sample, and one after a sample with no time left out. A peak between two samples within the top’s bound. A trace that never falls below zero giving burnout as a floor from the top speed. The noise measured as the scatter about the curve, a straight line’s as 0.hpr_flightdata::readings::canopies: a drogue to 150 m (492 ft) at 25 m/s (82 ft/s), then a main at 6 m/s (20 ft/s). Each leg’s rate and the opening read within their bounds. The opening’s bound holding the main’s slowing time to its 9.6 m/s (31.5 ft/s) mark beside half the fit. One canopy withholding the drogue and reading the main from apogee. A drogue no faster than the main’s mark read as one canopy. A drogue passing the mark for a moment, as a gust would make it, naming no main. One canopy from 8.6 km (28,215 ft) read as one at the ground’s density. Samples bunched at landing leaving the median its window. A short drogue leg withheld. A track too coarse for the main’s fit withholding both.hpr_flightdata::readings::day_air: an invented flight in air 30 K over standard, its note, its share against the rule and the truth within it; 30 K under, the other way; 10 K over, covered. The edge, exactly 15 K, covered both ways and 15.01 K not. A log ending on the climb, its share at 216.65 K. No note with no height above sea level, no temperature, or one that can’t be the air: out of range, or one value throughout (zeros in kelvin, °C or °F). The standard’s temperature against its table.hpr analyze’s own tests: each note below each reading, in full, on a hot pad and a cold one; a day just past 15 K within the bound’s share; none at 70 °F; the pad’s pressure altitude named as such; and the drogue’s line calling its rate the mean from apogee.hpr_flightdata::synthetic: the invented flight, its readings against the truth (burnout, the main’s opening and both legs among them). The Hampel filter keeping the pulse the median removes.hpr_flightdata::filter: a pulse removed, a ramp untouched, the Hampel filter at zero equal to the median. Property tests that every output lies within its window and that the sliding median equals each window’s own, bit for bit.cargo xtask synthetic --check: every reading on the tuning set within its bound, at every rate, step and cut. That includes each accelerometer at 500, 100 and 20 samples a second, and the IMU’s part set to ±8 g. A floor is no more than its bound above the truth. The report is reproduced on every platform.cargo xtask logsand its tests: each invented sample read to its reason. And, where the sample logs are fetched, every record’s readings counted and the report reproduced.crates/hpr-cli/tests/cli.rs:hpr analyzeon a log alone in a folder, its JSON checked against the published schema; the public Pnut log, where fetched.crates/hpr-py/tests/test_logs.py: Python’sFlightLog.readings()equal to whathpr analyzeprints, on each invented log.
References
- J. Lei, M. G’Sell, A. Rinaldo, R. J. Tibshirani and L. Wasserman, “Distribution-free predictive inference for regression”, Journal of the American Statistical Association 113(523), 2018, §2.2, for the split-conformal rank that sets each interval’s points. V. Vovk, A. Gammerman and G. Shafer, Algorithmic Learning in a Random World, Springer, 2005, ch. 2, for its origin.
- R. K. Pearson, Y. Neuvo, J. Astola and M. Gabbouj, The Class of Generalized Hampel Filters.
23rd European Signal Processing Conference (EUSIPCO), 2015, §2, eqs. 1 and 2. Pinned as
pearson-2015-generalized-hampelin the reference lock file. - Debrief,
lib/analyze/index.tsandlib/parsers/perfectflite.ts(MIT, the project owner’s own), for the landing’s thresholds, the least climb, the speed’s refusals and the format. The same files are the source for the flat top of a clipped accelerometer and the fall through zero it takes as burnout. They are also the source for the main’s opening found back from landing, the drogue’s ratio and a leg’s least drop.lib/flight/build.tsis for the first sample kept at a repeated time. Notes are in the readings note. - The accelerometer’s scale and bias: the ADXL375 datasheet’s ±10% sensitivity (p. 3), and the bias the synthetic flights assume, which no source states. Both are in the sensor noise note and Synthetic flights.
- A canopy’s slowing after the opening: vertical motion under quadratic drag, , J. R. Taylor, Classical Mechanics, University Science Books, 2005, §2.4. is its integral from any speed down to , HPR Sim’s step.
- A canopy’s rate: drag balancing the weight, , so the rate goes as the density to the −½ (Recovery).
- The day’s air past 15 K: the hypsometric equation, , and
the temperatures of U.S. Standard Atmosphere, 1976,
NOAA-S/T 76-1562, as the height formulas note lays them out. The range a logged temperature must fall in sits beyond the coldest and hottest air on record, −89.2 °C at Vostok and 56.7 °C at Death Valley, from the WMO’s archive of weather and climate extremes. The dry adiabatic lapse rate a hot afternoon’s air tends toward, 9.8 K/km: J. M. Wallace and P. V. Hobbs, Atmospheric Science, 2nd ed., Academic Press, 2006. - The density scale height: U.S. Standard Atmosphere, 1976,
NOAA-S/T 76-1562, its troposphere’s lapse of 6.5 K/km and its tropopause’s 216.65 K (Atmosphere). The formula follows from its pressure and temperature. - The noise model and the range of air: ADR-280, the synthetic flights first §2–3, and Synthetic flights.
- The port’s error: the Mach error note §1–2, from a wind-tunnel test of the static pressure along an ogive-cylinder through Mach 1.
- How loggers turn pressure into height: the height formulas note.
- The least acceleration off the pad: the NAR’s high-power safety code. Its limit is a liftoff weight no more than a third of the motor’s certified average thrust. Tripoli’s is the other (below 3:1 only with an active stability system). The most a rail stands from vertical, 20°: the same codes.
- The rate of the day’s pressure change: the National Weather Service’s glossary, pressure rising
(falling) rapidly. That is 0.06 inHg an hour or more, the threshold of METAR’s
PRESRRandPRESFRremarks.
Synthetic flights
See the 2,200 simulated flights, with known truths and their loggers’ flight logs, on which readings and 90% intervals will be tested.
In short
- What it models: 2,200 flights of the ten public RocketPy designs that HPR Sim, FusionSpace HPR’s simulator, validates against, in three sets on fixed seeds. Each flight draws its motor, drag, wind, rail angle, site and air, and one of six simulated loggers like those FusionSpace HPR reads. The logger writes what its sensors would, each with its own noise terms. A fourth set of 2,000, the calibration set, fits the readings’ 90% intervals and isn’t in the census (The sets). Each flight’s truth is HPR Sim’s trajectory, every 0.01 s, with its dynamic pressure and Mach number.
- Sources: sensor datasheets and public logs (the sensor noise note). The port’s error is from a wind-tunnel test (the Mach error note). The ejection pulse is a public log’s, and the GNSS lag that of hobby receivers in boost (the GNSS note). The wind’s limit is the NAR’s high-power safety code. Some terms are assumed (The noise, term by term; evidence row G32).
- How well it is validated: not against real logs. The noise follows datasheets and a few public logs, and the flights are HPR Sim’s own. So a check on them shows how well a method recovers a known trajectory, not how real flights behave. Each noise term’s test holds it to its stated value and fails when it is changed. That shows the generator draws what it says, not that the terms are right. A flight drawn again is the same to the bit, on one platform. No test yet compares the terms together with a real log of the same family (#725; evidence row G32).
- What it leaves out: the bay’s vent lag, a temperature term, clock drift, vibration and the logger’s own speed column, and flights at Mach 1.18 or more, which none of the 2,200 reaches (What it leaves out).
Why simulated flights
A real log has no truth beside it. The altimeter’s own apogee comes from the same pressure trace that a reading takes it from. So the two agreeing shows they read the trace alike, not that either is right (Flight-log readings). To learn how often a 90% interval holds the truth, the truth must be known, on many flights.
Each reading and fit is to state a 90% interval. ADR-257, calibrated intervals asks that each be tested on at least 1,000 flights whose truth is known. It must miss about 5% of the time on each side. The sets were fixed before any interval was written. By rule, no interval is tuned on the flights it is judged on (ADR-280, the synthetic flights first).
A simulated flight knows its truth, but a check on it is only as good as its noise. A model that adds white noise alone flatters an interval. Real barometer noise is correlated from sample to sample, so its errors don’t average away as fast (the smoothing note §6). So most terms here come from a measurement or a datasheet. The few that no source states are said to be assumed where they are described.
A check on these flights doesn’t show how well HPR Sim predicts a real flight. That is M7.3, a flight against its simulation’s question, on real logs.
The flights
The sets
The census’s three sets, each on its own seed, written down before any method was tuned:
| Set | Flights | Seed number | Model flown |
|---|---|---|---|
| Tuning | 200 | 2026101700 | 100 of A’s and 100 of B’s, alternating |
| A | 1,000 | 2026101701 | HPR Sim’s |
| B | 1,000 | 2026101702 | its drag, wind and thrust reshaped |
By rule, anything fitted or tuned uses the tuning set, and sets A and B only judge. A fourth set,
the calibration set, fits the points that scale the readings’ 90% intervals
(The 90% intervals). Its 2,000 flights are drawn as the tuning
set’s are, alternating A’s model and B’s, on seed 2026102900. That seed was fixed on
October 29, 2026, after the readings and the smoother were tuned and before any reading’s interval
existed. The census and the smoother’s check don’t fly it. Flight
of a set draws each group of inputs (its design, motor, drag, wind, rail, site, model and
logger) from its own stream. The stream is keyed by the set’s seed, and the group. So a
set’s first flights stay the same if it grows, and an input added to one group moves no other group.
Set B flies a model that differs from HPR Sim’s on purpose, so that a method can’t pass by knowing HPR Sim’s model:
- The drag rises differently through Mach 1. The zero-lift drag is multiplied by , where . Here is between −0.2 and 0.2 and is between −0.05 and 0.05.
- The wind grows with height as a power law, its exponent 0.14 to 0.20, the drawn speed at 18.3 m (60 ft), after NASA/TM-2008-215633 §2.2.5.2. That report ties the larger exponents to lighter winds; here the exponent is drawn on its own. Set A’s wind is the same at every height.
- The thrust curve is tilted: its thrust times , with between −0.3 and 0.3, then scaled back to the same total impulse.
What a flight draws
| Input | Range | Why |
|---|---|---|
| design | one of the ten | the RocketPy designs, each with its example’s parachutes; Cavour’s has none, so it lands without one, as on a failed recovery |
| total impulse | 0.94 to 1.06 times | its half-width twice the 2.5 to 3.1% spread (1σ) of repeat certifications (the dispersion note §2); drawn evenly, its own spread is 3.5%, wider |
| burn time | 0.90 to 1.10 times | its half-width near the 10.7% spread (1σ) of the one burn-time batch found, of small black-powder motors (§2); drawn evenly, its own spread is 5.8%, narrower |
| zero-lift drag | 0.8 to 1.2 times | its half-width twice OpenRocket’s 10% default; drawn evenly, its spread is 11.5%, narrower than the 16% coast fits suggest (§4) |
| wind | up to 20 mph (8.94 m/s), from any direction | the safety code’s limit |
| rail | 0° to 10° from vertical, toward any direction | inside the code’s 20° |
| site | 0 to 1,500 m (0 to 4,921 ft) above sea level | sea-level fields to the high deserts |
| air | the 1976 standard, −15 to +15 K | a day off standard |
A range’s half-width is its largest departure from 1. Drawn evenly over ±h, a value spreads by h/√3 (1σ), the spread the rows compare with their sources’.
The loggers convert pressure to height by the standard atmosphere, so a day off standard is a real error in their heights. On a cold day a barometer reads high. The readings must carry it.
The truth is the flight’s center of mass, every 0.01 s, and its events: liftoff, rail exit, burnout, apogee, each charge and deployment, and landing. Its heights are above the ground; a reading’s truth is the height above where the center of mass stood at liftoff. An accelerometer would feel the specific force along the rocket’s axis, at the nose tip where HPR Sim records the acceleration. Under a canopy the rocket is taken to hang vertically.
The loggers
A flight draws one of six profiles, each like a family of real loggers, at that maker’s logged rate and step. Its log is tagged with that family’s format, its logger named as synthetic.
| Profile | Rate | Pressure written as | Accelerometer | GNSS |
|---|---|---|---|---|
| PerfectFlite | 20 Hz | height, whole feet | none | none |
| RRC3 | 20 Hz | pressure, 10 Pa steps | none | none |
| Eggtimer | 20 Hz | height, whole feet | none | none |
| AltOS | 100 Hz climbing, 10 Hz after | pressure, 1 Pa steps | high-g | 1, 5 or 10 Hz |
| 500 Hz IMU | 500 Hz | pressure, 2 × 10⁻⁵ atm steps | low-g, ±32 g | none |
| GNSS tracker | 1, 5 or 10 Hz | none | none | yes |
The height a profile writes is its pressure’s height in the 1976 standard atmosphere, less the mean of its samples on the pad. The RRC3 uses the NOAA formula instead, as its maker’s software does (the height formulas note). The two differ by about 0.83 m (2.7 ft) in 2 km (6,562 ft).
Two loggers and stages
Four more sets check two logs on one timeline. None joins the census:
| Set | Flights | What it flies |
|---|---|---|
| Two-logger calibration | 2,000 | drawn as the calibration set is, to fit the offset’s 90% interval |
| Two-logger A | 1,000 | set A’s model |
| Two-logger B | 1,000 | set B’s model |
| Staged | 200 | the design synthetic-two-stage-75mm-54mm, a logger in each stage |
Each flight carries two loggers, drawn independently from the table above, their noise on streams of their own, and each log’s clock moved by up to 300 s either way, as a board’s is by when it was switched on. A flight’s truth says where each clock stood, so an offset can be held to it.
A staged flight’s booster burns out, the stack parts 0.5 s later and the sustainer lights 0.5 s after that. The sustainer comes down under a canopy. The booster tumbles from the split, as HPR Sim flies one: a point mass with its tumble’s drag (staging). Its truth is that descent on the same 0.01 s grid, from the integrator’s dense output, so these flights say how well two stages’ liftoffs line their clocks up, not how well a booster’s fall is modeled.
The noise, term by term
The pressure
The logged pressure is the true pressure plus seven terms, then rounded to the logger’s step. The sections are those of the sensor noise note unless another note is named:
| Term | What it is | Drawn per flight | Source |
|---|---|---|---|
| offset | the sensor’s absolute error, which the pad’s zero takes out of the heights | ±100 Pa for an MS5607 and PerfectFlite’s; none for a Bosch-class part | §2, §6 |
| gain | an error proportional to the change from the pad | ±0.25% for an MS5607, ±0.1% for PerfectFlite, ±0.08% for a Bosch-class part | §1, §2, §6 |
| drift | a slow change over the flight | 1 to 3 Pa over 30 to 300 s, either way | §3 |
| fast correlated noise | the noise measured on real logs’ pads | 0.5 m (1.6 ft) at 50 Hz, correlation 0.5 | §3, §6 |
| slow correlated noise | the noise that averaging over a second keeps | 0.24 to 0.29 m (0.79 to 0.95 ft), time constant 0.65 to 1.26 s | §3 |
| white noise | the datasheet’s | 2.3 Pa (RRC3), 2.4 to 13 Pa (AltOS), 0.2 to 6.6 Pa (Bosch class); none for PerfectFlite | §6 |
| port error | the static port’s error near Mach 1 | the port 1 to 5 calibers behind the nose’s shoulder, assumed | the Mach error note §1–2 |
A charge adds an eighth, the ejection pulse, at each charge’s time.
What each profile’s part gives. An MS5607 zeroed on the pad holds ±1.0 mbar from 0 to 50 °C, stated over 700 to 1,100 mbar (§2). Read as a gain, that is ±0.25% of the change from the pad. That is an inference, as the datasheet doesn’t say how the error grows with the change. PerfectFlite names no part, so its profile takes an MS5607’s offset, which is an assumption. It takes its maker’s stated ±0.1% of the height as a gain (§1). It has no white noise beyond the noise measured on real logs. Eggtimer and Featherweight name no part on most of their boards (§1). So the Eggtimer and 500 Hz IMU profiles take a Bosch BMP3xx or DPS310-class part, an assumption. Its white noise is 0.2 to 6.6 Pa by its setting, and its gain is ±0.08% relative (§2, §6). The offset stays in the logged pressure, but a height zeroed on the pad loses it. What is left after the zero is the gain and the drift.
The fast correlated noise is a first-order autoregressive process, a red noise: each sample keeps part of the one before. On the pads of five Blue Raven logs at 50 Hz the spread is 0.43 to 0.62 m (1.4 to 2.0 ft). The correlation from one sample to the next is 0.40 to 0.54 across six windows of those logs. Those windows are on the pad or at rest (the sensor noise note §3). The spreads are upper bounds that mix in wind and handling. The model takes 0.5 m (1.6 ft) and 0.5 for every barometer, and adds each part’s white noise. It is drawn as an Ornstein-Uhlenbeck process, a red noise in continuous time, so the correlation follows the time between samples, whatever the rate:
With 0.5 at 0.02 s, . A 20 Hz logger’s samples then correlate by 0.177, a 100 Hz logger’s by 0.707 and a 500 Hz logger’s by 0.933. The spread in pascals is the height’s times . At a 500 m (1,640 ft) site in standard air, 0.5 m (1.6 ft) is 5.72 Pa.
The slow correlated noise is a second term of the same kind, but slower. Its spread is 0.24 to 0.29 m (0.79 to 0.95 ft) and its time constant 0.65 to 1.26 s, each drawn per flight. Ten minutes of a BMP085 at rest gave it (Sabatini and Genovese 2013, Tables 1–2; the sensor noise note §3). The fast term loses its correlation within a tenth of a second. So a reading that averages over a second would see it shrink almost away. The slow one keeps most of its spread over that second. One part measured on one bench is taken for every barometer: an assumption.
The port error is the static port’s error where the pressure along the body changes near the speed of sound. It comes from a wind-tunnel test of the static pressure along an ogive-cylinder from Mach 0.7 to 1.2. The test is Czarnecki and Monta’s (NASA TN D-3516, 1966, Fig. 5; the Mach error note §1–2). The port reads off the true pressure. is read from the note’s trace of the report’s figure, to about ±0.01. It is read at the port’s distance behind the shoulder, in calibers, and the flight’s Mach number. Outside the table it is held at its end values. One caliber back at Mach 1, .
The ejection pulse has roughly the shape of the one on the public Pnut log that Debrief ships. It has seven samples 0.05 s apart from the charge. The height reads 8 m (26.2 ft) low at the charge and 16 m (52.5 ft) high 0.1 s after it. From 0.25 s it reads 3 m (9.8 ft) low, then true again. The shape is scaled by 0 to 2 per flight, a range assumed, as one log gives one pulse. It is turned into pressure at the density where the charge fires. No test yet compares it with real logs’ pulses (evidence row G32).
The acceleration
The logged acceleration is the truth’s axial specific force times , plus a per-flight bias of up to 0.05 g and white noise. It is clipped at the part’s range and rounded to its step. No source states a bias left after the pad’s zero. So the 0.05 g is assumed (the sensor noise note, What this suggests; evidence row G32):
| Part | Noise density | Step (mg, g) | Range, g | Scale , % |
|---|---|---|---|---|
| high-g, ADXL375 class | 5 mg/√Hz | 49 mg | ±180 g | ±10% |
| low-g IMU axis | 0.16 to 0.4 mg/√Hz | 64/65,536 g | ±32 g | ±3% |
Each sample’s noise is the density times . That is the noise bandwidth of a single-pole filter at half the rate the logger samples at while climbing. That bandwidth is an inference in the sensor noise note §4. The AltOS profile’s high-g part at 100 Hz has 44.3 mg (0.434 m/s²) per sample. It has the same after apogee too, when it logs at 10 Hz. The part’s filter doesn’t change with what the logger writes. Past 32 g the low-g part clips: the high-range part that takes over on a real IMU isn’t modeled.
The tuning set’s 500 Hz IMU flights, 38 of them, are also logged with the low-g part set to ±8 g. The steps are 16/65,536 g. The BMX160 and the MPU-6000 offer that full scale on the same 16 bits, as their datasheets state (the sensor noise note). The part holds its top value past the range. The noise and the clock are the same as on its own log. Of these 38 flights, 28 have a true top that reaches 8 g and 10 don’t, as the synthetic report counts. So the readings’ rule for a top clipped at its part’s range is held on flights that reach it (Flight-log readings). At ±32 g none does.
The GNSS fix
A hobby GNSS receiver’s navigation filter follows the rocket like a second-order loop. Under a steady acceleration it settles behind by
where is the loop’s natural frequency, drawn from 0.25 to 1.0 rad/s, with damping . No receiver’s loop has been measured against a truth. About 0.5 rad/s is near the 0.47 to 0.69 rad/s of the GNSS note’s simulated filter. That filter fell 103 to 261 m (338 to 856 ft) behind in boosts of 5 to 15 g, an inference (the GNSS note §4). One flyer reported a 440 m (1,444 ft) lag, its acceleration not given. That is larger than any of the simulated lags (§3). Drawn evenly, two in three loops lie above 0.5 rad/s and lag less than 0.5 rad/s would. So the draws err toward a fix more accurate than a real receiver’s. The damping is the usual choice for such a loop, assumed (evidence row G32). At 0.5 rad/s, a steady 50 m/s² would leave the fix 200 m (656 ft) behind. A 2 s boost ends long before the loop settles, so the lag peaks after burnout. Each axis has 3 m (9.8 ft) of white noise, a fixed value, assumed. No fix is written for 0 to 10 s from liftoff and from burnout. Each span is drawn per flight, as the GNSS note suggests. That is an assumption. The fixes written carry no flag that they lag.
The clock
The log starts 2 to 10 s before liftoff and ends 2 to 10 s after landing, each drawn. The AltOS profile changes from 100 Hz to 10 Hz at its first sample after apogee.
A worked example
An AltOS-like logger is launched from a sea-level pad. It flies through Mach 1 at 1,000 m (3,281 ft) above sea level, a geometric height, on a standard day. Its port is one caliber behind the nose’s shoulder.
- The air. The standard atmosphere there has and density 1.112 kg/m³.
- The dynamic pressure at Mach 1 is , which is 62,913 Pa.
- The port error is , here , which is −5,033 Pa: the port reads low.
- The height it writes. 84,843 Pa is 1,473 m (4,833 ft) in the standard atmosphere. So the logger reads 473 m (1,552 ft) too high while the rocket is near Mach 1. Three calibers back the sign flips: reads 1.9 kPa high, and the height low.
- The noise beside it. The fast correlated noise is 0.5 m (1.6 ft) at the pad, 6.01 Pa at sea-level density. The slow noise is 2.9 to 3.5 Pa and the white noise 2.4 to 13 Pa. Near Mach 1 the port’s error is about 840 times the fast correlated noise and 387 to 2,097 times the white. That is why a reading that leans on a barometer through Mach 1 must say so.
Validation and limits
Checked against
Each noise term, on a truth built for it. The tests build a truth that stands still, or climbs at a constant acceleration, with only the term under test switched on. They hold the log to it. They check the offset as the residuals’ mean, the drift as their slope, and the white noise’s spread to within five standard errors. They check the fast and slow correlated noise’s spreads and correlations, and the gain on a 2 km (6,562 ft) climb. They check the port’s at a measured point and the pulse at 0.15 s. They check the accelerometer’s scale, bias, spread (after apogee too) and clip, and the GNSS lag and dropouts. They check the log’s span and rates, and its values lined up with the truth by the drawn pad span. Each drawn noise term is checked again changed, and must then fail. The offset, drift, white noise and gain are tried at half and one and a half times their values. The others are zeroed, halved, doubled or moved (the port to 3 calibers, the GNSS loop to 1 rad/s). The fix rate and the spans are set to other values, which the log must follow. Each part’s stated ranges are pinned to the values on this page, so a changed constant fails too. The fixed 3 m (9.8 ft) GNSS noise is held to its value on each axis. The census is a file in the repository (synthetic-flights.md). It counts each set’s flights by design and logger. It also gives the ranges of eight quantities: apogee, top Mach number and speed, flight time, wind, rail angle, site elevation and the air’s offset.
What the census shows. Every one of the 2,200 draws flew. Apogees above the pad run from 412 to 4,810 m (1,352 to 15,781 ft), and top speeds from Mach 0.269 to under 1.18. Values are kept to three significant figures, the digits every platform shares, each range’s ends rounded outward. Each night CI flies every flight again on macOS, Windows and Linux and holds the census to them.
What it leaves out
- Fast flights. None of the 2,200 reaches Mach 1.18 (the census rounds its greatest up). So from there to the Mach 3.5 HPR Sim is built for (the operating envelope) there is no synthetic flight.
- The bay’s vent lag. A bay’s pressure lags the outside air through its vent holes. In an invented flight, three invented bays vented by the makers’ rules moved the apogee by at most 2.1 cm (0.07 ft). They lagged the height by 0.4 to 135 m (1.3 to 443 ft) through Mach 0.9 to 1.07. That is an inference (the Mach error note §5), and no hobby bay’s lag has been measured.
- A temperature term. Not drawn. Below 4 km (2.5 mi) above the pad it moves the apogee by up to 0.72 m (2.4 ft) on every site and day drawn. The most is at that height above a 1,500 m (4,921 ft) pad on a +15 K day. From a sea-level pad on a standard day it is 0.60 m (2.0 ft) there. Both take a sensor 0.6 K off its pad value at apogee. No altimeter log that peaked that low moved more than 0.56 K. The census reaches 4,810 m (15,781 ft) above the pad. Logs that peaked higher warm by +2.48 K at their 90th percentile. At the census’s top, above a 1,500 m (4,921 ft) pad on a +15 K day, that makes the term about 3.2 m (10.6 ft). The largest logged warming, +6.73 K on a faster and higher flight, would make it about 8.8 m (29 ft). All of these take 8 Pa/K, which is no ceiling. It is the mean slope over 25 K that the MS5607’s error bands allow below 700 hPa, where each of these apogees sits. At higher pressure it is 6 Pa/K, and a shorter span allows a steeper slope (bay temperature §2, §5 and §7, an inference).
- Clock drift. The logger’s clock is taken as exact.
- The logger’s own speed column. Each logger filters its own speed its own way, so the synthetic logs carry none.
- The rocket’s attitude in the accelerometer. Only the axial axis is logged, at the nose tip rather than where the logger sits, and under a canopy the rocket hangs vertically. Each parachute opens at full size after its lag, as the RocketPy examples define them, so a main’s opening is a sharp spike.
- Vibration. The accelerometer’s noise is the same through the boost as on the pad; a motor’s vibration isn’t drawn.
- A GNSS error that wanders. Each fix’s noise is drawn afresh, so an average of fixes is quieter than a real receiver’s, whose error drifts over seconds to minutes.
- A sharp port jump. The port’s error is read linearly between the tunnel’s Mach numbers, 0.1 apart near Mach 1. So its jump is spread over that much speed, and a real port’s may be sharper.
- A part’s stated noise, where it is larger. The noise from the density can understate a part’s own stated figure. The MPU-9250’s 8 mg at 94 Hz is 2.2 times what the density gives (the sensor noise note §4). The low-g profile may be quieter than a real IMU.
Tests and references
Tests
hpr_forensics::synthetic: every draw inside its range and filling it, in every set. Each set is on its own seed. One flight drawn again is the same to the bit, whether flown alone or after another that shares its drag table.hpr_forensics::synthetic::noise: the correlated noise’s spread and correlation at 10, 50 and 100 Hz, and the port table at its measured points. It also checks the pulse’s shape and the GNSS loop’s steady lag.hpr_forensics::synthetic::logger: each drawn pressure, acceleration and GNSS term held, and failing when changed. It also checks the fast noise’s correlation at 100 and 500 Hz and the slow noise’s time constant. It holds the GNSS noise to 3 m (9.8 ft) on each axis. Last, it checks the log’s span, each part’s rate, each profile’s step and channels, and the height formulas.hpr_forensics::synthetic::held: the 500 Hz IMU’s part set to ±8 g, with its range stated to the readings. A true top past it is read as clipped at the range, a floor that holds. A part with no lower setting writes no such log.hpr_forensics::synthetic::truth: set B’s drag and tilted thrust, which keeps its impulse. It also checks that set B’s three changes reach its flights’ inputs while set A’s keep HPR Sim’s.cargo xtask synthetic --check, in CI on every platform each night (ADR-149’s amendment, the time budget for CI), and by hand: the census reproduced. CI’scensusjob flies the sets in two steps,--sets tuning,aand--sets b,calibration. Each compares what its sets make with their sections of the committed report, so every flight is flown and compared on every platform. A test readsci.ymland fails if a set isn’t on exactly one line of a job that runs on all five platforms, or if that job runs on any condition but a full run’s, nightly or started by hand.cargo xtask synthetic --slice, on pull requests on all five platforms and inscripts/gate.sh: every 21st flight of each set (202 of 4,200) flown again, held to the census’s rules for one flight and to thesynthetic-flights.slice.jsonthe whole run writes, by the byte on the Mac’s everyday build that writes it and by the word elsewhere (a flight’s numbers can move between builds). A test changes one flight’s truth, then its log, and checks that its lines change.
References
- K. R. Czarnecki, W. J. Monta, NASA TN D-3516 (1966), as the Mach error note cites it.
- Sabatini and Genovese, Sensors 13(11):15692 (2013), as the sensor noise note cites it.
- NASA/TM-2008-215633, Terrestrial Environment (Climatic) Criteria Guidelines for Use in Aerospace Vehicle Development, §2.2.5.2.
- The National Association of Rocketry, High Power Rocket Safety Code.
- The research notes this page draws on: sensor noise, the Mach error, GNSS in boost, height formulas, smoothing methods, dispersion sigmas.
The smoother
See how FusionSpace HPR estimates a flight’s height and vertical speed from all of a log’s sensors, and how well its 90% intervals hold.
In short
- What it models: a flight’s height and vertical speed at every sample of a
flight log, from its barometer, axial accelerometer and GNSS
receiver together. A Kalman filter runs forward over every sample. A Rauch-Tung-Striebel pass
then runs back, so each moment uses the whole flight. Each estimate comes with a standard error
and a 90% interval. A health card says how each sensor fared. It is in the
Rust library,
hpr_flightdata::smoother.hpr analyzeprints the smoothed apogee and the card, and Python’sFlightLog.smoothed()gives the whole track. - Sources: the textbook filter and pass back, and the project’s notes on sensor noise, the port’s Mach error and GNSS lag (Sources). The rest are HPR Sim’s choices, recorded in ADR-300, the smoother and its check.
- How well it is validated: only on the synthetic flights, whose truth is known. There, at burnout, the top speed, apogee and a drawn moment, 94.4% to 98.1% of set B’s truths lie inside the 90% intervals (How well it holds). Two logger cells fall under 90%: 88.7% on set B and 89.2% on set A, which the check’s rule allows. Sets A and B were run while its rules were set, so they aren’t untouched tests. A real log comes with no truth taken apart from it, so the smoother is unvalidated on real logs (evidence row G33). Tracking from the ground can’t stand in for one: a contest’s optical track gives one height and no speed. Its apogee scatters about 2% (one standard deviation) from a calibrated altimeter at best, and 3% to 5% typically. So it can expose a gross bias but can’t test the 90% intervals (the note on truth flights). A test range’s best tracking is good enough, but no public hobby log was found with a range’s track.
- What it leaves out: the horizontal track and the rocket’s attitude. A log that starts at launch has no pad to zero the barometer on, so the pad is assumed, the card says so, and its accelerometer is set aside (A log written from launch, and evidence row G33). A log too long to hold in memory is withheld. So is a track whose vertical speed passes 11,186 m/s (36,699 ft/s), Earth’s escape speed. That is an estimate that ran away, not a rocket (A track that runs away).
How it works
The filter’s state is the height above the pad and the vertical speed and acceleration. It also holds the sensors’ own errors: the accelerometer’s bias, scale and tilt, the barometer’s slow noise and drift, and the receiver’s offset. A log without an accelerometer, or with a clipped one, runs the same model with nothing measuring the acceleration. Each estimate’s 90% interval is the estimate ± 1.645 standard errors.
Three things a log can’t settle are carried into each interval instead of guessed:
- The day’s air. A barometer reads height through the standard atmosphere. On a day 10 K warmer, every height it gives is about 3.5% short, and nothing else in the log can tell. Only a GNSS receiver’s heights measure it.
- The static port’s error. A port reads the flow as well as the air: its pressure coefficient times the dynamic pressure. The log is smoothed twice, the coefficient a standard deviation apart, and each interval is widened by the difference.
- Charges. Each charge’s pressure pulse would read as a jump in height. The barometer is de-weighted for half a second after each charge the log names. It is also de-weighted around its own apogee in every log.
The barometer is de-weighted from Mach 0.8 too, because near Mach 1 the port’s error can reach hundreds of meters. Any sensor’s sample is rejected when it misses the estimate by more than five of its standard deviations.
A rocket swinging under its canopy can scatter its barometer’s readings by meters, far more than it showed at rest. So past apogee, each barometer sample’s noise also holds the log’s own scatter about a smooth curve through six seconds of it. That scatter is taken as correlated over 2 seconds, so a swing isn’t averaged away. Swings of 3 to 6 m (10 to 20 ft) that last up to a second stay inside their intervals in the tests. A slower one, correlated over 3 seconds, is partly read as motion, and its intervals miss more often than they claim.
A GNSS receiver lags a climb by up to hundreds of meters, all the while flagging its fix good. So its fixes count only once its speed has agreed with the smoother’s for 2 seconds.
How well it holds
The check, run by cargo xtask synthetic, compares each flight’s smoothed height and speed with
the truth. It does so at burnout, the top speed, apogee and one moment drawn at random per
flight. A cell fails if either side’s misses are shown, at 99.9% confidence, to pass 5%, half of
what a 90% interval allows. Each set’s cells and each logger’s must hold, and a log withheld for
any reason but having no barometer fails the check.
The rules were set on the tuning set. But sets A and B were run as each change landed, and some changes were found on them (ADR-300, item 13). On set B, 845 of the 1,000 flights were smoothed; the other 155 logs have no barometer. The share whose truth lay inside the 90% interval was:
| Moment | Height | Speed | Median standard error (height, speed) |
|---|---|---|---|
| Burnout | 96.8% | 96.4% | 59.3 m (195 ft), 11.2 m/s (37 ft/s) |
| Top speed | 97.4% | 94.4% | 62.3 m (204 ft), 11.1 m/s (36 ft/s) |
| Apogee | 97.3% | 96.9% | 85.3 m (280 ft), 1.23 m/s (4.04 ft/s) |
| A drawn moment | 97.3% | 98.1% | 18.5 m (61 ft), 1.02 m/s (3.35 ft/s) |
The intervals are wide on purpose. Two terms are expected to lead the height interval: the day’s air, which a log without a GNSS receiver can’t measure, and the port’s error. The widest are on barometer-only loggers, in the report’s JSON per logger: up to 407 m (1,335 ft) at burnout and 260 m/s (853 ft/s) at a drawn moment.
Across the three sets, each set’s cells run from 94.2% to 99.4%. Per logger, the lowest cells are 88.7% on set B and 89.2% on set A, both the GNSS logger’s apogee height. The rule still allows them: their misses aren’t shown to pass 5% a side.
The check also runs a setting made to fail. Each log with a GNSS track is smoothed again with
its receiver trusted from liftoff, which is wrong on purpose: a receiver lags a climb. hpr analyze can’t be set that way. The check must catch it, and it does. B’s 186 smoothed logs with
a GNSS track were smoothed again that way, the rest left as they were. Six of them ran away and
were withheld (A track that runs away). That leaves 839 of B’s 845
smoothed flights. Of those, 144 apogee truths lay below the interval, and only 82.2% inside it.
Every set and moment is in the report.
A track that runs away
The smoother withholds a track whose vertical speed passes 11,186 m/s (36,699 ft/s) anywhere in the log, up or down. That is Earth’s escape speed at its surface, the 11.186 km/s of NASA’s Earth Fact Sheet. No rocket that comes back flew it, so a track that reads it is an estimate that ran away. The bound catches a runaway. It doesn’t make a track under it right: the intervals and the health card do that work. The decision record has the measurements behind it.
If your log is withheld. hpr analyze prints withheld: on its smoother row and this
reason, with your log’s speed and time in it:
the smoother's vertical speed reads <speed> m/s at <time> s, past Earth's escape speed, 11186 m/s either way: the estimate ran away
That row takes the place of the smoothed apogee and the health card. The
readings above it (liftoff, apogee, top speed, landing) are read from the
log, not from the smoothed track. Go by those. Of the sample logs’ 1,058 records, 3
are withheld so: one altos-csv log and two held-table logs (altos-csv and held-table
are log families in that survey). Why those three run away isn’t traced yet
(an open issue). It doesn’t by
itself mean a sensor is broken. Before the bound, hpr analyze printed those three tracks, so
output saved earlier for such a log shows a runaway track.
How the check’s wrong setting runs away. Each sample passes a gate: one that misses the estimate by more than five of its standard deviations is rejected. A sensor rejected for a whole second is taken back, which the health card counts as a reset. The smoother then treats the estimate, not the sensor, as wrong. It widens the uncertainty of the height, speed and acceleration by the size of the gap, so the estimate jumps to the sensor. That is right when the estimate has drifted and the sensor hasn’t.
It goes wrong when two sensors of the height disagree past their gates and both can be taken back. A take-back reads the gap as motion the filter missed and leaves the speed and acceleration wide open. The other sensor’s samples, fused against that, swing the speed. A second later the next take-back can meet a wider gap, and the gap can grow without limit.
The barometer and the GNSS receiver both measure height. As shipped, the receiver is never taken back. After two rejections in a row it is no longer trusted, and it must agree with the smoother for 2 s again. The barometer can be taken back, and so can the accelerometer before apogee, but those two don’t measure the same thing. Trusted from liftoff, the receiver is taken back as the barometer is, and the two can feed each other.
An invented flight shows it (the smoother’s test
a_track_past_escape_speed_is_withheld_as_diverged). The rocket’s top speed is 98.1 m/s
(322 ft/s). Its barometer logs at 20 Hz. Its receiver logs at 5 Hz and, from apogee on, its
altitude error grows by 20 m (66 ft) every second, as no real receiver’s does. Trusted from
liftoff, the track is withheld as diverged. Trusted by agreement, as shipped, the same log
smooths. Its top speed reads within 2 m/s (6.6 ft/s) of the true 98.1 m/s (322 ft/s). At 30 s,
on the way down, the true height and speed lie inside their 90% intervals.
On the synthetic flights, the wrong setting runs away on 11 of the 185 logs set A smooths again. It does so on 6 of set B’s 186 and on none of the tuning set’s 33 (the report). Those logs leave the wrong setting’s cells, and it still fails on the rest, as it must. As shipped, the check fails if a single synthetic log with a barometer is withheld, for this reason or another, and none is.
A log written from launch
Many loggers write little before they detect the launch. Of the 1,058 records of the sample logs, 546 are smoothed: 372 on an assumed pad and 174 on their own. A log with no zero to stand on, such as a track of pressures alone with no pad, gives no liftoff and is still withheld. With fewer than five barometer samples on the pad, the smoother assumes it:
- The height stands on the same zero as the readings: the logger’s own, or whatever pad samples the log does hold. A zero that is the pad’s only by a column’s name may be off by up to 19.9 m (65 ft) either way. The height’s standard error carries it as an even spread over that range, 11.5 m (38 ft).
- The barometer’s noise comes from the flight’s own scatter past apogee.
- Nothing is held still. The height, speed and acceleration start with wide priors, HPR Sim’s choices: 100 m (328 ft), 100 m/s (328 ft/s) and about 30 g. Priors that wide would take a bad sample as the truth. So for the first second, or the first ten samples if that is longer, each sample fused is the median of the five about it, and the first two aren’t weighed. The readings set aside one or two bad samples that stand high, so they don’t move the readings’ zero, except for the cases the climb names, on the slowest logs among them.
- The accelerometer is set aside if it has too little of the pad to take its level from.
To test this, each synthetic flight’s log is cut at liftoff and smoothed again. That keeps the logger’s true zero, so the test holds no error in that zero. On the report’s sets A and B, every cell holds, overall and per logger (the command fails otherwise): 95.6% to 98.7% of truths lie inside the 90% intervals overall. Real logs have no such truth (evidence row G33). Their smoothed apogee falls outside the reading’s bound on 11 of the 372 on an assumed pad and 19 of the 174 on their own. A log’s own pad doesn’t prevent it (an open issue). The card then says so, and the reading is the one to go by.
The health card
A barometer-only log from the tuning set, as the report prints it:
barometer: 5632 samples, 5632 fused, 0 rejected, 0 not weighed, 0 resets; 100.0% inside the gate; mean NIS 0.678; largest test ratio 0.632 at 141 s, Mach 0.01
barometer de-weighted: charge 28.1–30.1 s
pass back: every step smoothed
Each sample is fused into the estimate, rejected at the gate, or not weighed. A GNSS fix isn’t weighed before it is trusted, nor an accelerometer sample that is clipped or past apogee. A reset is a sensor taken back after a second of rejections. The test ratio is a sample’s squared miss over five standard deviations squared. Above 1, the sample is rejected. The mean NIS (normalized innovation squared) is the squared miss over its variance. It is near 1 when a sensor’s noise is what the smoother takes it to be. Below 1, the smoother takes the sensor as noisier than it was, which isn’t a fault. The last line says whether the pass back solved every step.
Three more lines appear only when they apply: pad assumed, accelerometer set aside, and
smoothed apogee ... past the reading's bound: go by the reading.
On a log that ends on the climb, the smoothed apogee is a floor with no interval, as the reading’s is: the track’s highest point is only where the log stopped, not the rocket’s peak. That holds where the reading’s apogee is withheld too.
Sources
The filter and the pass back are the textbook ones (Särkkä and Svensson, Bayesian Filtering and Smoothing, 2nd edition, 2023). The sensors’ errors come from the sensor noise note. The port’s error near Mach 1 comes from the Mach error note, and the GNSS receiver’s lag from the GNSS note. The rest are HPR Sim’s choices, recorded in ADR-300, the smoother and its check.
The least-squares fit
See how the library fits a flight’s log to a simulation for drag, impulse, wind and mass, and where its Bayesian option fails its tests.
In short
- What it models: the simulator’s inputs are changed until the simulated flight passes through the log’s samples up to apogee, read the way the log’s sensor reads it. It fits a scale on the drag and one on the impulse. It fits a constant wind in two components, and the mass within what the weighing says. Each comes back with a 90% interval.
- Sources: Levenberg-Marquardt as in Numerical Recipes; the widening for correlated residuals from Wilks; the wind’s growth with height from IEC 61400-1 (Sources). The test of an interval is ADR-257’s.
- How well it is validated: use the least-squares intervals; the Bayesian option’s don’t pass yet. Both are tested only on synthetic flights, and only as a whole. By least squares, each parameter’s interval passes on two sets of test flights (the sets), set B’s drag at the edge of its test. Set A flies the simulator’s own model; set B flies a deliberately different one. A truth is the value a test flight was flown with. On set B it’s the fit to the same flight with no noise, for all but the mass. The wind passes only on logs with a track, the log’s latitude and longitude. Choices in the model were made after seeing those two sets; the intervals’ sizes come from a third. An interval holds 90% over a set, not on each design or flight (How well it holds). No real flight has checked its intervals (evidence row G38). On a real flight, the model’s own errors go into the scales with nothing to say so. The Bayesian option draws the unknowns’ possible values at random rather than reading the curvature at the answer. Its intervals pass 8 of their 10 tests, 5 parameters on each of 2 sets. The wind passes on both sets, on a model of the receiver tuned on those same flights. Set B’s drag passes, but so does a copy widened on purpose. A tail passes with at most 74 of 1,000 truths. Set A’s drag reads low, 85 above its intervals, and set B’s impulse high, 84 below. Each makes the rocket look better than it flew. Until all pass, use the least-squares intervals (The Bayesian option).
- What it leaves out: anything past apogee, and the accelerometer. A log whose only height is a
GNSS receiver’s isn’t fitted, since the log reader takes no apogee from it; that’s every log with
nothing to fit among the sets’ counted draws, about one in six (when). Its wind is
constant with height; on a log of height alone, a wind that grows with height only widens the intervals. It’s
told the design, rail, site and the day’s air, and takes them as right. It’s in the library only,
with no
hprcommand yet. Its prediction from the boost has been compared with a logged apogee on 2 public flights, both cut after their burn, on logs that stay under 227.7 m/s (747 ft/s): an anecdote, not a measure.
How it works
The fit reads the log’s heights, as a median every 0.25 s, from a second before liftoff to apogee. A track is the log’s latitude and longitude, from a GNSS receiver such as GPS. Where the log holds one, the fit reads the drift as well, which is what speaks to the wind. It flies the simulation about 70 times a fit, which takes about a second of one processor core. It steps the inputs by the Levenberg-Marquardt rule, a damped Gauss-Newton search, until the sum stops falling. It has three parts, the heights’, the track’s and the stated ranges’:
Here is a logged height and the simulated height, read as the sensor reads it. and are the same for the track, and is an input. The last part holds each input to what’s stated of it, as a range: is the range’s middle, and sets its width. That’s why a log with no word on the wind gives back the wind’s stated range. and are the root-mean-square of the fit’s own residuals. They’re at least 3 m (10 ft) on height, a barometer’s noise (log readings). On the track they’re at least 10 m (33 ft), a judgment for a receiver’s errors, which run on from fix to fix (ADR-316).
On the synthetic flights, the stated ranges are those the flights draw from (what a flight draws):
| Input | Stated range | Its 90% width (factor; the wind’s in m/s) |
|---|---|---|
| drag scale (times the simulator’s drag) | 0.8 to 1.2 | 0.36 |
| impulse scale (times the motor’s rated impulse) | 0.94 to 1.06 | 0.108 |
| mass (times the weighed mass) | 0.98 to 1.02 | 0.036 |
| wind, each of east and north | a speed up to 8.94 m/s (29.3 ft/s), any way | 12.7 (41.7 ft/s) |
A sensor’s errors would otherwise land in the drag, so the fit also solves for them. On every log that’s the clock offset, the height offset and a height that drifts over the flight. On a barometer it’s also the reading’s gain, a scale on the heights it reads. And it’s the port’s pressure coefficient: how much the airflow past the vent lowers the pressure it reads. A barometer’s bins at or past Mach 0.8 are left out, where the port’s error grows past the range the fit holds. The cut is taken again from the flight each pass finds. The burn time also has a scale, not reported, since a motor’s impulse and its burn trade against each other. A wind of either sign lowers the top. So a log of height alone is flown in a wind of the stated range’s root-mean-square speed, 5.16 m/s (16.9 ft/s).
The parameters’ standard errors come from the fit’s curvature, taken from the product of its Jacobian with itself as Gauss-Newton does (standard error). Two things widen them:
- Residuals that run on. A misfit is correlated from bin to bin, so the bins tell less than as many independent ones. The heights’ and the track’s noise variances are each widened by , where is the residuals’ correlation from one bin to the next, capped at 0.9. A residual with triples it. It’s an approximation: Wilks gives the factor for the variance of a mean, and the cap is a judgment. The calibrated shares take up what it misses.
- A wind heights can’t tell. On a log of height alone the wind is unknown, and its loss grows as its speed squared. The fit moves its answer, to first order, to a calm and to a strong wind: the stated wind’s speed plus half its 90% width. On the synthetic flights that’s 5.16 m/s (16.9 ft/s) plus 6.35 m/s (20.8 ft/s), 11.5 m/s (37.7 ft/s) at 18.3 m (60 ft) above the pad, past the 8.94 m/s (29.3 ft/s) they draw. It’s grown with height as . With the larger of the two moves, joins the variance, as a uniform spread over would.
Each 90% interval is then a standard error times two factors, its low and high shares. They’re found on the calibration set, kept apart from the test flights. They’re the 5th and 95th percentiles there of each fit’s error over its standard error. Logs of height alone have one pair of shares, on the calibration set’s height-alone logs with something to fit. Logs with a track have another, on 1,000 flights of its logger with a barometer and receiver.
Each fit also says whether it stopped at the bottom of within 60 steps a pass.
When a log has nothing to fit
A log with nothing to fit gives back its stated range and says so. That’s any of these:
- the log has no height channel, or the log reader finds no apogee or pad height in it;
- its climb, from liftoff (or its first sample) to apogee, isn’t positive or would run past 1,000 s;
- its climb fills too few 0.25 s bins, as many as the fit’s unknowns or fewer;
- a barometer has too few bins below Mach 0.8;
- the fit’s heights stand far from the log: an RMS residual over 0.1 of the spread of the heights it read;
- a simulation can’t fly, or the curvature can’t be inverted.
On the synthetic flights, every log with nothing to fit has only a GNSS receiver’s height. That’s 216 of set A’s first 1,216, and 193 of set B’s first 1,193. No other cause in the list removed a flight from either set (the report).
A worked example
Flight 140 of set A flies the Calisto design (one of the
example rockets) in its getting-started variant with the motor at
−1.255 m (−4.12 ft), with a logger that holds a track. The report keeps only counts, so a test,
the_pages_worked_example_is_a_real_flights, fits this flight again and checks these rows.
Its heights fit to 0.98 m (3.2 ft), in 84 simulated flights. The table is the least-squares fit’s;
21 of those flights are the Bayesian option’s, finding where to start its draws. A factor is times the simulator’s
value; the mass’s, times the weighed mass:
| Parameter | Fitted (factor) | 90% interval (factor) | Truth (factor) |
|---|---|---|---|
| drag scale | 0.903 | 0.858 to 0.931 | 0.897 |
| impulse scale | 1.011 | 0.991 to 1.028 | 1.019 |
| mass on the weighed mass | 1.000 | 0.982 to 1.017 | 1.013 |
| Parameter | Fitted (m/s) | 90% interval (m/s) | Truth (m/s) |
|---|---|---|---|
| wind toward the east, m/s | 4.45 | 4.24 to 4.67 | 4.59 |
| wind toward the north, m/s | −4.18 | −4.38 to −3.97 | −4.31 |
So this flight says its drag was about 10% under what the simulator took, and that the motor gave about its rated impulse. It says the wind blew at about 4.5 m/s (14.8 ft/s) toward the east and 4.2 m/s (13.8 ft/s) toward the south. The interval on the mass is nearly its stated ±2%: this flight doesn’t weigh the rocket any better than a scale does.
How well it holds
ADR-257 sets the test. Set B’s drag curve, thrust and wind are shaped otherwise, so it has no flown drag or impulse scale or wind. Their truth is the same fit run on the flight’s noise-free samples; only the mass keeps its flown value. On each set, the truths below an interval, inside it and above it are counted. Each count must fit a 99.9% Clopper-Pearson band (an exact binomial interval) around 5%, 90% and 5%. An interval narrowed to 0.8, widened to 1.25, or shifted down one standard error must fail it. The report holds every count and each design’s (how CI checks it).
Each set counts its first 1,000 logs with something to fit. Of set A’s first 1,216 flights, 216 had nothing to fit; of set B’s first 1,193, 193. Each has only a GNSS receiver’s height. A wind’s counts are on 1,500 flights of the logger with a barometer and a GNSS receiver, some past those. Three of them on each set are left out: nothing to fit, or no track read.
The counts are flights:
| Parameter | Set A below, inside, above (no unit) | Set B below, inside, above (no unit) |
|---|---|---|
| drag scale | 34, 903, 63 | 71, 900, 29 |
| impulse scale | 34, 910, 56 | 54, 909, 37 |
| wind toward the east, m/s | 90, 1,346, 61 | 76, 1,352, 69 |
| wind toward the north, m/s | 66, 1,366, 65 | 73, 1,360, 64 |
| mass on the weighed mass | 40, 911, 49 | 41, 900, 59 |
A log tells of a parameter, the report’s “identified”, when the median interval on set A is at most half the stated range’s 90% width:
| Parameter | Median width (factor) | Stated width (factor) |
|---|---|---|
| drag scale | 0.115 | 0.36 |
| impulse scale | 0.04 | 0.108 |
| mass on the weighed mass | 0.035 | 0.036 |
So it tells of the drag and impulse, and not of the mass. On logs with a track, a wind’s median width is 0.348 m/s (1.14 ft/s) east and 0.372 m/s (1.22 ft/s) north, of 12.7 m/s (41.7 ft/s) stated.
On pure noise nothing is told (the report’s noise table). The log reader turns noise of ±5 m (16 ft) and ±1,000 m (3,281 ft) away. Noise is also handed straight to the fit. On height alone it’s ±5 m (16 ft), ±50 m (164 ft) or ±1,000 m (3,281 ft). With a track of ±5 m (16 ft), it’s ±5 m (16 ft) or ±1,000 m (3,281 ft). It says nothing in all 200 flights of each. The fit’s residual is at least 0.957 of the heights’ spread, against 0.1 allowed.
Those counts have limits:
- Sets A and B were seen. The barometer’s unknowns, the track’s floor, the split of shares by track and set B’s truth were chosen after reading their counts. So were which logs are counted and which hold a wind, the wind’s flight count, the misfit’s cut of 0.1, and both widenings. Only the shares themselves come from flights kept apart.
- Set B’s drag passes at the edge: 29 above is the fewest that pass at 1,000. At 71 below, 4 more would fail it too. Its fit runs high by 0.005 on average.
- Coverage holds over a set, not on each design. On set B, the Prometheus design’s drag interval holds 68 of its 96 truths, and its wind toward the north 127 of 161.
- Coverage holds over a set, not on each flight. A flight whose heights fit to 1 m (3.3 ft) or worse misses more often. Set B’s drag interval holds 370 of 450 such flights, and 530 of 550 that fit better (the issue that tracks it: #1108).
- Some fits stop short of the bottom of . Among the flights counted and the wind’s, 3 on set A and 8 on set B did, counting set B’s truths’ own fits.
- A wind on a log of height alone isn’t counted and shouldn’t be read. Height alone can’t tell a steady wind from one that changes with height.
The Bayesian option
hpr_forensics::fit::bayesian runs the least-squares fit, then draws the posterior of the same
unknowns around its answer. ADR-317 chose importance sampling; ADR-320 draws
the wind first, then the rest. Its 90% intervals don’t pass
their test yet: 8 of the 10 tests pass, 5 parameters on each of 2 sets. One of those 8, set B’s
drag, passes with a probe that should fail passing too. Set A’s drag and set B’s
impulse miss too many truths on one side, so there they’re too narrow or off center. Until they
pass, read the least-squares intervals. Like the fit, it’s in the library only, and no real flight has checked
it.
The posterior is what the fit’s unknowns could be, given the log and the stated ranges. The least-squares fit reads its uncertainty off the curvature at its answer, as if the posterior were a bell curve. It then multiplies that standard error by two shares, factors fitted on the calibration set so that its intervals hold (How it works). The Bayesian option uses none. The Bayesian option draws points around the answer at random and flies each one. It weighs each point by the posterior’s value there divided by how likely the draw was to land there. So the points it lands on often don’t count extra: that’s importance sampling. Each parameter’s 90% interval is the weighted points’ 5% and 95% points, as they come, with no shares. So a posterior that bends or leans one way shows as it is.
How it draws:
-
The wind first. On a log of height alone the heights can’t tell the wind. The drag, the impulse and the clock offset follow the wind along a curve. So each draw takes the wind first, then the other unknowns around where one step of the least-squares fit’s search puts them in that wind. That step is a flight, so each draw flies twice.
-
A pilot widens the draws. 100 pilot draws measure how far the posterior reaches. Where it reaches past the bell curve, the next 400 draws are spread wider, up to twice as wide, and never narrower (Oh and Berger). Only those 400 are read.
-
The sensor’s linear unknowns are worked out exactly. The height offset, the drift, and a barometer’s gain and port coefficient each enter the heights linearly. So their part of the posterior has a closed form. Seven unknowns are drawn, not eleven; eight with the shear, below.
-
On height alone, the wind’s shear is drawn too. How fast the wind grows with height is an unknown there. It’s an exponent stated anywhere from 0, a constant wind, to 0.2, IEC 61400-1’s normal profile. The least-squares fit carries the same doubt in its errors instead.
-
On a track, the receiver’s filter, noise and pad are unknowns too (ADR-321). A GNSS receiver smooths its raw fixes with a filter. The filter lags behind a hard boost and catches up after burnout (GNSS in the boost). The posterior models it as a standard two-pole loop of damping , the usual choice for such a loop. The loop’s speed is its natural frequency: the lower it is, the more the filter lags. Under a steady acceleration the lag settles at . A 10 g boost leaves a 5 rad/s filter 3.9 m (13 ft) behind. A 1 rad/s one would trail by 98 m (322 ft), had the boost lasted long enough.
- The frequency is anywhere from 0.2 to 5 rad/s, evenly in its logarithm. The synthetic receivers’ run from 0.25 to 1 rad/s. The research note’s simulation of a boost used 0.47 to 0.69 rad/s. The loop speeds of the u-blox, Quectel and SkyTraq parts it read are unpublished, and no consumer receiver’s filter lag has been measured against a truth in a real boost.
- The track’s noise runs on from one bin to the next by a correlation anywhere from 0 to 0.99. That’s a first-order autoregression; its exact likelihood is J. D. Hamilton’s (Time Series Analysis, 1994, §5.2). Its size takes Jeffreys’ prior and is integrated out in closed form (G. E. P. Box and G. C. Tiao, Bayesian Inference in Statistical Analysis, 1973, §2.4).
- The pad’s position is an offset of its own on each axis, under a flat prior, also integrated out in closed form.
None of these is fitted, and nothing more is flown for them. Only the search for where the draws start flies more, about 21 flights a fit. If the fit is given a noise level rather than taking it from the log, the track is read the old way, as the least-squares fit states it.
This model’s limits: the synthetic receivers are filters of this same shape, inside the stated range. So the wind’s pass below doesn’t test the shape. The noise model, the filter, the pad and where the draws start were chosen after reading counts on the first 300 tracked flights of each set. All of set B’s and 299 of set A’s are among the 1,497 counted. A receiver of another shape is outside this model. So is one that also measures its speed from the satellites’ Doppler shift and lags under 1 m (3.3 ft). No real flight has checked it.
A fit with something to fit flies about 1,000 times, against about 70 for least squares on set A. On a log with a track, the search for the posterior’s peak adds about 21. In one run on a 10-core Mac, the whole report took 1 hour 56 minutes, against about 16 minutes by least squares alone. So each pull request checks every 21st fit, its posterior with it, and CI fits the whole each night (In CI).
How well the Bayesian option holds
It’s held to the same test as the least-squares fit, on the same flights (How well it holds). The counts are flights:
| Parameter | Set A below, inside, above (no unit) | Set B below, inside, above (no unit) |
|---|---|---|
| drag scale | 30, 885, 85: fails | 74, 872, 54 |
| impulse scale | 72, 875, 53 | 84, 883, 33: fails |
| wind toward the east, m/s | 57, 1,381, 59 | 58, 1,353, 86 |
| wind toward the north, m/s | 56, 1,382, 59 | 70, 1,348, 79 |
| mass on the weighed mass | 56, 882, 62 | 63, 869, 68 |
On the 1,000 flights of drag, impulse and mass, a tail passes with 29 to 74 truths. On the wind’s 1,497, a tail passes with 49 to 104, and the inside with 1,308 to 1,384. What holds and what fails, as far as it’s known:
- The wind passes on both sets since the track is read as a receiver reports it (ADR-321). Before, the posterior took the track’s noise as the least-squares fit states it. Then from 1.06% to 2.41% of truths fell in each tail, where 5% belong. Its median width on set A is now 0.36 m/s (1.18 ft/s) east, against least squares’ 0.348 m/s (1.14 ft/s). Set B’s wind leans: 86 and 79 of its truths fall above, near the 104 that pass. Its mean error is −0.0362 m/s (−0.12 ft/s) east. Set B’s wind grows with height, and on a track the posterior’s wind doesn’t, which may be why; that isn’t measured. Set A’s wind is close to too wide: 1,381 and 1,382 of 1,497 truths fall inside, and 1,384 is the most that pass.
- The wind’s pass leans on thin posteriors. On the committed slice, every 21st fit, 294 wind intervals are counted. The 218 from posteriors of 100 or more effective draws miss 14 truths, 6.4%, where 10% belong. The 76 under 100 miss 11, 14.5%. So the well-drawn intervals may still be too wide, and the thin ones, too narrow, may bring the tails up to 5%. The report doesn’t split its counts this way yet.
- Set A’s drag sits low and set B’s impulse high. 85 of set A’s drag truths fall above, and 84 of set B’s impulse truths below. 72 of set A’s 85 above are on logs of height alone, 776 of its 1,000 flights, as before the track was read anew. Height-alone logs are the only ones where the shear is drawn, though set A’s wind doesn’t shear. That points at the shear’s stated range, but it isn’t measured yet, and set B’s impulse leans the other way. Set A’s drag is M7.3c6; set B’s impulse and the rest are M7.3c7.
- Set A’s impulse passes near its edge. 72 of its truths fall below, 2 short of 74, the most that pass. That’s the same side as set B’s: it too reads high, which flatters the motor.
- Set B’s drag passes, but so does its widened probe. The test can’t tell its intervals from ones widened to 1.25 times, so they may be wider than they need be.
Drag and impulse are identified on set A, at median widths of 0.0919 and 0.0391 (least squares: 0.115 and 0.04), of 0.36 and 0.108 stated. The mass isn’t, at 0.034 of 0.036. On pure noise nothing is identified by either method. But the reader or the fit turns away every noise log before a posterior is drawn, so that says nothing of the sampler itself.
The draws are counted too. A posterior’s effective draws are how many equally weighted draws its weighted ones are worth (Kish): 400 draws with one heavy weight are worth about 1. Under 100, a result is flagged as too few to read, but its interval still counts in the table above: so few draws can leave an interval too narrow or off center, so take it as rough. All 10 tests, the 8 that pass and the 2 that fail, include those posteriors. On the wind, the slice suggests they cause more than their share of misses (above). Of the flights counted, 2,276 on set A had a posterior, 559 of them with fewer than 100 effective draws; across all 2,276, the fewest was 1 and the median 153. On set B, 712 of 2,296 had fewer than 100; the fewest was 1 and the median 138. That’s about a quarter on set A and nearly a third on set B, the loss on logs with a track: before the track was read anew, 319 and 392 fell short. A draw fails when it can’t be weighed, as when its flight can’t fly. That’s 129 of 1,138,000 on set A, and 152 of 1,148,000 on set B. Every flight counted with something to fit has a posterior. M7.3c4 is to make the counts pass.
The sampler’s tests
The sampler, hpr_forensics::posterior, is also tested on made-up distributions whose answer is
known. In one, the unknowns are and a noise term, each a standard normal, and is
plus the noise. ’s standard deviation is 1.22. A bell curve at the peak would put ’s median at
0 and its 90% interval at ±1.645, a standard normal’s 5% and 95% points. With 160,000 draws, the
sampler gives a median of 0.43 and an interval of −1.35 to 2.57.
The tests hold each of those three within 0.08 of the true distribution’s points, worked out by
Simpson’s rule: about a fifteenth of ’s standard deviation. Drawn in two blocks, first, they
hold within 0.08, or 0.15 with the second block centered poorly. Other tests hold a correlated bell
curve within 0.06 standard deviations, show the sampler going wrong when the draw’s own
likelihood is left out of the weights, and check that a pilot widens and never narrows. On the
fit, a straight line’s drag, impulse and two winds come within a tenth of a standard error of their
closed forms. A result under 100 effective draws is flagged as too few to read. Run cargo test -p fusionspace-hpr-forensics posterior and
cargo test -p fusionspace-hpr-forensics fit::tests.
Apogee from the boost
The library predicts a flight’s apogee from its climb and the start of its coast: a log cut after
burnout, once the climb speed has kept falling for 0.75 s (hpr_forensics::boost). That is 1.08 s to 2.30 s after burnout on the synthetic
flights below, and 1.3 s (Bella Lui) and 3.5 s (NDRT 2020) after the burn on the two public ones.
It is run on 7 of the 12 public flights, those compared along their climb.
It predicts 2 of the 7, Bella Lui and NDRT 2020, both cut after the motor’s burn.
That is too few to say at 95% whether it beats the forward simulation
(the report).
The other 5 reach the speed limit described below before a cut.
The private collection’s manifest keeps 72 flights in its apogee errors. Of them, 64 have a barometer’s log
the analyzer reads an apogee from (the count).
26 are cut, 36 refused at the speed limit and 2 as sampled under 8 Hz.
Of those 26, the 20 whose motor’s burn and log’s liftoff are known are each cut after its thrust curve’s burn. For the other 6 it isn’t known.
Of the 26, 21 are predicted. HPR Sim’s forward simulation refuses the design of 3, and 1 has no weather file for its day. There is nothing to fit or compare for those.
One more has too little up to its cut to fit. The flights are split into two halves by a hash of each flight’s id
(ADR-322, held-out flights).
A third is held out in expectation and the rest are the calibration half; neither is blind, as the fixture report’s forward errors on its 60 flights were published before the split.
On the 12 in the calibration half the prediction’s mean absolute apogee error is 3.17%, against the forward simulation’s
9.37% on the same flights. On the 9 held out it is 3.60%, against 16.75%. The difference is each flight’s absolute
error from the prediction less the forward simulation’s, averaged, in percentage points. Each half’s paired bootstrap
95% interval on it lies below zero: −10.14 to −2.81 and −18.77 to −7.93 points. The numbers are in
the report, and the
choices behind them in ADR-329.
Both methods fly nothing deployed, and 10 of the 21 flights deployed something before apogee. Without them (8 and 3
flights) the difference is −7.1 and −7.3 points. Three flights are too few to resample, and their sign-flip interval
is unbounded. The fitted impulse scale averages 0.958 in the calibration half: the thrust curve’s impulse times 0.958. That
is a fit’s factor, not a measured impulse. It may take up some of what the model gets wrong in the boost, as the other
scales may.
The same report splits each flight’s forward error at the cut. The numbers below are from it. The prediction’s error is the share made after the cut. The forward error less the prediction’s is the share made up to it. There the motor’s thrust, the rocket’s mass and the boost’s own drag set the climb. On the calibration half that share averages +8.94 percentage points of the logged apogee: the forward simulation’s climb up to the cut put its apogee that much too high. It is the larger share on 11 of the 12 flights. On the held-out half it averages +14.39 points and is the larger share on all 9. Without the flights that deployed something before apogee it is +10.48 and +11.93 points. The prediction’s own mean error is near zero, −0.05% and +1.34%, so the share up to the cut is nearly the whole forward error. This is a split of two simulations’ errors, not a measurement of the motor. The fit also moves the drag, the mass and the wind within what it was told, and those carry into the coast.
Each fit is told the motor delivers its rated impulse to a standard deviation of 0.033, and that pulls its impulse scale toward 1. So each calibration log is fitted again with that range made 100 times wider, and the log alone speaks. The 12 impulse scales then average 0.936, with a standard error of 0.014 on that mean, and all 12 are below 1. That is 12 flights of one half of one collection: it says what these logs show, not what motors deliver. A barometer’s boost can’t tell a motor that delivered less from a rocket built heavier than its files. That scale carries both, and whatever the model gets wrong in the boost.
One of the 12 flights is flagged: its log and its files disagree by more than the limit below. The cause could be the files, the motor or the model of the boost. The limit is 13.1%. Past that, NAR, one of the bodies that certify motors, tests a motor again as a new type. NAR’s rule is for a test firing against the certified mean. Using it for a flown motor against its rated impulse is this project’s inference, and the report gives the source. The scale’s distance from 1, less two of its own standard errors, must be more than the limit. A flagged flight stays in every number on this page. ADR-346, the rule before the fit, fixes how a correction is fitted on the calibration half. It also fixes how the correction is judged, on the held-out half and the public flights. It was written after a look at the calibration half’s fits and before any correction was fitted or flown.
The correction was fitted and judged, and it failed. It is two scales, fitted on the calibration half: one on every motor’s impulse, one on the drag. The drag scale comes from the coasts. For each flight with nothing deployed before apogee, a bisection finds the drag at which the boost, refitted with the drag held there, flies on to the logged apogee. The scale is those values’ mean, and its 95% interval comes from Student’s t. The impulse scale comes from the boosts, refitted at that drag. It is their weighted mean, and its interval comes from their weighted spread (Merkatas and others, Metrologia, 2019, §3.1). A scale counts only if its interval excludes 1, and it is rounded to two decimals.
Without the flagged flight, the drag’s interval holds 1, so the drag stays as the model has it. The impulse scale is 0.94: the boosts, on the files’ masses, climb as if every motor gave 94% of its rated impulse. That correction takes the held-out half’s mean absolute error from 16.34% to 10.89%, and its mean error from +13.56% to +6.04%. On the 12 public flights it takes the mean absolute error from 8.88% to 11.91%, and the mean error from −4.64% to −11.76%. These are the report’s figures on the simulator as it is now: the report flies the correction again whenever the model changes, and the verdict’s decision record keeps those of the day it was judged. The rule said the public flights must get no worse, so the verdict is a fail and nothing ships. The fit over every calibration flight fails the same way. ADR-348 records it. No correction ships, so the simulator’s flight results are unchanged. The collection reads high and the public flights read low, and one scale didn’t serve both. The 12 public flights are few. For the fit without the flagged flight, the bootstrap interval of their error’s growth, −0.43 to 6.22 points, holds 0, so the harm is not shown with confidence; for the fit over every calibration flight it is 0.40 to 7.45 points and excludes 0, though the exact sign-flip interval, −0.15 to 8.39 points, just holds it. Either way they give no support to one bias shared by both sets of flights. It doesn’t say where the collection’s high reading comes from. The report keeps the measurement for the work on causes. Some of its numbers are held back: the terms the owners shared these flights under allow only aggregates, figures over several flights, and two figures over sets that differ by one or two flights would give those flights’ own values by subtraction.
The scoreboard lists the
calibration half’s 3.17% as accuracy.from-boost, with which flights it counts
(ADR-330, the row).
The cut. The library follows the climb speed: a straight line fitted to each half second of heights. One reading far from the rest is left out, as the analyzer’s spike rule does. The cut needs the speed to stay 10% below its peak, and at least 10 m/s (32.8 ft/s) below it, for 0.75 s. It comes at the first sample where that holds and the speed is the lowest of those 0.75 s. It also never comes unless the fitted height stands more than 10 m (32.8 ft) above the pad. The pad is the fitted height where the line last stood still: where that half second’s fitted speed was under 5 m/s (16.4 ft/s), up or down. Before that, it is the first window that gives a line, five samples or more. Three bad readings in a row on the pad can lift the fit past 10 m (32.8 ft) for one sample. The fitted speed then falls back and stays down, as it does after burnout, so this height rule stops a cut there. They can also read a speed faster than the flight’s own top. Once they leave the window the line stands still again. The pad is read afresh there, and the top speed and climb read before it are dropped (#1362). A step up on the pad that stays settles the same way, at its new height. Bad readings close enough to ignition leave no still window between them and the climb. They can then still be the top speed and cut the log early (#1441); a test pins that gap as it stands. On the test’s flights that starts 0.2 s before ignition, and on one of them the cut then comes before burnout. How far out it starts on other flights isn’t bounded. A fast climb doesn’t stand still before its cut. A reading that dips in the boost can bring the speed under 5 m/s (16.4 ft/s), and the pad is then read again there; the dip test below still finds every cut after burnout. Two figures back the 5 m/s (16.4 ft/s), each measured once on sets A and B’s first 200 synthetic flights and not committed. No speed from liftoff to the cut read under 17.6 m/s (57.7 ft/s), and 98.8% and 98.4% of the pad’s windows read still. A climb whose top speed is under about 22 m/s (72 ft/s) reaches 5 m/s (16.4 ft/s) before its cut. That is 5 m/s (16.4 ft/s), plus the 10 m/s (32.8 ft/s) fall, plus 0.75 s of gravity; drag raises it a little. Such a slow climb is now refused as never lifting off; the walk before this rule cut some (measured once, not committed). A test refuses a climb whose top is 18 m/s (59 ft/s) and cuts one at 30 m/s (98 ft/s). After burnout gravity alone takes 9.8 m/s (32.2 ft/s) off the speed every second, drag more, so the speed keeps falling. A barometer’s reading can dip during the boost and catch up (#1307). In the burns of the seven public flights’ logs compared first, the speed fell that far for up to 0.48 s, then recovered (measured once). The deepest such fall was 63.2 m/s (207 ft/s), a one-off measurement not committed. The 0.75 s passes such a dip. The catch-up can read above the true speed. On 778 of the 1,793 dipped logs below a fall lasted over 0.5 s, likely the fall back from that overshoot (not traced). But on the synthetic dips the speed had begun to rise again while the motor burned, so it wasn’t the lowest of the last 0.75 s. So on the synthetic flights’ motors the cut comes after burnout, and the log keeps the start of the coast. The log up to the cut is fitted, and the fit flown on to apogee.
What gets no cut.
- A GNSS tracker’s log. In the boost a receiver’s altitude can drop out or lag the climb (GNSS in the boost). One flyer reports a lag of up to 440 m (1,444 ft).
- A barometer’s log whose fitted climb speed reaches 227.7 m/s (747 ft/s) before the cut, Mach 0.8 in the coldest air. Nearer the speed of sound (transonic flow), the pressure at the port may stop following the height. The analyzer withholds its top speed there too.
- A log sampled slower than 8 or faster than 500 times a second.
- A log that never climbs 10 m (32.8 ft) above where it last stood still.
- A climb whose top speed is under about 22 m/s (72 ft/s): it stands still again before its cut.
- A log whose speed never drops as far as the cut needs for 0.75 s.
Set A’s first 200 synthetic flights are mostly fast. Of them, 51 were cut, each after the true peak of its vertical speed. Each cut came 1.08 s to 2.30 s after burnout. 43 GNSS logs and 106 fast flights were refused. The slowest of those truly peaked at 221.3 m/s (726 ft/s): the fitted speed reads a little above the true one. Five single bad readings were tried, 12 to 100 m (39 to 328 ft) off. They sat at the pad, the first sample, or halfway or four fifths through the burn. They moved the cut on 8 of the 255 spiked logs of cut flights (785 in all), none by more than 0.70 s (measured). The same five were then tried as two and as three bad readings in a row. Of the 255 logs of cut flights at each length, two in a row moved 9 cuts, by up to 0.70 s. Three in a row moved 23, by up to 1.35 s. Three in a row also left 40 of those 255 logs uncut: the speed then read past 227.7 m/s (747 ft/s), so they were refused. Every cut in these runs still came after the peak and after burnout. Four or more in a row weren’t tried. Steps up on the pad that stay were tried too, from halfway through it, on the 157 barometer logs of those 200 flights. Steps of 8 m (26 ft), 12 m (39 ft), 30 m (98 ft) and 60 m (197 ft) each cut the same 51 flights, at the same sample as without the step. They were refused for their speed on the other 106. A test pins that each cut lands at the clean log’s sample; the counts are measured. A step of 100 m (328 ft) was refused on all 157. Before the pad was read where the line stood still, steps of 12 to 60 m (39 to 197 ft) cut 142 of those logs before the peak. That was measured once, not committed. A test flies three logs it builds, each with a blip on the pad faster than the flight’s top speed. A fourth has a 15 m (49 ft) step. Each is now cut where its clean log is. Before, all four were cut early, two of them before burnout, one 0.05 s after ignition. The test also moves the bad readings across the pad, starting them anywhere from 1.50 s to 2.75 s, with ignition at 3.0 s. Each log is cut where its clean log is, after its peak and burnout, or refused for its speed. From 2.80 s on these flights they can still be the top (#1441, the gap above). Without the height rule, three readings 12 m (39 ft) too high in a row on the pad gave 33 cuts before the speed’s peak, of the 157 logs spiked there (all but the 43 GNSS logs; measured once, not pinned by a test). 32 came before ignition, the other 0.04 s after it, and all 2.4 to 7.9 s before burnout. A test pins the order, the spikes, the place of every cut and at least 51 cuts; the counts and times are measured.
A second test puts a dip in each cut flight’s height: 0.2 to 0.6 s long, 10 to 40 m (33 to 131 ft) deep. It starts at ignition, or 0.3 or 0.6 of the way through the burn. Of 2,295 dipped logs, 1,793 have a speed that falls by the cut’s amount (10% of the top, at least 10 m/s (33 ft/s)) before burnout. 1,642 of them were cut, 0.14 s to 2.30 s after burnout, and 151 refused at the speed limit, which a catch-up can reach. None was cut in the burn. On 797 dipped logs every fall lasted 0.5 s at most and recovered in the burn, as the public logs’ did. Those falls went as deep as 98.9 m/s (324 ft/s), past the public logs’ 63.2 m/s (207 ft/s). On 218 more a fall still ran at burnout. Its depth takes in the coast’s, so it isn’t counted.
Why it can be trusted not to peek. A test replaces every sample’s value and time after the
cut with noise, and the prediction stays the same, bit for bit. It runs on three logs, one with a GNSS
receiver’s channels beside its barometer. Letting the prediction read half a second more changes
it. A channel on a clock of its own is cut at its first time past the cut or out of order; the samples before that are read wherever the file puts them. Run
cargo test -p fusionspace-hpr-forensics boost.
A worked example. NDRT 2020’s motor burns 3.43 s. Its barometer’s log is cut 6.90 s after liftoff, its climb speed at least 10% below its 168.5 m/s (553 ft/s) top for 0.75 s. That top is 1.4 s into the coast, a reading above the speed at burnout. So the cut comes about 3.5 s after the burn ends. The fit to the log up to there flies on to 1,273 m (4,177 ft), as the barometer reads it. The log’s apogee is 1,320 m (4,332 ft): the prediction is 3.6% low. The forward simulation, nothing fitted, reads 1,458 m (4,782 ft), 10.4% high. ERA5’s wind, averaged and held constant with height as the fit holds it, moves it down 3.8 points: the rocket reaches 1,407 m (4,616 ft), 6.6% high. Fitting the boost moves it down another 10.1 points, past the log, to the 3.6% low. The log up to the cut says little of the drag, so the fit leaves it at 0.95, near the 1 it was told. It reads the impulse 0.955. The whole log reads the impulse 0.95 and the drag 0.71. The other flights are in (the report).
Sources
- K. Levenberg, “A method for the solution of certain non-linear problems in least squares”, Quarterly of Applied Mathematics 2, 1944.
- D. W. Marquardt, “An algorithm for least-squares estimation of nonlinear parameters”, Journal of the Society for Industrial and Applied Mathematics 11, 1963.
- W. H. Press et al., Numerical Recipes, §15.5: the damped normal equations and the covariance.
- D. S. Wilks, Statistical Methods in the Atmospheric Sciences, 3rd ed., Academic Press, 2011, eq. 5.12: a correlated series’ effective number of independent values.
- IEC 61400-1:2019, Wind energy generation systems, part 1: design requirements, §6.3.2.2: the normal wind profile, a power law of exponent 0.2.
- ADR-316, the fit’s decisions, with the measurements behind them.
- J. Geweke, “Bayesian inference in econometric models using Monte Carlo integration”, Econometrica 57(6), 1989, pp. 1317–1339: importance sampling, and a proposal’s tails.
- L. Kish, Survey Sampling, Wiley, 1965: the effective sample size of weighted draws.
- M.-S. Oh and J. O. Berger, “Adaptive importance sampling in Monte Carlo integration”, Journal of Statistical Computation and Simulation 41, 1992: widening the draws from a pilot’s.
- ADR-317, the Bayesian option’s plan.
- ADR-320, the Bayesian option’s decisions, with the measurements behind them.
- J. A. Hartigan, “Using subsample values as typical values”, Journal of the American Statistical Association 64, 1969, pp. 1303–1317: the exact sign-flip interval the public flights’ report gives on the prediction’s difference from the forward simulation.
- ADR-325, the public flights’ prediction, with the measurements behind it.
- B. Efron and R. J. Tibshirani, An Introduction to the Bootstrap, Chapman & Hall, 1993, §13.3: the collection’s percentile interval.
Interpolation tables
Learn how HPR Sim reads values between a table’s points, along straight lines or a spline, and what each table does past its ends.
In short
- What it models: reading values between a table’s points, such as drag coefficient against Mach number, along straight lines or a smooth natural cubic spline. Each table sets what happens past its ends, and every lookup says if it went there.
- Sources: the slope form of the cubic spline in C. de Boor, A Practical Guide to Splines (Springer, 2001).
- How well it is validated: analytic and unit tests only. The spline through (0, 0), (1, 1) and (2, 0) matches its closed form, on . Property tests check that both kinds hit every point. Not compared with another simulator or a flight.
- What it leaves out: tables of more than one input. A natural spline can overshoot where data turn sharply (a thrust spike, a transonic drag peak). There is no overshoot-free (monotone) cubic yet, so use linear tables there.
Code and sources
Code: hpr_core::interp (Table1D). Today it carries the tables that override HPR Sim’s own
drag (), and normal force with its center of pressure (Aerodynamics). Thrust curves and soundings interpolate
on their own (Solid motors, Atmosphere). Every table states how it interpolates and
what happens outside its range, and every lookup reports whether it extrapolated.
Knots
A table has knots . The strictly increase, and every value and every secant slope , with , is finite. Construction and deserialization both enforce this.
Interpolation
Inside , with on interval :
-
Linear: . This form returns the knot values exactly.
-
Natural cubic spline: the cubic Hermite form with knot slopes :
The second derivative at the ends of interval is
Equating the two at each interior knot and multiplying by gives
Setting to zero at both ends (the “natural” or free-end condition) closes the system with and . This is the slope form of cubic spline interpolation (C. de Boor, A Practical Guide to Splines, rev. ed., Springer, 2001, ch. IV). Every row is strictly diagonally dominant, so the Thomas algorithm needs no pivoting. With two knots the spline is the straight line.
A natural spline can overshoot where the data turn sharply (a thrust spike, a transonic drag peak). Use linear tables for such data; a monotone cubic can be added when a model needs one.
Extrapolation
| policy | below | above |
|---|---|---|
clamp (default) | ||
linear | ||
error | CoreError::OutOfRange | CoreError::OutOfRange |
is the end interval’s secant for a linear table and the spline’s end slope or for a cubic one. So linear extrapolation of a natural spline stays twice differentiable. A lookup at NaN is an error under every policy.
Tests that pin this
The tests are in crates/hpr-core/src/interp.rs.
natural_spline_matches_the_three_knot_closed_form: knots , , give slopes and on , symmetric about .- Property tests: both kinds reproduce the knots exactly. Linear values stay within each interval’s end values. The spline’s second derivative is continuous at interior knots and zero at the ends. The spline reproduces straight lines, extrapolation included. Each policy behaves as in the table above. A JSON round trip rebuilds an identical table.
rejects_malformed_knots,deserializing_checks_the_knots: malformed input fails.
Adaptive quadrature
See how HPR Sim computes the area under a curve to a requested accuracy, the method behind the volume and inertia of curved parts.
In short
- What it models: a definite integral (the area under a curve) to a requested accuracy, splitting the range where the error estimate is largest. It gives the volume, center of mass and inertia of parts such as nose cones and fins.
- Sources: QUADPACK (Piessens, de Doncker-Kapenga, Überhuber and Kahaner, Springer, 1983), public domain: its 15-point rule, which carries its own error estimate, and its adaptive scheme.
- How well it is validated: analytic tests only. The rule integrates polynomials up to degree 22 exactly, and six test integrals, one infinite at an end, reach 1e-11 relative. The integrals of 22 nose cones and transitions agree with 40-digit references to 1e-12 relative (Nose cones). Not compared with another simulator or a flight.
- What it leaves out: QUADPACK’s extrapolation for singular integrands. It relies on splitting, plus changes of variable at known singularities, and reports an error when it runs out of subintervals.
Code and sources
Code: hpr_core::quadrature.
Source: [QP] R. Piessens, E. de Doncker-Kapenga, C. Überhuber and D. Kahaner, QUADPACK: A
Subroutine Package for Automatic Integration, Springer, 1983. QUADPACK is public domain. Its
routine qk15 has the rule’s nodes and weights to 33 digits.
Method
- On , the 15-point Gauss-Kronrod rule embeds the 7-point Gauss rule . is exact for polynomials of degree and for degree .
- The error estimate of a subinterval is for each component. This overestimates the error of when the integrand is smooth.
- The adaptivity is global ([QP]
QAG, §2.2 and §3.3):- Keep every subinterval with its estimates.
- While the summed error of some component exceeds the larger of and , bisect the subinterval that contributes most to the worst component.
- Stop with
QuadratureDidNotConvergeat the subinterval budget, or when a bisection point can no longer be represented. - QUADPACK’s
QAGSalso extrapolates with the -algorithm. HPR Sim does not. It relies on bisection plus variable substitutions at known singularities (Shapes).
- Vector integrands share one set of subintervals, so the moments of a solid come from the same integrand evaluations. Integrands should be scaled to order one so that one absolute tolerance suits every component.
- The relative tolerance never goes below . A NaN or infinite sample is an error
(
QuadratureNotFinite), never a silent zero.
Verification
The tests are in quadrature::tests.
- The rule is the published one:
- The Gauss nodes are roots of to 1e-15.
- Both weight sets sum to 2.
- One panel integrates exactly for (Kronrod) and (Gauss). At the next even degree it is not exact.
- A digit typo in any node or weight fails these checks.
- Convergence:
- , , , , and all reach 1e-11 relative.
- Four components converge together.
- Reversed limits change the sign.
- Failures:
- on runs out of subintervals.
- A NaN integrand is reported.
The HPR design format (.hpr and .hprz)
This page describes the HPR design format, FusionSpace HPR’s own open JSON format for rocket designs, and how to convert, read and write it.
An .hpr file is a rocket design written as one JSON document in the HPR design format. The format
is FusionSpace HPR’s own, open and described by a published JSON Schema. It holds
everything HPR Sim reads from an OpenRocket .ork. That includes the rocket’s parts, every motor
configuration, when each parachute opens and each stage separates,
and the simulations the file stored. It also carries what the file holds that the simulator doesn’t
model. Beyond that, it holds the other files inside the .ork, such as an embedded thrust curve or a
decal image. It is plain text, so a design can be kept in git and a change to it reads as a small diff.
A .hprz is the same document in a zip archive, with other files beside it, such as the design’s
flight logs and photographs (the container).
What works today: hpr convert turns a .ork into a .hpr or .hprz and back. hpr sim
flies a .hpr or .hprz as it flies the .ork (reading and writing one).
A document of the older version 0.1 is migrated when it is read. Rust programs can do all of this
through the hpr_format library. TypeScript and Python programs can do it through types generated
from the schema, each with a reader that checks a document
(TypeScript and Python).
Keep your .ork too. The format is version 0.2, a draft until FusionSpace HPR’s first release.
A document of version 0.1 still reads, but 0.1 didn’t record whether the rocket’s airframe was read
exactly as written. When the document can’t show it either, hpr sim refuses to fly another motor
in it until the .ork is converted again (versions).
The file
What the format is called, what a document holds, and the zip container that carries other files beside it.
Its names: extension, format id and media type
| name | value | where it is used |
|---|---|---|
| extension | .hpr, and .hprz for the container | the file’s name; hpr convert and hpr sim choose the format by it |
| format id | hpr-design | every document’s format key |
| media type | application/vnd.fusionspace.hpr+json | a .hpr file served over the web, or named by an app that opens it |
The media type is FusionSpace’s (the decision on FusionSpace HPR’s public names
§4). It is in the vendor tree of RFC 6838 with the +json
suffix, since a document is JSON any JSON tool reads. It isn’t registered with IANA. Rust programs
take it from hpr_format::MEDIA_TYPE. A .hprz has no media type of its own yet; as a zip
archive it is application/zip to a program that doesn’t know it.
What a document holds
A document is an object with nine keys, always written in this order:
| key | what it holds |
|---|---|
format | always "hpr-design", so a program can tell a design from any other JSON |
version | the format’s version, "0.2" |
provenance | the program that wrote it (tool), that program’s own version (tool_version, the simulator’s version, not the format’s) and its designation in the FusionSpace product system (designation, "FS-ACHERNAR · SW · TOOL 001", or "FS · SW · TOOL 005" in a document an earlier build wrote; absent in a document written before it was added); the format and SHA-256 of the file the design came from; and, if the design’s airframe was not read from that file exactly as written, why not. Converting a document again names the program that converted it, and keeps the source as it was |
rocket | the stages and their parts, with every motor configuration that flies |
motors | every motor configuration, flown or not, with why one is not |
recovery | when each parachute and streamer opens, and when each stage separates |
simulations | the simulations the source file stored, with their conditions and results |
extensions | what the source file holds that the simulator doesn’t model, kept for writing it back |
source_files | the source file’s other files, such as a .ork archive’s embedded thrust curves and decal images |
Every number is in SI units, and a key says its unit where it has one: length_m is meters,
kg_m3 kilograms per cubic meter. A SHA-256 is a
fingerprint of a file’s bytes: it names the source without giving its path or name, which can
name a person. Here is the start of the
stable trainer,
one of the public demonstration designs from Loft, the project
before FusionSpace HPR, as a document:
{
"format": "hpr-design",
"version": "0.2",
"provenance": {
"tool": "FusionSpace HPR",
"tool_version": "0.1.0",
"designation": "FS-ACHERNAR · SW · TOOL 001",
"source": {
"format": "ork",
"sha256": "199f71f9fc774d5f7f29df70ecac94d8ad46e682a001ef7e67b144970934a234"
}
},
"rocket": {
"name": "Loft Demo 38mm — stable trainer",
"stages": [
{
"id": "10f70005-0000-4000-8000-000000000002",
"name": "Sustainer",
"components": [
{
"id": "10f70005-0000-4000-8000-000000000003",
"name": "Nose cone",
"part": {
"nose_cone": {
"shape": {
"kind": "ogive",
"radius_ratio": 1.0
},
"length_m": 0.25,
"base_radius_m": 0.019,
A stage strapped beside the airframe, such as a pair of boosters, is a parallel stage. It comes
in stages after the stage it hangs on. Its optional parallel key holds:
- the id of its body tube (
on); - its place along that tube (
position); - its copies (
pods), laid out as a pod set’s.
A stage on the axis leaves parallel out, so a 0.2 document written before it reads
the same (Parallel stages).
A stage can carry mass beyond what its parts weigh, such as glue and paint: its optional
added_mass key holds the mass (mass_kg) and, when it has one, its station aft of the stage’s
forward end (cg_aft_m). A stage with none leaves the key out, so a 0.2 document written before it
reads the same (A stage’s added mass).
A stage’s overrides say what it weighs and where it balances, and its optional override_rule key
says how they set its inertia: "rescaled" (the default, left out) scales and moves the stage as
one body, and "parts_in_place" leaves its parts where they are, as OpenRocket weighs a single
stage. The .ork reader gives "parts_in_place" to a stage whose override covers its parts; a
design written by hand keeps "rescaled" unless it asks. Under "parts_in_place" the mass an
override adds sits at the stage’s center and adds no inertia, so if that mass is really spread
along the stage, the inertia reads low, by about the mass ratio (5 times for a 2 kg mass override over 0.40 kg of parts). A
0.2 document written before the key reads the same (A stage’s rule).
A motor that flies is written out in full, its thrust curve included, so a document flies with no motor database. That has a consequence for sharing. When a program supplies curves from a motor database, as this project’s checks supply OpenRocket’s, the document holds those curves. OpenRocket’s database publishes no terms for reusing them (where the curves come from). Check before sharing such a document.
The source file’s other files are under source_files, in the order the file held them. A text
file, such as an embedded thrust curve, is written as its text. Any other file, such as an image, is
written in base64, a standard way to spell
bytes with 64 printable characters. A .ork written from the document puts every one back.
Why the airframe’s reading is recorded. Some .ork rockets aren’t read exactly as written: a
part is left out, a value dropped, or a size assumed. The simulator flies none of their motor
configurations, and hpr sim won’t fly another motor in them either. A .ork written back from the
document spells out every assumed value, so reading it again can’t tell that anything was assumed.
The document therefore records the reason, as provenance.source.airframe_not_as_written, and
hpr sim reads it from there.
What the document doesn’t keep: the .ork reader’s warnings. hpr convert prints them once,
when it reads the .ork; hpr sim prints them for a .ork but not for a .hpr or .hprz.
The container (.hprz)
A .hprz file is a zip archive holding a design and the files that go with it: flight logs,
results, photographs, anything. Its first entry, design.hpr, is the design exactly as a .hpr
file, so unzipping a container gives a .hpr any reader of the format takes. Every other entry is
an attachment, kept byte for byte, under its name, in its order.
- Names are relative paths, with
/between folders, such aslogs/flight-1.csv. No part of a name may be empty,.or... A name holds no\,:or control character. So no name can climb out of the folder a container is unpacked into. No attachment may be nameddesign.hpr, in any mix of capitals, nor sit in a top-level folder of that name (design.hpr/notes.txt). - Names that would unpack as one file are refused. Two names the same but for capitals, and a
name that is also another’s folder (
logsbesidelogs/a.csv), are such cases. For Windows, a part ending in.or a space is refused. So is a part named as a device (CON,NUL,COM1and the like, with or without an extension). No part of a name is longer than 255 bytes, the most common file systems’ limit. Capitals are compared as Unicode maps them, which also takesßforss, sostraße.csvbesidestrasse.csvis refused though Windows would keep both. Two spellings of one accented letter are refused too, as macOS would merge them.écan be written as one character or asefollowed by a combining accent. The names are compared with every accent written the second way (Unicode’s canonical decomposition, NFD). The refusal names both spellings, with the combining accent written out (cafe\u{301}.txt), since the two look alike on screen. - At most 256 MiB, unpacked. The design and its attachments together hold no more. The simulator refuses to write a bigger container, and to read one, so a small, hostile archive can’t fill memory.
- The same design and files give the same bytes. Every entry is compressed with deflate, zip’s usual method, and dated 1 January 1980, zip’s zero date, never the clock. (This holds for one build of the simulator; another deflate library could give other bytes that read back the same.)
- Reading is held to the same rules, so a container made by another program is refused with the reason rather than half read. The reader checks every name before it unpacks anything. It takes the design wherever the archive holds it. It passes over a folder’s own entry, which some zip tools write, as long as the entry is empty. It refuses a symbolic link. It refuses a name beyond plain ASCII that isn’t marked as UTF-8 (each entry carries a flag for it). It also refuses a name that is marked but isn’t valid UTF-8. It refuses two entries of one name, which the zip library the simulator uses would otherwise read as one, dropping the other without a word. A refused link or name is quoted in the message. To get past a name refusal, rename that file inside the archive to plain ASCII. Or pack the archive again with a tool that marks UTF-8 names.
A .hpr has no place for attachments, and a .ork keeps only the source file’s own. So
hpr convert names each attachment it leaves out, as a warning.
Reading and writing one
hpr convert takes a design between .ork, .hpr and .hprz, choosing each format by the file’s
extension (hpr convert):
hpr convert my-rocket.ork my-rocket.hpr
hpr convert my-rocket.hpr my-rocket.hprz --attach flight-1.csv --attach pad.jpg
hpr sim my-rocket.hprz
--attach puts each file at the top of the container, under its file name; a Rust program can
use folders. In Rust, the hpr_format library does each step
(API reference, with worked
examples):
| function | what it does |
|---|---|
DesignFile::from_ork | reads a .ork into a document |
to_json | writes a document’s text |
from_json, read_json | read the text back, migrating an older version; read_json also says which version it was |
DesignFile::to_ork | writes the .ork |
container::write, container::read | write and read a .hprz |
Editing a document by hand. The simulator flies what the document says, and the .ork written
from it carries an edit to the airframe, the recovery or the simulations. (hpr sim flies the
parachutes and streamers, as it does a .ork’s, and its powered separations
(Separation).) The motors are the exception: they are held twice
(what is not there yet). hpr sim flies the motors under
rocket.configurations. The .ork writer takes its motors from motors.configurations. So change
a motor in both places, or convert the .ork again. Nothing warns when the two disagree. Any
program that checks JSON against a JSON Schema can check an edited document before the simulator
reads it (the schema). No other design program reads .hpr or .hprz yet.
The text is canonical: there is exactly one way to write a given design. It uses two-space indents, keys in the order above, and a final newline. So the same design always gives the same bytes.
Before it returns, the writer reads its own text back and compares it with the design. A value JSON can’t carry, such as an infinite number, is refused with an error rather than written as something else.
Versions
A version is two numbers, major.minor. The reader checks format and version before anything
else. So a file of another kind or another version is refused with that reason, not with the first
key it doesn’t know.
- A reader takes its own version and migrates older ones. A migration rewrites an old document into the current version’s shape, one version at a time. The reader then reads it as a current document, so it is held to every current rule. A newer version is refused as “written by a newer program”. A key the reader doesn’t know is refused too. So a document from a later build of the simulator, with a key added within the same version, is refused as an unknown key.
- While the major number is 0, the current version may change in place only if every document
already written stays readable, with the same meaning. Any other change takes a new minor version,
with a migration from the one before.
provenance.designationwas added to 0.2 this way: it is optional, so a document written without it reads as before. The old version’s schema stays committed, with a document its program wrote, which a test migrates. - From 1.0, a new minor version only adds, and a change that breaks old documents takes a new major version, with a migration.
| from version | to version | what the migration changes |
|---|---|---|
| 0.1 | 0.2 | attachments is renamed source_files, leaving “attachment” to mean a file in a .hprz. Whether the airframe was read exactly as written, which 0.1 didn’t record, is worked out from the motor configurations, or marked unknown |
What the 0.1 migration can’t recover. 0.1 recorded why a .ork’s airframe wasn’t read exactly
as written only in a motor configuration left out for that reason. The .ork reader asks it after
the configuration’s motors and before its stages’ separation. So a configuration left out for the
airframe gives the reason. A configuration that flies, or is left out only for its separation,
shows the airframe was read as written. When every configuration was left out for an earlier
reason, such as a missing thrust curve, or there is none, nothing shows it. The migration then marks
it unknown, and hpr sim refuses to fly another motor in the rocket, saying so. On the 73 designs
of this project’s checks, the migration:
- recovers 0 of the 3 reasons, and marks all 3 unknown;
- marks 28 of the 70 designs read as written unknown too, so 31 of 73 in all are unknown;
- gives no wrong answer.
Converting the .ork again gives a 0.2 document that knows. To see whether a 0.1 document was
marked unknown, convert it to a .hpr and look at provenance.source.airframe_not_as_written.
The reasons are in two decisions. The decision on the format and its extensions set the extensions and the first version policy. The decision on the container and migrations added the container and the first migration.
Extensions and unknown keys
What a source file holds that the simulator doesn’t model is kept under extensions. It goes in a
namespace: a key that starts with x- and names the program the data belongs to. Version 0.2 has
one, x-openrocket. It holds the parts, sections, tags and attributes of a .ork that the
simulator doesn’t read. Each is kept whole with where it was
(what the simulator keeps). That is how
a .ork written from a document gets them back.
A key the version doesn’t define is refused, not dropped, anywhere in the document, an unknown namespace included. A document either reads whole or says why it doesn’t. Keeping another program’s namespace as it is waits for a later version.
The schema
schema/format/hpr-design-0.2.schema.json
is the document’s JSON Schema. A JSON Schema is a machine-readable description of a JSON document’s
keys and types, which many languages can check a file against. This one follows the standard’s
2020-12 edition. It is generated from the Rust types by cargo xtask format (one of the
repository’s development commands), and a test fails if the committed file is stale. Its
descriptions are the types’ documentation. It refuses every key the version doesn’t define, as the
reader does. The simulator’s reader refuses what the schema refuses, such as a
provenance.source.sha256 that isn’t 64 lowercase hexadecimal digits, and names the place. Tests
hold it to the schema on thousands of altered documents
(how the readers are checked). The schema can’t express a few rules,
so a document can pass the schema and still be refused by the simulator:
- a source file’s base64 must decode;
- no two source files share a name;
- a name can’t be
rocket.orkor a folder’s; - every embedded thrust curve must be among the source files.
Version 0.1’s schema stays beside this one,
hpr-design-0.1.schema.json.
TypeScript and Python
Programs in TypeScript (or JavaScript) and Python can read a document with types generated from the schema. Each language gets one file, with a reader that checks a document against the schema. Three limits come first:
- The readers check what the schema checks, not everything the simulator does (how they are checked).
- They read version 0.2 only, which is a draft, so copy the file again when the HPR design format’s version changes.
- They read designs; they don’t fly them. To fly a design from Python, use the
fusionspace-hprpackage (Python).
| language | file | needs |
|---|---|---|
| TypeScript | schema/format/typescript/hpr-design.ts | Node.js 22.18 or later to run it as it is, or a TypeScript compiler with target ES2020 or later; tested with Node.js 24 and TypeScript 7.0.2 |
| Python | schema/format/python/hpr_design.py | Python 3.11 or later (macOS’s own python3 is 3.9: check python3 --version), nothing outside its standard library; tested with Python 3.12 and the type checker mypy 2.3.1 |
Using one in your project. Neither is a package on npm or PyPI yet: copy the one file into your
source tree. Both are MIT OR Apache-2.0, like the rest of FusionSpace HPR.
- TypeScript: the file is an ES module, so your
package.jsonneeds"type": "module". Where the compiler only checks types (noEmit), import./hpr-design.tswithallowImportingTsExtensions, as this project’s tests do. A bundler, or Node.js running TypeScript as it is, also leaves the compiler only checking types. Where the TypeScript compiler itself writes the JavaScript, import./hpr-design.jsundermodule: nodenext. This project’s tests don’t try that. - Python: put
hpr_design.pybeside your code or onPYTHONPATH. - A reader takes a
.hprfile’s text. For a.hprz, unzip it and read thedesign.hprinside (the container).
What the file holds. A type for every object in the schema, named as the schema names it, with
the schema’s descriptions as its comments. The names are DesignFile for a whole document, Rocket,
Component, NoseCone and so on. In TypeScript they are interfaces and unions; in Python,
TypedDicts (typed dictionaries) and Literals. A document stays plain JSON data: objects and
arrays (dictionaries and lists in Python). So a program can write it back with its own JSON writer.
The simulator reads the result as the same design, but numbers may be spelled differently (1850
for 1850.0). hpr convert edited.hpr tidy.hpr writes it back in the simulator’s own spelling.
Replace the original with tidy.hpr so diffs in git stay small. To check a document your program
built or changed, pass its text through the reader: readDesign(JSON.stringify(design)) or
read_design(json.dumps(design)).
The reader is readDesign in TypeScript and read_design in Python. It takes a document’s text
and checks it against the schema, which is copied into the file, before handing it back typed. It
refuses, with a DesignFormatError:
- a document of another version:
hpr convertrewrites an older one, and a newer one needs the file from a newer release of FusionSpace HPR; - a missing key, an unknown key, or a value of the wrong type, naming where, for example
$.rocket.stages[0].components[0].part.nose_cone: has no "length_m", which it needs; - a misspelt fixed word, listing the words allowed there, for example
…position.from: is "topp", not "top", "middle", "bottom" or "after".
This example reads each document it is given and counts what it holds:
// Reads each design document named on the command line with the generated types, and prints a
// line for each: what it holds, or why the reader refused it. Exits 1 if it refused any.
//
// node schema/format/typescript/read-design.ts design.hpr [more.hpr ...]
//
// Node.js 22.18 or later runs TypeScript as it is; an older one needs --experimental-strip-types.
import { readFileSync } from "node:fs";
import { DesignFormatError, readDesign, type Component } from "./hpr-design.ts";
/** How many parts `components` hold, counting the parts inside parts. */
function count(components: Component[]): number {
return components.reduce((sum, c) => sum + 1 + count(c.children ?? []), 0);
}
let refused = 0;
for (const path of process.argv.slice(2)) {
try {
const design = readDesign(readFileSync(path, "utf8"));
const stages = design.rocket.stages;
const parts = stages.reduce((sum, stage) => sum + count(stage.components), 0);
const configurations = design.motors.configurations.length;
console.log(
`read ${path}: stages ${stages.length}, parts ${parts}, motor configurations ${configurations}`,
);
} catch (error) {
if (!(error instanceof DesignFormatError)) {
throw error;
}
refused += 1;
console.log(`refused ${path}: ${error.message}`);
}
}
process.exitCode = refused === 0 ? 0 : 1;
The Python one,
read_design.py,
does the same. From a checkout of the repository, with hpr installed (the command
line), convert one of Loft’s public demonstration designs and read it:
hpr convert validation/fixtures/ork/loft-demo/demo-dual-deploy.ork demo-dual-deploy.hpr
node schema/format/typescript/read-design.ts demo-dual-deploy.hpr
python3 schema/format/python/read_design.py demo-dual-deploy.hpr
Each prints:
read demo-dual-deploy.hpr: stages 1, parts 7, motor configurations 1
How the readers are checked
Both are checked on every change:
cargo xtask formatwrites both files from the schema, and a test fails when either is stale.- Both readers read the 17 public designs’ documents (checked on real designs), plus the committed version 0.1 document after the simulator migrates it to 0.2. They print the same counts of stages, parts and motor configurations as a count of the same JSON in Rust.
- Each language’s own JSON writer (
JSON.stringify, Python’sjson.dumps) writes the 18 documents back out, and the simulator reads each as the same design. - Tests make 7,164 altered copies of two of those documents. In them a key is added or removed, an
array is lengthened or shortened, or a value is replaced by another. The replacement is a
different type, an out-of-range number, an unknown word, or a string with a final newline. The
schema refuses 5,802 of them. Each reader takes a copy exactly when a separate schema checker, the
Rust
jsonschemalibrary, does. - The TypeScript compiler (at
targetES2020) and mypy are both at their strictest. They accept the 18 documents written out as values of typeDesignFile, and the two examples. They refuse a document with a misspelt fixed word. - Like the simulator’s reader, both refuse a number too large for a 64-bit float (
1e400) and a lone UTF-16 surrogate ("\ud800"). Both also refuse arrays nested 128 levels deep, as that reader does. Tests hold each to the simulator’s own reader.
A reader checks what the schema says, so it shares the schema’s blind spots. A document it takes can still be refused by the simulator for the few rules the schema can’t express. The two readers also differ from the simulator’s on three details of JSON:
| in the text | HPR Sim | TypeScript reader | Python reader |
|---|---|---|---|
| a key twice in one object | refused | takes the last | refused |
a whole number written with a point or an exponent (2.0, 3e0) | refused | taken as 2, 3 | refused |
| a stage number of 253 or more | read | refused, since JavaScript would round it | read |
Each row of the table, and each refusal in the list above, is tested against the simulator’s own reader.
The other way round, the simulator’s own reader refuses each of the altered copies the schema refuses. So a document the simulator reads, the readers read too. Until #253 was fixed, the simulator read four kinds the schema refuses:
- a
provenance.source.sha256that isn’t 64 lowercase hexadecimal digits; - an array where the schema has an object;
- another key beside
"model": "isa"; "value": nullbeside a plugged delay.
Tests now hold the simulator to the schema on each.
Checked on real designs
The .ork reader and writer are checked on 75 .ork files, 73 of which the simulator reads
(.ork design files). Some are other people’s private designs, so
only counts are published. cargo xtask ork takes each one through the format:
| check | designs |
|---|---|
| its document follows the committed schema | 73 of 73 |
| the document reads back as the same document | 73 of 73 |
the .ork written from it is the .ork the simulator writes from the file itself, other files and all, byte for byte | 73 of 73 |
that .ork reads back as the design first read, bit for bit | 73 of 73 |
| the document, rewritten by the check in version 0.1’s shape, migrates back to the same document, but for whether the airframe was read as written, which 0.1 didn’t record | 73 of 73 |
| of the 3 whose airframe was not read exactly as written, the migration recovers the reason | 0 of 3; 3 marked unknown |
| of the 70 read as written, the migration marks unknown | 28 of 70 |
Between them, the documents carry the files’ 55 other files: 3 as text, the thrust curves the designs embed, and 52 as base64, their images.
Then each motor configuration that flies is flown three ways:
- the design first read;
- the design read back from its document;
- the design read back from the
.orkwritten from the document.
Each flight is in calm air of the standard atmosphere at sea level, off a 1.5 m (4.9 ft) vertical rail. Its stages separate if they do. Of the designs’ 170 configurations, 161 fly, and each reaches the same apogee all three ways, bit for bit. The format’s first step, M3.3a, asked for 1 part in 10⁹.
The check supplies OpenRocket’s own motor database for the curves the files name but don’t carry.
With it, 161 of the 170 configurations fly; with only the files’ own curves and the simulator’s
bundled motors, 154 would fly
(the reference library’s survey of motors). The other 9
of the 170 have no flight to compare. The .ork reader leaves them out of the rocket all three ways, by the
first reason it finds. Of the 9, 6 lack a thrust curve, 1 has a motor the simulator can’t light
as written, 1 an airframe not read exactly as written, and 1 stages it can’t separate as written
(which configurations fly).
In CI, the automatic checks that run on every change don’t have the private designs. So
hpr-format’s tests take the 17 public .ork designs under validation/fixtures/ork/ through the
same checks. None carries a curve the simulator can fly, so
bundled motors stand in. Each motor gets the bundled motor
of its designation, or the one nearest its diameter. 18 configurations fly, one per design and two
for demo-multi-config. From the document they reach the same apogee bit for bit. Through the
written .ork the test holds them to 1 part in 10⁹, because the stand-in motors are not written
into a .ork. They are supplied again when it is read. A test also takes each key out of two
documents in turn. It checks that the schema and the reader agree on whether the document is still
valid.
The tests also cover the rest of this page:
- Migration: a document version 0.1’s program wrote, committed as
embedded-curve-0.1.hpr. 0.1’s schema takes it and 0.2’s doesn’t. It reads as 0.2, key for key the old document withattachmentsrenamed. It is the document the current reader makes from the same.ork, flies on the curve it embeds, and writes that.orkback. Other tests migrate edited 0.1 documents. They cover each way the airframe can be recovered, found read as written, or marked unknown. They also cover old documents that already hold a 0.2 key, which are refused. A last one migrates each of the 17 public designs from its 0.1 shape, plus two made from them. One has a parallel stage the simulator leaves out, and one has an invented embedded curve. All 19 come back as the document first written, but for the airframe’s answer, which is never wrong. With no motor catalog in these tests, no public design’s configuration flies. So all 17 come out unknown, and only the invented-curve design’s answer is recovered. - The container: a design with four attachments (a text file, an image, an empty file and a
name in accents) reads back the same. It writes the same bytes again. Each of these is refused
with the reason:
- each name rule above;
- two entries of one name;
- a symbolic link;
- a name beyond ASCII that isn’t marked as UTF-8;
- a name marked as UTF-8 that isn’t valid UTF-8;
- a folder’s entry that holds bytes;
- a missing or damaged design;
- a container past 256 MiB, written or read.
- The command line:
hpr converttakes a public design.ork→.hpr→.hprz→.ork, each file the library’s own, byte for byte.hpr simflies a public design from its.hprand its.hprzto the same output as from its.ork. It refuses another motor in a rocket whose airframe wasn’t read as written, whichever of the three it reads.
How it compares with other design formats
Four other formats hold a hobby rocket design. HPR Sim reads .ork and writes it back. It doesn’t
read the other three yet.
OpenRocket’s flights of the private designs
lists the reference library’s .rkt and .CDX1 files it leaves out.
OpenRocket .ork | RockSim .rkt | RASAero II .CDX1 | RocketPy .rpy | HPR design format .hpr / .hprz | |
|---|---|---|---|---|---|
| encoding | XML, usually in a zip archive with other files | XML | XML | JSON | JSON, canonical text; a zip archive for .hprz |
| published description | a prose page, no schema | in the help of SMARTSim, Apogee’s companion program | none: “not documented”, its author says | none beyond the code | a JSON Schema, generated and tested |
| version in the file | yes, major.minor | yes | yes | RocketPy’s version | yes, major.minor, with migrations |
| units | mostly SI, not stated in the file | fixed default units, not stated | the program’s English units (inches), not stated | SI by RocketPy’s convention, not stated | SI, the unit in every key’s name |
| motor configurations, stages, recovery | all three | stages, motors and parachutes | a sustainer and up to two boosters; recovery at apogee and at a set altitude | one motor object per rocket (a ring cluster, several motors in a ring, is modeled as one), parachutes, no staging | all three, as .ork has them |
| thrust curves and other files | embedded curves, images | motors by name | motors by name | curves as data, no other files | embedded curves and images; any file in a .hprz |
| another program’s data | a simulation’s extension settings | none found | none found | none | extensions, one namespace per program |
| what it is | a design | a design | a design, as its outer shape for aerodynamics | a saved Flight: the rocket, its environment and the results | a design |
Sources:
- OpenRocket’s
file format page
and HPR Sim’s own reading of 73 files (
.orkdesign files). - Apogee’s SMARTSim manual, which says RockSim’s rocket files are XML with data “stored using prescribed default units”. It sends the reader to SMARTSim’s own help for the elements.
- RASAero II’s author on its file format and its user’s manual, which gives every dimension in inches.
- The four
.rktand four.CDX1files in this project’s reference library, of which only these facts are published. - RocketPy’s code at the version this project’s checks pin, where
.rpycame with version 1.10.0 (save_to_rpyandload_from_rpy).
Why FusionSpace HPR didn’t adopt one of them:
.ork: its page describes the structure and leaves the rest to OpenRocket’s source code, which is GPL-licensed and which this project doesn’t read. It has no schema, and the usual zip archive shows no useful difference in git. HPR Sim keeps reading and writing it, as the format most designs are shared in..rkt: RockSim is a commercial program, and its file’s elements are described only in the help of another of its maker’s programs. Its units are implied, not stated..CDX1: undocumented, in English units, and it describes the rocket’s outer shape for aerodynamics, not a design to build..rpy: a saved state of one Python library’s objects, not a design format. It has no schema and holds one motor and no stages. A function in it (a parachute’s trigger, say) is stored as a Python pickle, which runs code when the file is loaded. So a.rpyfrom someone else is only as safe as a program from them.
What is not there yet
- The generated types aren’t on npm or PyPI. Copy the file you need from the repository (TypeScript and Python).
- Reading
.rkt,.CDX1or.rpy: no milestone yet. - The motors are held twice.
motors.configurationsholds every configuration in the file as the.orkholds it.rocket.configurationsholds the ones that fly, each motor ready to fly.hpr simuses the second and the.orkwriter the first. Editing one doesn’t change the other, and nothing checks that they agree yet. - An embedded curve is held twice: as the file’s text under
source_files, and as the motor built from it in the configuration. A flight uses the motor; a.orkwritten from the document uses the text. Editing one doesn’t change the other, and nothing checks that they agree yet. - Some type names come from
.ork, such asOrkMotor, because the document holds the design as the simulator’s.orkreader models it. A later version can rename them, with a migration. - A container’s attachments aren’t read by anything yet.
hpr simflies the design and says how many it leaves unread. Reading a flight log from a.hprzwaits for the commands that compare a flight with its simulation.
OpenRocket .ork design files
This page explains how HPR Sim reads an OpenRocket .ork design into a rocket it can fly, part by
part, and writes one back out.
A .ork file is an OpenRocket design. It holds the tree of parts a rocket is built from and the
materials they are made of. It also holds the motors flown in it and the results of the simulations
OpenRocket last ran. Hobby designs are most often shared in this format, so reading it is how a
design gets into HPR Sim without being typed again.
What works today: HPR Sim reads the three .ork container forms and turns the XML into a design
tree. It keeps what it doesn’t model. It writes a design back out as a .ork that reads back as the
same design (writing a .ork back out). OpenRocket 24.12 opens each
written file whose original it opens. OpenRocket flies each one to the original’s apogee within
0.002% (checked in OpenRocket). Layout is normalized; comments, processing
instructions and XML namespaces are dropped.
It currently builds supported stages, body components, tubes, rings, fins, lugs, rail buttons,
pods, recovery gear, motor configurations, recovery settings and stored simulations. Staged,
clustered and air-start configurations fly, with each stage separation under power, one or several
in turn (staged, clustered and air-start flights). Two
more cases fly. One is a payload dropped with nothing left to burn, when its own device opens at
the split. The
other is boosters strapped beside the core on a rocket of one stage on the axis
(Parallel stages). Unsupported shapes and recovery behavior are not fully
modeled. The trust limits below are measured against OpenRocket 24.12 and the current reference
corpus. A Rust program reads a file with hpr_io::ork. From a terminal,
hpr sim flies one, with its parachutes and streamers. It refuses what it
can’t fly as written, such as a payload that would coast with no drag after its split.
The details, one claim at a time.
- The shape is cross-checked. The airframe’s key geometry was compared with a second program
that reads
.orkfiles, RocketSerializer, and with OpenRocket itself. That geometry is the nose cone, the transitions, the fin sets, where each sits, and the body radius. Over 71 designs in the current scratch-excluding survey, HPR Sim’s value is within the survey’s 1-in- comparison tolerance of OpenRocket’s for all 1,171 numbers. The survey found 75 files, 73 readable and 72 with a design that lays out; two readable designs are not opened by OpenRocket. Where parts sit is checked against OpenRocket alone. Mass and the center of gravity are checked in Mass properties (checked against RocketSerializer). - Most motor configurations fly with HPR Sim alone. Motors are read. A configuration flies only
when every motor in it has a thrust curve and lights at a moment HPR Sim can fly. Its stages
must also come apart in a way HPR Sim flies, and the airframe must have been read without a
warning. Most designs don’t carry their curves. With the file’s own curves and HPR Sim’s
bundled catalog, 154 of the 170 motor configurations in the reference library and
OpenRocket’s examples fly. When a caller also supplies OpenRocket’s own motor database, as the
validation survey does, 161 fly. HPR Sim doesn’t ship that database
(motors in the reference library). The
hpr simcommand fetches a curve still missing from ThrustCurve.org by the file’s manufacturer and designation, and caches it, as motors from ThrustCurve.org describes. With those curveshpr simflies 136 of the 170 as saved, and 25 more with--accept-design-errors(the count). - Parachutes and streamers fly as OpenRocket flies them. HPR Sim lands within 0.021% of
OpenRocket’s landing speed on 50 of its 53 example flights and within 0.12% on all 53. Take the
51 with no named cause for an apogee gap, less the Base drag hack’s three. On these, HPR Sim’s
flight time is −1.57% to +3.16% off
(flown as OpenRocket flies them). Stage separations are flown as
described below. A lone
separation with nothing left to burn, such as a payload’s, is flown under one condition. The
part that keeps the nose must have a device of its own open by then
(a payload’s split).
A Rust program and
hpr simfly such powered separations, each device on the part its stage is in (powered separation inhpr sim; several separations). A dropped stage’s own flight is not validated (the evidence row).hpr simflies a configuration whose separation can only come after apogee as one stack, with a note. - Whole flights are compared with OpenRocket’s on its own examples. Both programs fly 53 configurations of OpenRocket’s examples to the end. On 41 of them the stability margin off the rod agrees within 0.016 calibers, taken with the air along the rocket’s axis as OpenRocket’s is. On the Tube fin rocket it is 1.08 calibers below OpenRocket’s (tube fins), on the three-stage example’s three configurations 0.039 to 0.058 below, and on the five flights of Pods--airframes and winglets 0.071 to 0.076 above, the flattering side (#325, #326). Where nothing named explains a difference, HPR Sim’s apogee is from 4.34% low to 1.95% high. Eight apogees are more than 5% off, each with a named cause. The eighth, 37.93% low, is a pod example’s sustainer that turns over before apogee in both programs. OpenRocket aborts it, so HPR Sim’s is compared at two points up to the abort, weaker evidence than an apogee. At OpenRocket’s last row, 1.81 s, its height is 1.18% below OpenRocket’s and its speed 4.02% above (flights OpenRocket aborted). The rest is in HPR Sim’s flights against OpenRocket’s.
- One private flight is far off, and it is the supersonic one. On the private designs, one
apogee is more than 5% from OpenRocket’s. It is
C06/1(a private design’s first motor configuration, under an anonymized id), the only supersonic flight, at +13.60%. Flown on OpenRocket’s own drag it reads +1.11%, so its cause is in the drag. Which drag is right is open (#222: HPR Sim’s supersonic pressure drag and base drag under power, a supersonic flight). - Pods are read, weighed and flown (Pods). Five small probe designs with pods of bodies, fins, a tail cone, winglets or motors are compared with OpenRocket. So is OpenRocket’s Pods--airframes and winglets, whose stability margin reads 0.07 calibers above OpenRocket’s, the flattering side (below).
- Parallel stages are read and flown on a rocket of one stage on the axis (Parallel stages). OpenRocket’s Parallel booster staging flies both its configurations within 1.3% of OpenRocket’s apogee. A parallel stage HPR Sim can’t read, such as one on a rocket of several stages, is kept whole. The design is marked reduced (what HPR Sim keeps).
- Some parts are left out. A part HPR Sim cannot give an honest shape, such as a launch lug on a nose cone, is left out. Each one is named in a warning rather than guessed at (what is left out, and why). None in the reference library is. The warning says what the part carried and which way the numbers lean without it (what a part left out does to the numbers).
- Fins on a nose cone or a transition are read with their root along its surface (Fins on a nose cone or a transition).
- Tube fins are read, weighed and flown, each tube as a ring wing (Tube fins sized from the body; the aerodynamics). OpenRocket’s example flies 6.95% higher in HPR Sim than in OpenRocket, a net gap in the drag.
- Every one of the 72 designs in the current reference survey lays out, meaning every part gets a position and a radius. A radius the file leaves with nothing to be worked out from gets OpenRocket’s own default of 25 mm (0.98 in). It also gets a warning (when an automatic radius has nothing to take).
- A written file flies in OpenRocket as its original does. Of 151 configurations OpenRocket flies both ways, all 151 reach the original’s apogee within 0.002%, and 142 exactly. This checks the file, not HPR Sim’s physics (checked in OpenRocket).
Opening a file today
This is the doctest on hpr_io::ork, which CI runs. It stops at the document: the tree of
elements the file said, with nothing interpreted. To go one step further and get an
hpr_design::Rocket out of that tree, see
opening a design, in full.
let xml = br#"<?xml version="1.0" encoding="UTF-8"?>
<openrocket version="1.10" creator="OpenRocket 24.12">
<rocket><name>Sounder</name></rocket>
</openrocket>"#;
let read = hpr_io::ork::read(xml)?;
assert_eq!(read.value.container, hpr_io::ork::Container::Xml);
assert_eq!(read.value.document.version.to_string(), "1.10");
let rocket = read.value.document.root.child("rocket").expect("a rocket");
assert_eq!(rocket.child("name").expect("a name").text(), "Sounder");
assert!(read.warnings.is_empty());
read takes bytes, not a path: hpr-io does no file I/O, so that it can also run in a browser.
Hand it the bytes of a real .ork and the three containers are all the same call. What comes back
is an OrkFile (the container, the document, and the archive’s other entries) beside the
warnings the read raised.
Code: hpr_io::ork (API reference), written for
the milestone that reads the container and the document whole.
Rules below are from the format documentation unless marked Observed (seen in real files) or
Policy (HPR Sim’s own choice).
Reading the file
Where the format is described, how the reader unpacks and parses a file, and how it was checked on real files.
Sources
- [F] OpenRocket file format documentation,
https://openrocket.readthedocs.io/en/latest/dev_guide/file_specification.html, and the
fileformat.txtshipped with the program. There is no XSD: nothing machine-checkable describes a.ork, and every OpenRocket release has added tags. - Observed: 75
.orkfiles, all cached underrefs/and never committed. The private design corpus supplies 27. Loft supplies 20 hand-authored fixtures and Debrief 1 (this project’s two predecessors). The pinnedOpenRocket-24.12.jarholds 17 example designs. Theopenrocket-databaseparts library supplies 9, and 1 was cached elsewhere. Generated files underrefs/scratch/and sources cached for research notes underrefs/research/are excluded from the default survey. So is the repository pinned underrefs/public-flights/for two predicted flights (issue #1413 asks for its designs to be surveyed). By the files’ owncreatorattribute, 55 of the 73 readable files were written by OpenRocket and 18 were hand-authored. So where a count says what a real OpenRocket writes, it is given over those 55. Every count below is printed bycargo xtask orkunless it names another source. - OpenRocket’s own Java source is not consulted. It is GPL, so it can’t be read (the decision to keep the document whole), and this project is MIT OR Apache-2.0. The project is built from published documentation and real files, never from another program’s source, which is what “clean room” means here.
The three containers
Loft told the three apart by their magic bytes. A malformed file had to give an error rather than crash (the Loft lesson on that). The first bytes say which of the three a file is in ([F]):
| container | first bytes | what it holds |
|---|---|---|
| zip | 50 4b 03 04 (PK␃␄) | an entry called rocket.ork (the design as XML) beside anything else the design carries |
| gzip | 1f 8b | the design document, compressed on its own. What older OpenRocket versions wrote |
| XML | <, after an optional byte-order mark and blank lines | the design document itself |
Observed: of the 73 files that open, 71 are zip and 2 are plain XML. No gzip .ork survives in
the current scratch-excluding survey, so that path is held by a test rather than by a real file.
Policy. Inside a zip, the design is the entry named rocket.ork. If there is none, the first
entry whose name ends in .ork or .xml is read as the design and a warning says so. Every other
entry is kept byte for byte as an attachment: thrustcurves/*.rse motor curves (schema 1.11),
preview.png, lookup tables. Observed: 38 .png, 11 .jpg, 3 .gif and 3 .rse attachments
across the corpus. All three .rse curves come from the single schema 1.11 file. So the 1.11
attachments that
the milestone that reads motors, recovery and stages reads
are a sample of one. Loft threw such attachments away
(the Loft lesson). The motor reader takes a curve from them
first (where the thrust curve comes from). They are kept
too, so an export can put them back.
The schema version
The root element carries it: <openrocket version="1.10" creator="OpenRocket 24.12">. Version 1.9
is OpenRocket 23.09, and 1.10 is 24.12. Version 1.11 (26.xx, documented but not yet released) adds
embedded .rse curves, CSV lookup tables, a gravity model and preview.png.
Observed, across the corpus:
| schema version | files | written by |
|---|---|---|
| 1.4 | 2 | OpenRocket 13.05, 15.03 |
| 1.5 | 9 | OpenRocket 15.03 |
| 1.8 | 5 | OpenRocket 22.02 |
| 1.9 | 3 | OpenRocket 23.09 |
| 1.10 | 53 | OpenRocket 24.12, and hand-written fixtures |
| 1.11 | 1 | an OpenRocket 26.xx snapshot |
Policy. A version past 1.11 is read anyway, with a warning. A newer file is mostly an older file
with tags added, and refusing it outright would help nobody. A version that is not major.minor is
an error.
The document
The design document is read into a tree of elements and text, and nothing is interpreted. That is deliberate. There is no schema to check against. So the only way to be sure a later step has not quietly dropped something is to keep the whole file. It must also be possible to write it back.
Policy, and what the tree keeps:
- Every element, in document order, with its attributes in the order they were written.
- The text of a leaf element exactly as written, including leading and trailing spaces.
<name> Sounder </name>is not the same as<name>Sounder</name>until something decides to trim it. - Text an element holds beside child elements. Observed: OpenRocket writes this, and only
here. A simulation’s
<warning>prints its own message after its fields, in 48 elements of 19 files.cargo xtask orkfinds no other tag that does it. - The blank text that only lays the file out (the indentation between child elements) is not kept. This keeps writing the document out again free to lay it out afresh.
- An XML comment or processing instruction is dropped, and counted as a warning. No
.orktag carries meaning in one. A comment, a processing instruction or a CDATA section splits a run of text in two as it is parsed. The pieces are joined back, because dropping the comment leaves the writer nowhere to put the split.
The one thing the tree does not keep is XML namespaces. A prefix and its declaration are
dropped, and two attributes differing only by prefix become one. No .ork OpenRocket writes uses
them, and a document that declares any says so in a warning.
Writing the document back out uses one fixed style. It isn’t W3C Canonical XML, which is a different
thing. It indents by two spaces and writes <tag/> for an empty element. It uses character
references for characters that would otherwise change when read again. These are a carriage return
in text, and a tab, newline or return in an attribute. Reading a document, writing it, and reading
it again gives the same document. That is what “keeps everything” means here. Invariant
(tested): parse(to_xml(parse(x))) == parse(x): by
hpr_io::ork::tests::any_document_written_and_read_again_is_unchanged over generated trees, by
reading_writing_and_reading_again_gives_the_same_document and
awkward_text_and_attributes_survive_being_written on awkward text, and by cargo xtask ork over
every real file in the corpus.
The values inside the tags
A component’s numbers sit in leaf elements, and three things about them are not obvious. All three
are mistakes Loft made. Each is settled here by what the corpus shows rather than by a
specification, because .ork has none. Code: hpr_io::ork::value
(API reference), decided in
the decision on what a value means.
A dimension may be automatic. <aftradius>auto 0.025</aftradius> means “OpenRocket works this
out from the neighboring components, and 0.025 m (0.082 ft) is what it last worked out”. This form is
how OpenRocket 24.12 writes it; older releases may differ
(see below). A bare auto
(<outerradius>auto</outerradius>) is the same with nothing worked out yet. It is the commoner
form: at least 290 of the 407 automatic dimensions in the corpus cache no number. Those are all the
cd, innerradius and outerradius ones. So a reader that resolves them cannot treat the cached
value as a shortcut. HPR Sim keeps both halves: which it is, and the cached number. Keeping only
the number is a Loft lesson: it turned automatic dimensions into
hand-typed ones the next time the design was saved. Observed: 407 automatic dimensions across
the corpus, on seven tags.
| tag | Automatic dimensions |
|---|---|
outerradius | 131 |
innerradius | 80 |
cd | 79 |
radius | 37 |
packedradius | 36 |
aftradius | 30 |
foreradius | 14 |
A tag may be written under two names. OpenRocket renamed several and writes both, so an older
reader still finds one. Two of those renames are that and nothing more, and HPR Sim reads either
name, taking the newer. Observed: on every element that carries both, the two agree. They agree
on the text, and on the type/method attribute that says what the number is measured from.
| newer | older | elements with both | Elements agreeing on text | Elements differing on frame |
|---|---|---|---|---|
axialoffset | position | 642 | 642 | 0 |
instancecount | fincount | 109 | 109 | 0 |
Two that disagree is not something OpenRocket writes, so HPR Sim raises a warning. It does so whether they disagree on the number or on where the number is measured from.
Three more pairs look the same and are not. The newer name of each carries a method
attribute (the frame the number is measured in) that the older name never carries:
| newer | older | elements with both | Elements agreeing on text | Elements differing on frame |
|---|---|---|---|---|
angleoffset | rotation | 95 | 95 | 95 |
angleoffset | radialdirection | 26 | 26 | 26 |
radiusoffset | radialposition | 0 | n/a | n/a |
For a long time HPR Sim read neither name of any of them. The two angle pairs agree on the number
every time and differ on the frame every time. radiusoffset (on 106 elements) and radialposition
(on 536) are never written together at all, so nothing about them had been measured. Reading one
as the other would move a component without saying so.
The step that read all three settled them without ever having to say what the older name’s frame is. See how far off the axis, below.
A stated zero is a value. <overridecd>0.0</overridecd> means no drag at all, not “no
override”. Reading it as missing is a Loft lesson, which charged
a zero-drag part full drag. A component declares its own mass, center of gravity and drag
coefficient with three tags. Three more say whether each covers the components inside it. All are
read independently. A part’s or a stage’s drag coefficient goes into the design as its
drag_override, with its own flag. It flies as OpenRocket 24.12 flies it: on the reference area,
once per fin, lug or button, in place of all the part’s own drag. See
A part’s stated drag coefficient and
the decision on drag overrides.
One on the <rocket> element itself has no place in the design and is not applied. No file seen has
one.
Observed override tags: overridemass 108, overridesubcomponentsmass 95,
overridesubcomponents 10, overridecg 14, overridesubcomponentscg 9, overridecd 2,
overridesubcomponentscd 2. The third of those is the single flag that files before schema 1.9 use
in place of the three per-quantity ones. Policy: it is read as OpenRocket 24.12 reads it, as
setting all three, in files of schema 1.4, 1.8 and 1.10 alike. Where a part writes both forms, the
one written later wins, quantity by quantity. <overridesubcomponents>true</overridesubcomponents>
then <overridesubcomponentsmass>false</overridesubcomponentsmass> covers the parts inside for the
center of gravity and the drag but not the mass. No element in the corpus carries both forms. Eleven
probe designs measured this
(the old override flag), and the tests in
hpr_validate::openrocket hold HPR Sim to them. HPR Sim no longer warns about the flag’s form. Not
measured: a value other than true or false, which is dropped with a warning (so the design is
not flown). Also not measured: a flag tag written twice on one part, which is read at its first
copy, with a warning too.
A stage’s mass and center of gravity overrides
A stage’s override is read as OpenRocket 24.12 weighs it, and that depends on the override’s
flag. A mass override that doesn’t cover the stage’s parts is added to them and flies. An
override that covers the parts leaves them where the design puts them, as OpenRocket does
(The inertia where an override covers the parts, below). What is still refused is in the
last bullet below. A flag of true says the override covers the stage’s parts: in OpenRocket, the override’s
box for all subcomponents is ticked (“override for all subcomponents”, in its user guide’s words).
The override is then the whole stage’s. With the box unticked the flag is false, and the guide
says the value “is added to the calculated value”. The guide says so of the center of gravity
too, but OpenRocket 24.12 itself changes nothing for a center alone (the table’s second row). A
flag that isn’t written reads as false, even when the other flag is written. The older single
flag saying false reads as false too. The probes measured this in schema 1.10 files, and the
older flag in schema 1.4. The reader applies it to every schema.
Probe designs measured where the added mass goes. The table is for the one-stage probes’ stage: parts that weigh 0.40 kg, centered 0.470 m (1.54 ft) aft of the tip, with a 2 kg mass override, a center of gravity override at 0.4 m (1.3 ft), or both.
| The stage’s override | OpenRocket’s stage | In the design |
|---|---|---|
mass, flag false or not written | 2.40 kg at 0.470 m (1.54 ft): the 2 kg sits at the parts’ center | an added_mass of 2 kg |
center alone, flag false or not written | 0.40 kg at 0.470 m (1.54 ft): no effect | nothing |
both, flags false or not written | 2.40 kg at 0.412 m (1.35 ft): the 2 kg sits at 0.4 m (1.3 ft) | an added_mass of 2 kg at 0.4 m (1.3 ft) |
mass flag false or not written, center flag true | 2.40 kg at 0.4 m (1.3 ft): the parts stay, the 2 kg sits at 0.4 m (1.3 ft) | an added_mass of 2 kg, under the stage’s center override, its parts in place |
both, mass flag true, center flag false or not written | 2.00 kg at 0.4 m (1.3 ft), exactly as with both true | the stage’s mass and center overrides, its parts in place |
center alone, flag true | 0.40 kg at 0.4 m (1.3 ft): the parts stay | the stage’s center override, its parts in place |
Policy: the reader follows the table for a stage on the axis and for a parallel stage alike, and raises no warning for any row, so it no longer holds such a design back. A stage’s added mass gives the rule and a worked example, and the decision records give the measurements: a stage on the axis and a parallel stage.
- Where the mass sits. With no center stated it sits at the center of that stage’s own parts, and moves neither the center nor the inertia about it. On a rocket of two stages, the lower stage’s added mass sits at the lower stage’s parts’ center, not the rocket’s. A stage’s pods are among its parts. A center that doesn’t cover the parts is a station measured from the stage’s forward end, and the mass sits there, as far off the axis as the parts’ center is: on it, unless the parts’ center is off it, as one pod alone puts it.
- On a parallel stage the table holds on each pairing probed there: eight pairings with each flag written (four of both overrides, four of one), with three boosters and with one, and the mass alone and both overrides with no flag written, with three. A flag left out beside one that is written, and the older single flag, weren’t probed on a parallel stage. One piece of code reads both kinds of stage, so they are read as on a stage on the axis. The record holds 49 probes in all, four of them with no override as baselines: 40 with three boosters beside the core or with one, and 9 of two stages on the axis, one or both weighing nothing. The mass is added once to the set of boosters, not to each. With no center stated it sits at the boosters’ center. A center that doesn’t cover the parts is a station from the parallel stage’s forward end, and the mass sits there as far off the axis as the boosters’ center: 52 mm (2.0 in) off with one booster. The boosters carry the mass away when they drop. On the 25 of those probes with boosters that HPR Sim lays out (places every part and weighs each stage), the parallel stage alone matches OpenRocket’s mass within 5 parts in 10 million, its center within 0.2 µm and both inertias within 3 parts in a million. OpenRocket gives one inertia across the axis, the one about its y axis. One booster hangs off the axis along that axis, so how far off it is adds nothing to OpenRocket’s figure. With one booster, then, the parallel stage’s and the rocket’s inertias across the axis are compared about the body axis the booster lies along, where HPR Sim’s has no such term either.
- On the stage a parallel stage hangs on, an added mass at a station flies. With three boosters, that stage and the whole rocket match OpenRocket’s mass and center within the same bounds. Their inertias are held by what the override adds to them: within 5 parts in 10 million of what it adds in OpenRocket, or within 1e-9 kg·m² where it adds less than 0.002 kg·m². The smallest addition across the axis, 0.000061 kg·m² to the rocket, is held to 1e-9 kg·m², which is 16.4 parts in a million of it. About the axis it adds nothing in either tool. The cases still refused there are in the last bullet.
- A motor doesn’t move it. OpenRocket’s rocket at launch and at burnout is the motor added to the structure above, with the added mass where the structure put it (four more probes, on an airframe with an AeroTech H128W aboard).
- The inertia where an override covers the parts is OpenRocket’s rule: the parts stay where
the design puts them, and the stage’s inertia is theirs about the stage’s center. The mass an
override adds, and an added mass with no station, sit at that center and add no inertia. The
reader gives such a stage
"override_rule": "parts_in_place"(Overrides). On the one-stage probes HPR Sim’s inertias match OpenRocket’s within 3 parts in a million, and on the motor’s airframe the inertia the override adds to the structure is within 1e-9 kg·m² of OpenRocket’s. On the two probes of a rocket of two stages with the override on the lower, OpenRocket’s figure is below what the stage’s tube alone has about the stage’s center, so no stage that keeps its parts in place gives it: the rocket’s inertia across the axis is now 4.95% over OpenRocket’s (a center beside an added mass) and 3.33% over (a mass that covers the parts, beside a center that doesn’t), where it was 1.5% and 18.5% (worse on the first, better on the second); about the axis the two agree. That difference stands: HPR Sim won’t close it, and a test pins both figures (the decision that it stands). With a motor aboard OpenRocket sums the same way: on the motor’s airframe, under an added mass beside a center that covers the parts, HPR Sim’s rule gives an inertia across the axis 1.6% under OpenRocket’s at launch and 1.1% under at burnout, worked by hand from OpenRocket’s records, its motor’s term in both. Closing that gap is open work: M2.3d9, the inertia with a motor aboard. The decision record gives the measurements. - A parallel stage’s override that covers its parts leaves the boosters in place too, and
the reader gives it the same rule. Until this was measured it was read as a pod set’s override:
one body, scaled and moved whole, whose inertia across the axis is more than 37% off
OpenRocket’s on each such probe. The parallel stage alone now matches OpenRocket’s within the
bounds above. The whole rocket’s inertia across the axis doesn’t. OpenRocket sums each
booster from where the design puts it, with its own mass, and adds a point at the parallel
stage’s center, the stated one where the override states one. Under a mass that covers the boosters that point is the whole stated mass, so
the boosters’ own is counted beside it. It takes the rocket’s center from the stage as
overridden. A stage weighed as one body can’t give that sum and OpenRocket’s inertia for the
stage alone.
openrockets_sum_with_a_parallel_stages_covering_center_is_no_bodysworks the sum from OpenRocket’s records on all ten such probes. With an added mass beside a center that covers the boosters, the override adds 0.63% of OpenRocket’s inertia less with three boosters and 0.22% less with one. With a center that doesn’t cover the boosters beside a mass that does, it adds 0.79% and 0.27% less, and about the axis 0.103% less with one booster. Closing those is open work: M2.3d14, the rocket’s inertia beside a parallel stage’s covering override. Where every override covers the boosters (a mass, a center, or both), the shortfall is 0.070% to 4.673%, and about the axis, with one booster under a covering mass, 0.103%. No increment is planned for this yet; #1432 records it. - A center alone that doesn’t cover the parts changes nothing in OpenRocket. It is left out of the design and kept as the file wrote it, so an export writes it back.
- A flag that says neither
truenorfalseis warned of where it is read, which holds the design back, and is taken as not written. - An export writes an added mass back as a mass override whose flag is
false. One with a station is written beside a center override whose flag isfalsetoo. So an added mass read from a file that wrote no flag, or the older single flag, comes back with the per-quantity flags, which read the same. A design built in the library can hold what a.orkcan’t say: an added mass beside a whole-stage mass, or a station beside a whole-stage center. The added mass is then left out, with a warning. A stage under HPR Sim’s default rule with a mass or center override and no stated inertia is written with a warning too: OpenRocket, and the reader, weigh it with its parts in place. - Not flown yet, each refused by name, never guessed:
- On the stage a parallel stage hangs on, an added mass above zero with no station, and one at a station where the parallel stage is one booster off the axis. OpenRocket weighs that stage with its boosters while they hang there. With a mass and no center stated, and no override on the parallel stage, OpenRocket puts the added mass 39 mm (1.5 in) aft of where it sits once three boosters are gone, and 14.4 mm (0.57 in) aft with one. At a station beside one booster, the added mass sits 2.7 mm (0.11 in) off the axis, and on the axis once the booster is gone. Either way it moves when they drop. HPR Sim’s stage is one body that keeps its center (M2.3d11, the stage a parallel stage hangs on). An override that covers that stage’s parts is refused there as before (Parallel stages).
- An added mass above zero with no station, on parts that weigh nothing. On the six probes with no center stated, OpenRocket puts it at the rocket’s tip, even for a lower stage that starts 0.8 m (2.6 ft) aft of it. The tip is as far forward as a mass can sit, so no placement reads the stability margin higher, and HPR Sim doesn’t take it without saying so. On the two with a center that covers the parts beside it, OpenRocket puts it at that center (M2.3d12, an added mass on parts that weigh nothing).
- A flight with a mass that moves, a mass that is released, or a parting through a stage, where that stage carries an added mass (M2.3d13, flights that move, release or part).
The tests a_stage_override_not_covering_its_parts_adds_to_them (19 probes),
a_stage_override_covering_its_parts_beside_one_that_does_not (10 probes),
a_motor_aboard_does_not_move_a_stages_added_mass and
a_stages_added_mass_sits_among_its_pods_and_level_with_their_center (6 probes with pods) in
hpr_validate::openrocket hold HPR Sim to
OpenRocket’s mass, center and both inertias, but for two cases: on the probes with pods or a motor
aboard they hold the inertia the override adds, and the two lower-stage probes hold mass, center
and roll and pin the inertia across the axis at 4.95% and 3.33% over. And a_stage_override_not_covering_its_parts_is_read_and_written_back in
the .ork writer holds the export. openrockets_lower_stage_sum_is_below_its_parts_in_place and
openrockets_inertia_with_a_motor_aboard_is_the_same_sum reproduce OpenRocket’s own sums from
its records: the first checks why no stage that keeps its parts in place gives its figures, and
the second pins the 1.6% and 1.1%. The command line’s test
sim_flies_a_ork_stage_whose_override_adds_to_its_parts flies one of the probes through
hpr sim, with no warning. For a parallel stage,
a_parallel_stages_override_not_covering_its_parts_adds_to_them and
a_parallel_stages_override_covering_its_parts_leaves_them_in_place hold the parallel stage
alone and the rocket and pin the rocket’s shortfalls,
an_added_mass_at_a_station_on_the_stage_boosters_hang_on holds the stage the boosters hang on,
and every_placement_probe_is_checked counts the 49 probes: 27 laid out and 22 refused, each
refusal pinned beside what OpenRocket does there.
sim_flies_a_ork_parallel_stage_whose_override_adds_to_its_parts flies two of them through
hpr sim, their boosters dropping with the added mass. It flies the same airframe with the
mass at a station on the stage the boosters hang on too, and they drop as light as they were. Until this was read, such a stage was held back
(#1225): taking the override as
the whole stage’s would be the flattering side. A stage whose override adds 300 g of paint would
weigh 300 g in all: far too light, so its descent rate would read low.
Warnings, not failures
A design written by an older OpenRocket, or by another program, should still open. Everything that
departs from [F] but leaves the file readable is a warning that travels with the result
(hpr_io::ork::Warning), not an error:
| kind | means | raised for |
|---|---|---|
Skipped | a whole part was left out | a component this reader cannot give an honest shape (below), its warning saying what that does to the numbers; an attachment entry that could not be decompressed, or one that would pass the unpacking limit; a damaged design entry is an error, not a warning |
Dropped | a value was left out | a comment or processing instruction; an XML namespace; a tag whose text is not the number, count or flag it should be; two names for one value that disagree; a dimension the file does not give, read as zero |
Unusual | read as it stands | a schema version past 1.11; no creator attribute; a design entry not called rocket.ork; a surface finish or an axial-offset method this reader has no rule for; an automatic radius with nothing to take, given OpenRocket’s 25 mm (0.98 in) default; a part inside an inner tube set off the body’s axis, placed from the body’s axis (below); a <rocket> holding nothing |
Observed: reading the corpus’s containers and documents raises no warnings at all: every file that opens is ordinary. Building a rocket from those documents raises 10 warnings over 73 readable files: 1 skipped and 9 unusual (what they are). Every kind of warning the container and document readers can raise is therefore exercised by a test rather than by a file anyone shipped.
Only these stop a read:
- bytes that are none of the three containers;
- a damaged zip or gzip;
- a zip with no entry that could be the design;
- a design that is not UTF-8, or not well-formed XML;
- a root element that is not
<openrocket>; - a
versionattribute that is missing or is notmajor.minor; - a document that nests more than 64 elements deep;
- an archive that unpacks to more than 256 MiB.
Why there are two limits
A deflate stream can expand by about a thousand to one. A .ork of a megabyte can therefore ask for
more than a gigabyte of memory. One of forty megabytes can ask for more than a machine has. Running
out is an abort, not an error. So a read decompresses at most 256 MiB out of one archive (the
largest in the corpus unpacks to 2,052,024 bytes, document and attachments together). An entry that
would pass the limit is left out with a warning. If the entry left out was the design, the read
fails rather than returning half a file. hpr_io::ork::container::unpack_within takes another
limit, for a caller with less memory to spend.
Reading descends the tree, and so does the XML parser underneath. A file written to nest deeply
enough exhausts the stack. That is a crash rather than an error, and
the Loft lesson on malformed files asks for an error. Feeding
roxmltree documents of increasing nesting in a debug test build, on a 2 MiB test-thread stack, it
read 120 levels and died on 130. The process aborts, so this one measurement cannot itself be a
committed test. The figure also moves with the stack a platform gives a thread. That is the argument
for not relying on it.
So HPR Sim counts the nesting before the text reaches the parser. The scan skips comments, CDATA
and processing instructions and tracks quotes. HPR Sim refuses anything past 64 levels. The scan can
only ever count more levels than a parser will descend. XML forbids a raw < in an attribute
value, so every element start it sees is a real one. A test,
hpr_io::ork::tests::the_depth_scan_never_undercounts, holds the scan to that over generated
documents.
Observed for the depth, over the 73 files that open: 53 nest 11 deep. The distribution runs 4, 7, 9, 10, 11, 12, 13, 14 and 17. An ordinary single-stage design reaches 11. The deepest, at 17, is OpenRocket’s own parallel-booster example, where each nested stage or inner tube costs two levels and a component’s appearance three. So 64 leaves about three more levels of nesting than anything anyone has written.
Checked against real files
cargo xtask ork reads every .ork in the reference library and in the OpenRocket jar’s example
set, writes them back out, reads them again, and reports counts. The private corpus stays private:
the per-file detail goes to a gitignored corpus-out/, and only counts are published. On
September 23, 2026, excluding generated refs/scratch/ files:
| files found | 75 |
| opened | 73 |
| written and read back unchanged | 73 |
| warnings raised reading the container and the document | 0 (building a rocket from them raises 10; see below) |
| refused, not well-formed XML | 2 |
| deepest nesting | 17 |
| elements holding text beside children | 48, in 19 files |
| largest unpacked (document and attachments) | 2,052,024 bytes |
The two that do not open are hand-written fixtures for Loft’s browser tests, and neither is XML: a
<databranch> is closed with </flightdata>. Python’s expat refuses both at the same lines
HPR Sim does, so this is the files’ fault and not the reader’s. They are listed by name in the
survey, which fails if either one ever behaves differently.
Here the reference library is every .ork under refs/, fetched by cargo xtask refs fetch. It
leaves out the private flight collection’s own designs (two older repositories copied into it are
read). The 17 example designs inside the OpenRocket jar (also under refs/) are counted with it
unless a table lists them apart.
Apart from the two Loft fixtures, every file imports without an error. An import error is a file
that does not read, or a
design that reads but does not lay out. Warnings are not errors, because a warning never stops an
import. The survey counts both kinds of error for each source. On October 23, 2026, excluding generated
scratch/ files from the default scan:
| source | files | Files read | Files laid out | errors |
|---|---|---|---|---|
the private design library (loft-fixtures, now copied into the private flight collection) | 27 | 27 | 27 | 0 |
| the OpenRocket 24.12 jar’s examples | 17 | 17 | 17 | 0 |
everything else under refs/ | 31 | 29 | 28 | 2 (the two Loft fixtures that are not XML) |
One file in the last row reads but holds no design, so it has nothing to lay out.
What you can check yourself. The corpus is not public, so these counts are not reproducible on a
fresh clone. cargo xtask ork needs cargo xtask refs fetch first, and stops with “no .ork files
found” without it. What is reproducible anywhere is everything the tests cover:
cargo test -p fusionspace-hpr-io, and the same command on any .ork files you have, with
cargo xtask ork --dir <path>.
Snapshots of public designs
Seven small designs from Loft, the project owner’s earlier tool, are committed in
validation/fixtures/ork/loft-demo/ (MIT). The test
hpr_io::ork::tests::loft_demo_designs_read_as_snapshotted reads each with hpr_io::ork::design.
It also reads a synthetic design whose motor flies from the bundled catalog. It compares a summary
of what it reads with a committed insta snapshot. A snapshot is a saved copy
of the output that the next run must match. Each summary records:
- the stages and body components;
- the structure’s mass and center of mass, to nine significant figures;
- the motor configurations, and which of them fly;
- the recovery settings and the stored simulations;
- what is kept in
x-openrocket, and every warning.
A snapshot shows that the reading has not changed, not that it is right. None of these numbers
is compared with another program here. The geometry is, in
the next section. For example, demo-stable.ork is a 38 mm
(1.5 in) trainer on an AeroTech H128W. Its snapshot says the structure weighs 0.540 kg and that its
one configuration flies ("flown": ["cfg-38-stable-h128"]). It warns that the motor’s bundled
curve file is more than 1% from ThrustCurve.org’s figures
(motors). Each field’s meaning is in the section of this page
that reads it.
When a snapshot changes, the test fails and shows the old and new output. Run
cargo insta review (from cargo install cargo-insta) to see them side by side, and accept only a
change you can explain. You can also rerun with
INSTA_UPDATE=always cargo test -p fusionspace-hpr-io and read the diff in git. The new .snap
file goes in the same pull request. The private reference library is never snapshotted.
cargo xtask ork reports it only as counts, as above.
Checked against RocketSerializer
In short. RocketSerializer is a second program that reads .ork files.
RocketPy’s team wrote it to turn an OpenRocket design into RocketPy’s inputs. This check compares
HPR Sim’s reading of each design’s shape with RocketSerializer’s. Where the two differ, OpenRocket
itself, run on the same file, decides which is right.
On September 23, 2026 the current scratch-excluding check covered 71 designs. Of 1,171 numbers:
- HPR Sim matched RocketSerializer on 1,061;
- on the other 110, OpenRocket gave HPR Sim’s number, not RocketSerializer’s;
- HPR Sim never differed from both.
Every one of HPR Sim’s 1,171 numbers is also OpenRocket’s. That includes the 1,061 where it matched RocketSerializer. So no agreement here is a mistake the two readers happen to share.
This checks the reading: the dimensions in the file, and where each part sits. It does not check
mass, the center of gravity, or any physics. The ongoing M2.2
work compares those properties, motors, stored results and flights with OpenRocket; completed
mass-property results are in Mass properties.
The check was added by M3.1d2, the roadmap step that finished
reading .ork files, and ADR-059 records how it was decided.
What is compared. What RocketSerializer reports about the airframe’s shape:
| part | numbers |
|---|---|
| the nose cone | its shape, length and base radius, and, for a Haack series nose, its shape parameter (0 for a Von Kármán nose) |
| each transition | its length, and its radius at each end |
| each trapezoidal or elliptical fin set | the number of fins, root chord, tip chord, span, sweep, cant and cross-section (square, rounded or airfoil edges) |
| each of those parts | its station: where its front sits, in meters aft of the nose tip |
| the rocket | its body radius: the largest radius the file writes as a number |
RocketSerializer also reports each part’s name. It reports a fin set’s sweep angle when the file writes one (the files here write the sweep as a length). Those are not compared.
How a difference is settled. A script, validation/oracles/rocketserializer/geometry.py, runs
RocketSerializer’s extractors, the functions it uses to pull each part out of a file, on every
design. It also asks OpenRocket 24.12, loaded on the same file, for each of the same numbers. It
writes what both programs read to a JSON file, the record. cargo xtask ork then compares
HPR Sim’s reading with the record. Two numbers count as the same when they differ by less than 1
part in :
- If HPR Sim’s number is RocketSerializer’s, they agree.
- If it is not, but it is OpenRocket’s, then RocketSerializer differs.
- Otherwise HPR Sim differs, and the survey fails.
Whatever RocketSerializer says, the survey also fails when one of HPR Sim’s numbers is not OpenRocket’s. Otherwise a mistake HPR Sim and RocketSerializer made together would pass as agreement. One such case is known. OpenRocket limits a fin’s cant to 15°. HPR Sim and RocketSerializer take a larger cant as written, so the survey would fail on such a file. Issue #148 tracks what HPR Sim should do. No file here cants a fin past 15°.
A worked example. Loft’s public demo-dual-deploy.ork puts its fin set at the bottom of the
booster tube. The same tube also holds the drogue parachute, packed 0.08 m (0.26 ft) long, listed before the
fins in the file. The parachute sits inside the tube, so it adds nothing to where the fins are.
The file places the fins relative to the tube’s aft end. OpenRocket and HPR Sim both put the
fins’ front 1.45 m (4.8 ft) aft of the nose tip. RocketSerializer adds
up the lengths of every part listed before the fins in the same tube, the parachute’s 0.08 m (0.26 ft)
included. So it puts them at 1.45 + 0.08 = 1.53 m. The record keeps that sum of earlier lengths
for every part, so this cause is checked, not assumed.
The results. From cargo xtask ork on September 23, 2026, over the 75 files it finds. They are the
reference library under refs/ (excluding generated refs/scratch/) and the 17 examples inside
the OpenRocket jar:
| all designs | Counts, each file once | |
|---|---|---|
| designs compared (files OpenRocket opens) | 71 | 51 |
| numbers compared | 1,171 | 855 |
| HPR Sim agrees with RocketSerializer | 1,061 | 772 |
| RocketSerializer differs, and HPR Sim’s number is OpenRocket’s | 110 | 83 |
| HPR Sim differs from both | 0 | 0 |
| HPR Sim’s number is OpenRocket’s | 1,171 | 855 |
Some files are in the library more than once: 13 of Loft’s private designs are copies of the jar’s examples, for one. The second column counts each file’s content once.
The 110 differences, by cause:
| cause | count |
|---|---|
| a fin set’s station: RocketSerializer adds the lengths of the parts before it in its parent, as in the worked example | 75 |
| a transition’s radius: RocketSerializer looks transitions up in OpenRocket by name, and takes the first of that name | 15 |
| no cause shown | 20 |
Stations rest on OpenRocket. RocketSerializer does not read a station, or a transition’s radius, from the file. It loads the design into OpenRocket and walks OpenRocket’s tree, adding up lengths as it goes. That is where the worked example’s extra 0.08 m (0.26 ft) comes from. So its stations are not an independent reading. It agrees with HPR Sim on 5 of the 93 fin sets’ stations and 18 of the 22 transitions’. The rest are among the 110 above, where HPR Sim’s station is OpenRocket’s. For stations this is really a check against OpenRocket alone. For lengths, chords, spans, counts and cant, which RocketSerializer reads from the file, it agrees with HPR Sim every time.
For the 20 with no cause shown, the reason RocketSerializer’s number differs has not been traced. In each of them HPR Sim’s number is OpenRocket’s, and the per-file record holds all three programs’ numbers:
- 17 are stations, 13 of fin sets and 4 of transitions.
- 1 is a nose cone’s base radius, and 1 is the body radius.
- 1 is a nose cone’s shape: a nose written as an
ogiveof shape parameter 0. OpenRocket draws it as a cone, and so does HPR Sim, while RocketSerializer passes on the wordogive.
Four things OpenRocket does that the check allows for.
-
A design worked out again. OpenRocket’s first reading of an automatic radius can differ from the answer it settles on. OpenRocket reaches that answer once it works the design out again (when an automatic radius has nothing to take). The script saves each design once, to a throwaway, before it reads anything. So every number in the record, RocketSerializer’s included, comes from the settled design.
-
A canted fin. OpenRocket turns a canted fin about the middle of its root chord. That moves the front of the root aft by half the chord times , where is the cant. For a 0.495 m (1.62 ft) root at 1°, as in the OpenRocket jar’s Simulation extensions example, that is 38 µm. The file places the root before it is turned, and so does HPR Sim. So the script reads OpenRocket’s station with the cant set to zero, then puts the cant back. It keeps the turned station too. For all 10 canted fin sets, the turned station is aft of the unturned one by exactly that amount, and
cargo xtask orkchecks it. -
A shape word. An ogive of shape parameter 0 is a cone (the spine says why). To tell which shape OpenRocket really draws, the script records OpenRocket’s radius a quarter, a half and three quarters of the way along the nose. HPR Sim’s profile is compared with those three radii: all 69 noses RocketSerializer reports match. So a nose’s shape counts as OpenRocket’s when OpenRocket draws HPR Sim’s profile, whatever word it uses.
-
A leading comment. OpenRocket 24.12 refuses a file that begins with a long enough comment. For 3 files, the script removes the comment from the copy OpenRocket reads, and the record says so.
What it leaves out.
- RocketSerializer reports no body tube, inner part, mass, fin thickness, freeform fins or tube fins. None of those is compared here.
- 6 parts inside pods or parallel stages are not compared. HPR Sim reads pods since M1.13b and parallel stages inside a body tube since M4.5m, but the cross-check still leaves their parts out (issue #211).
- 3 values RocketSerializer gives nothing for are not compared. 1 is a body radius, in a file
that writes every radius as
auto. 2 are fin cross-sections, in a file that writes none. - 4 files are not compared, because OpenRocket 24.12 does not open them. One is Loft’s
demo-quirks.ork, whose parallel stage sits directly under the rocket. Two are the Loft fixtures above that are not XML. The fourth holds no design.
Run it yourself. CI does not run RocketSerializer or OpenRocket. It holds HPR Sim to their saved
output for the seven public Loft designs, validation/fixtures/ork/rocketserializer-loft-demo.json,
with cargo test -p xtask rocketserializer. OpenRocket opens six of the seven. Of their 80
numbers, 74 agree, and the other 6 are fin stations that RocketSerializer adds earlier lengths to,
as in the worked example.
To make a record yourself you need Python 3.11, uv, Java 17 and
the OpenRocket 24.12 jar (cargo xtask refs fetch downloads the jar to refs/openrocket/). From
the repository root:
# Once: an environment of its own, with every package pinned.
uv venv -p 3.11 refs/venv-rs
uv pip install -p refs/venv-rs --no-deps -r validation/oracles/rocketserializer/requirements.txt
# The seven public designs, written over the committed record; nothing should change:
refs/venv-rs/bin/python validation/oracles/rocketserializer/geometry.py \
validation/fixtures/ork/rocketserializer-loft-demo.json validation/fixtures/ork/loft-demo
git diff validation/fixtures/ork/
# The whole reference library and, with --jar, the jar's example designs; then compare:
refs/venv-rs/bin/python validation/oracles/rocketserializer/geometry.py \
corpus-out/rocketserializer.json refs --jar
cargo xtask ork
For your own files, give the script their directory in place of refs: it writes what
RocketSerializer and OpenRocket read. Comparing HPR Sim’s numbers with them is not automated yet;
cargo xtask ork compares HPR Sim with the record of the reference library only.
The rocket’s parts
How the tree of elements becomes a rocket: the stages and body first, then everything on and inside them.
The spine: stages and body components
The trunk of a design is its spine. It is the stages and, inside each, the nose cones, body
tubes and transitions that stack end to end along the axis. hpr_io::ork::rocket turns a
document’s spine into an hpr_design::Rocket, with its shapes, lengths, radii, walls,
materials and overrides. Everything else is counted and left for
M3.1b3: the tubes and rings inside the body, the fins and
lugs on it, the recovery gear.
An automatic radius is marked, not filled in. Where the file says auto, the component carries
the dimension’s name. Rocket::layout() then works the radius out from the neighbors, including
across a stage boundary. So a booster’s first component takes its radius from the stage ahead of
it. That is Loft lesson L59: Loft resolved within a stage only,
and a booster came out as whatever number happened to be cached. A stated wall is also kept when
the radius it sits in is automatic. Judging the wall against a radius that is not known yet threw
it away, which is half of Loft lesson L61.
The shape parameter is not the same number. OpenRocket writes the ogive’s parameter as
(a tangent ogive’s radius of curvature over this one’s).
So is a tangent ogive and an infinite radius, which is a cone.
hpr-design states the same shape the other way up, as . The two are
reciprocals: reading one as the other turns every secant ogive into a bulged one. The power, parabolic and Haack parameters carry over unchanged. All four
are Niskanen’s appendix A, equations A.3 and A.7 to A.9.
Readings this page is not sure of, every one of them for the OpenRocket oracle (M2.2) to settle. The first is the spine’s; the rest come from the parts. Two readings this table held are settled. A shoulder, and a tube, of zero wall thickness weigh nothing, as in OpenRocket 24.12. That was measured in M2.2b1 (ADR-061).
| what the file says | how it is read | why it is in doubt |
|---|---|---|
no shapeclipped on a transition | clipped | it is the shape that reaches both radii; only 1 of the 23 transitions in the corpus states it |
| an angle, which way it turns | the same way HPR Sim’s own frames turn | HPR Sim measures a roll angle right-handed about an axis pointing at the nose; OpenRocket’s technical documentation puts its own axis along the centerline pointing aft and leaves the rest unstated. If it means what that implies, every angle read here is mirrored; see below |
a polished finish | 2 µm | the number is the author’s, from 2013; a newer OpenRocket may have moved it (below) |
Measured on the reference library (cargo xtask ork, 73 readable files): 72 designs’ spines lay
out. Across 92 stages they hold 274 body components: 178 body tubes, 73 nose cones, 23 transitions. Two
of the stages, and two nose cones and two body tubes, are parallel stages, read since
M4.5m (Parallel stages). The
survey marked 328 automatic dimensions, including 7 body radii that took OpenRocket’s 25 mm (0.98 in) default.
The counts are what may be published; the per-file detail stays in the gitignored corpus-out/.
(When this was written, 3 designs did not lay out, and they were thought to be waiting on parts that were not read yet. Reading those parts, in M3.1b3, showed otherwise. One document holds no design at all. Two have radii with nothing to take, which M3.1b4 settled: when an automatic radius has nothing to take. All 72 designs lay out now.)
The parts on and inside the body
Everything that is not the spine hangs off it, and HPR Sim reads it into the same
hpr_design::Rocket. Four families, with the words this page uses for them:
- Tubes inside a body component: an inner tube, usually the motor mount. A coupler is the short tube that joins two airframe sections. An engine block is the ring that stops a motor sliding forward. Each can hold parts of its own.
- Rings that center them: a centering ring is a disc with a hole (its bore) that holds a motor tube on the airframe’s axis. A bulkhead is the same disc with no hole.
- What sits on the outside: fin sets, tube fins, launch lugs (the tubes a launch rod passes through) and rail buttons.
- What is packed in the bore: mass objects (an altimeter, a battery), parachutes, streamers and shock cords. HPR Sim reads the cylinder each takes up when packed, not what it does when it opens.
Code: hpr_io::ork::attached, decided in
ADR-053: the parts on and inside a .ork body.
Opening a design, in full
rocket reads the airframe alone. To get the motors as well, call hpr_io::ork::design instead
(motors and their configurations).
This is the doctest on hpr_io::ork::rocket, which CI runs.
The snippet leaves out the lines before it, which set xml to a small design. To run it, use
cargo test -p fusionspace-hpr-io --doc ork::component::rocket. Hand it the bytes of a .ork,
and what comes back is a design and the warnings reading it raised:
let read = hpr_io::ork::read(xml)?;
let design = hpr_io::ork::rocket(&read.value.document);
// Anything the reader could not take at face value travels with the result. Nothing here did.
assert!(design.warnings.is_empty(), "{:?}", design.warnings);
// The ring's outer radius says `auto`, so the design carries the dimension, not a number...
use hpr_design::AutoDimension;
let ring = &design.value.stages[0].components[1].children[0];
assert!(ring.auto.contains(&AutoDimension::OuterRadius));
// ...and the layout works it out: the bore of the tube the ring sits in, 0.05 - 0.002.
let layout = design.value.layout()?;
let (_, placed) = layout.find("ring").expect("the ring");
let hpr_design::Part::CenteringRing(ring) = &placed.part else { panic!("a ring") };
assert!((ring.outer_radius_m - 0.048).abs() < 1e-12);
assert!(placed.own.mass_kg > 0.0);
design.warnings is where a part that was left out is named. It is a Vec of
Warning. Each holds where in the file it happened and
how much was lost (Skipped, Dropped or Unusual). It also holds a sentence saying what was
read and how, and for a part left out, what that does to the numbers. For example: “a launch lug
sits on a nose cone, and HPR Sim attaches one only to a body tube; it was left out. Its mass and
drag aren’t counted, so the mass and drag read low. The stability margin reads high for a part aft
of the center of gravity, low for one ahead” (what a part left out does to the
numbers). Read them. A design that opens cleanly
raises none. The 73 readable files of the reference library raise 10 between them, and this page
explains every one (what the 10 warnings are).
.ork tag | read as | notes |
|---|---|---|
innertube, tubecoupler, engineblock | InnerTube | may hold parts of its own |
centeringring | CenteringRing | bore and outer radius may both be automatic |
bulkhead | CenteringRing with no bore | |
trapezoidfinset, ellipticalfinset, freeformfinset | FinSet | with its tab, its cant (the angle the fins are turned to induce roll) and its section (the shape along the chord: square, rounded or airfoil). The tab is read as stated, even where it starts ahead of the root or ends past it, as OpenRocket weighs it (a tab weighed as stated) |
tubefinset | TubeFinSet | an auto radius closes the ring around the body, as OpenRocket works it out (Tube fins sized from the body); both sets in the corpus are written so |
launchlug, railbutton | LaunchLug, RailButton | a row of them is one part with a count and a spacing; a rail button’s <screwheight> is its screw head, weighed since M4.5i (mass) |
masscomponent | MassComponent | |
parachute, streamer, shockcord | Parachute, Streamer, ShockCord | the packed shape, not the deployment |
podset | PodSet | the pod’s nose cones, body tubes and transitions, and everything on them (Pods) |
parallelstage | a Stage with its ParallelStage layout | inside a body tube on a rocket of one stage on the axis: a stage of its own, laid out as a pod set on that tube (Parallel stages); anywhere else, kept whole (what HPR Sim keeps) |
Angles in a .ork are degrees. Nothing in the file says so, and every length beside them is in
meters, which invites reading an angle as radians. Read that way, <angleoffset>180</angleoffset>
would be more than twenty-eight turns instead of half of one.
Observed: of the 977 angles the corpus writes, 184 are not zero. 174 of those are
larger than , more than a whole turn, which no component is written at. The values themselves
are 180, 90, 45, 30 and 120, carrying the float dust (119.99999999999999) of a conversion that
went through radians and came back. cargo xtask ork prints all three counts, and
hpr_io::ork::tests::angles_are_degrees_not_radians holds the reading.
A fin’s cant is the same degrees. The corpus’s two non-zero cants are 1.0 and −3.98. As radians they would be 57° and 228°, a fin turned past half a turn from the airflow.
Where a part sits is one tag: <axialoffset method="bottom"> on the newer name,
<position type="bottom"> on the older. Both take the same five words (top, middle, bottom,
after and absolute). They are hpr_design::Position unchanged, but for a rail
button. OpenRocket gives a button no length. It puts a button’s center at the position, with a
row’s first button there and the rest aft. So HPR Sim moves the offset to where the button’s
forward edge must be. The rule was measured on probes from the top, the middle and the bottom
(issue #151).
Observed: one tube coupler in the corpus has neither
tag; it is read flush with its parent’s forward end, with a warning.
How far off the axis a part sits is radialposition on some tags and radiusoffset on others.
ADR-052 read neither, for want of a source saying what the older name measures from.
That question need not be answered, because the two never meet. radialposition (536 elements)
is written on the parts inside a body. radiusoffset (106) is written on the parts on it and
on the pods. No element carries both. They are two tags on different components, not two names
for one. So
each is read where it is the only name its part has, and neither is ever read as the other.
Which way round a part sits is the angle, and there the two names do meet. angleoffset is the
newer one; the older is rotation on a fin set (95 elements carry both) and radialdirection on
everything else (26). On all 121, the two agree on the number, so which one is read cannot
change an angle. They differ on the frame (relative to the parent against fixed in the
rocket). Even so, the angle is the same for every parent HPR Sim builds. All of them sit on the
rocket’s own axis. A pod set hangs from a body tube, which is on the axis too. OpenRocket 24.12
puts its pods in the same places whichever of its three frame words the file writes (relative,
fixed, or mirror_xy, mirrored) (Pods). Whether a part inside a pod measures its angle
from the pod or from the rocket has not been tested against OpenRocket.
Which direction the angle turns is assumed, and is not settled. HPR Sim measures a roll angle from toward , right-handed about , which points at the nose (frames) (evidence row G16). OpenRocket’s technical documentation (§3.1.4) puts its own axis along the centerline pointing aft, and says nothing about the other two. A right-handed angle about an aft-pointing axis is a left-handed one about HPR Sim’s . If that is what OpenRocket means, every angle read here is mirrored. A mass object at 90° sits on the other side of the airframe, and a canted fin set rolls the other way. Nothing in the reference library can settle it, because a mirrored design is still a perfectly valid design. One deliberately asymmetric design put through the OpenRocket oracle will. Until then HPR Sim takes the number unchanged, and this is on the list of readings that are not settled.
An override that covers the parts inside a component is read from the mass flag. A .ork says
“this figure covers the components inside this one”. It says it once for the mass, once for the
center of gravity and once for the drag. hpr-design says it once for the whole component, so
the two cannot always agree. Mass is the quantity the flag is written for: 95 of the 104 written in the corpus
are the mass flag. So the mass flag decides. A center-of-gravity flag that disagrees with it
raises a warning. Nothing in the corpus disagrees. This matters from this milestone on and not
before: until a component had parts inside it, “covers the parts inside” covered nothing.
What a part takes from its parent is resolved by Rocket::layout(), never here. A coupler’s or
a ring’s automatic outer radius is its parent’s bore. Inside a nose cone or a transition, that is
the bore at the part’s narrower end (below). A ring’s
automatic bore is the widest motor tube beside it that overlaps it along the axis. A packed part
fills the room left in the bore.
Automatic outer radii resolve in a pass before any ring’s automatic bore. So a ring’s
answer cannot depend on whether the tube inside it was written first. In Loft, which resolved as it
walked, a bulkhead inside a coupler stayed NaN (not a number: no numeric value was available).
That is Loft lesson L60.
Inside a nose cone or a transition
A coupler, an engine block or a ring can sit inside a hollow nose cone or transition, with its outer
radius written auto. A nose’s bore narrows toward the tip, so “the parent’s bore” needs a place
along the nose. Since M2.2e7 HPR Sim takes it where OpenRocket
24.12 does (ADR-096, the decision on fillets and a nose’s bore):
- The radius is the parent’s outer radius at the part’s narrower end, less the parent’s wall. The nose’s shoulder is left out, even when the part reaches into it.
- If the wall is thicker than that radius, the radius is zero.
- A filled (solid) nose cone has no bore. The part is left out with a
Skippedwarning. - A packed part (a parachute, a mass component) inside a nose cone still takes no automatic radius.
It is left out with a
Skippedwarning too. - A coupler at the very tip, where the wall meets the axis, has no radius at all. OpenRocket weighs it as nothing; HPR Sim refuses to lay out the design.
- A tube whose own wall is thicker than the automatic radius it gets is a solid rod. This holds in a body tube too, and is here because two of the probes below measure it, one in each.
For example, take a conical nose cone 200 mm (7.9 in) long and 50 mm (2.0 in) in radius at its base. Its wall is 2 mm (0.079 in). A coupler 30 mm (1.2 in) long has its aft end at the nose’s base. The coupler’s narrower end is its forward end, 30 mm (1.2 in) ahead of the base, where the cone’s radius is . So its outer radius is .
An inner tube written auto keeps 9.5 mm (0.37 in). OpenRocket 24.12 does not work out an automatic
radius for an innertube, the tag a motor mount is usually written with. It keeps the 9.5 mm (0.37 in) it
starts with, in a nose cone or a body tube alike. HPR Sim reads it the same way, with no warning, so
a design holding one flies as OpenRocket flies it. A tubecoupler
or an engineblock written auto fills its parent as above.
Measured. Fourteen probe designs in validation/oracles/openrocket/conventions.py ask
OpenRocket these questions. Ten hold a coupler of automatic radius. Two hold it at a nose’s
bottom, in a plain and in an ogive nose. Two hold it past a nose’s base, with and without a
shoulder. One holds a long coupler from a nose’s middle, and one holds it at the tip. Two hold one
whose wall is thicker than its bore, in a nose and in a tube. One holds a mass inside it, and
one is in a transition. Of the other four, one holds an engine block, and one a centering ring and
a bulkhead. Two hold an inner tube written auto, in a nose and in a tube. HPR Sim flies 13 of the
14. Every part inside a nose cone, transition or tube but one weighs OpenRocket’s mass at
OpenRocket’s station. The test holds the mass to 1e-14 and the station to 1e-15. Three things are
pinned apart:
- One mass component, packed with an automatic radius inside the coupler, sits 20.75 mm (0.82 in) from OpenRocket’s. OpenRocket shortens its packed length to keep its volume, and HPR Sim keeps the written length (#186: OpenRocket repacks a part that does not fit).
- The nose cones’ and the transition’s own walls keep the gaps they already had. These are up to 3.93e-5 of the mass and 2.5e-6 m in the center. The ogive’s 3.93e-5 has no traced cause; the test holds all three to 5e-5 of mass. The transition’s 2.85e-6 is the sliver OpenRocket’s square-cut end adds (Nose cones, transitions and solids of revolution).
- The coupler at the tip is the 14th probe. HPR Sim refuses it, and OpenRocket weighs it as nothing.
The test an_automatic_radius_inside_a_nose_reads_as_openrocket_does in hpr-validate holds
HPR Sim to these answers. Before, HPR Sim had no bore to give such a part, so it left the part out
with a warning. A design holding one did not fly.
Tube fins sized from the body
A tube fin set is a ring of short open tubes glued along the airframe in place of flat fins. In
OpenRocket, a tube fin set’s radius can be written auto. OpenRocket then sizes the tubes from
the body tube they sit on. Since M2.2e8 HPR Sim works that
radius out as OpenRocket 24.12 does (the decision on a tube fin set’s automatic
radius). Before, HPR Sim left such a set out with a Skipped warning
(#133). HPR Sim reads and weighs tube fins now, and since
M2.2e9 a design that holds them flies
(below).
The rule. With three tubes or more, each tube touches the body and its two neighbors, so the ring closes:
-
The tubes’ axes sit on a circle of radius around the airframe’s axis. Here is the body tube’s outer radius and the tubes’ radius.
-
Neighboring axes are apart around that circle, for tubes, so the straight line between them (the chord) is long.
-
Two tubes of radius touch when their axes are apart. Setting the chord to gives
One or two tubes can’t close a ring. For those, OpenRocket gives the tubes the body’s radius, and
so does HPR Sim. The rule is
TubeFinSet::closing_radius_m.
HPR Sim applies it when it lays the design out, the step that works out every automatic dimension
(Automatic dimensions).
For example, take four tubes on a body of 50 mm (2.0 in) radius. is 0.7071, so . The axes then sit 170.7 mm (6.7 in) from the airframe’s axis, and neighbors are apart, which is : they touch. Fewer tubes must be wider to close the ring. Three to five tubes come out wider than the body, six exactly as wide, and more than six narrower:
| tubes on a 50 mm (2.0 in) body | radius |
|---|---|
| 1 or 2 | 50 mm (2.0 in), the body’s |
| 3 | 323.2 mm (13 in) |
| 4 | 120.7 mm (4.8 in) |
| 5 | 71.3 mm (2.8 in) |
| 6 | 50.0 mm (2.0 in), as wide as the body |
| 8 | 31.0 mm (1.2 in) |
Three more things are read as OpenRocket reads them:
- A wall thicker than the radius is cut to the radius, so the tubes are solid rods. OpenRocket weighs them that way, as it does an inner tube’s (above).
- More than 8 tubes are read as 8, with a
Droppedwarning, whether the radius isautoor stated. OpenRocket 24.12 reads 9, 12, 20 and 100 tubes as 8. HPR Sim caps the count before it checks its own limit of 64 parts in a row. So 100 tubes read as 8 rather than being refused. That cap is OpenRocket’s reading of the file, not a limit of the physics: HPR Sim’s own design files take any count. - A radial offset (tubes standing off the body) changes none of OpenRocket’s numbers. HPR Sim
reads such a set sitting on the body, with a
Droppedwarning, as it did before.
Measured. Nineteen probe designs, small designs made only to ask
OpenRocket one question each, are in validation/oracles/openrocket/conventions.py. Each carries
one tube fin set:
- on a 50 mm (2.0 in) tube:
autosets of 1, 2, 3, 4, 5, 6, 8, 9, 12, 20 and 100 tubes;- six tubes of a stated 20 mm (0.79 in) radius, with and without a 10 mm (0.39 in) radial offset;
- twelve tubes of a stated radius;
- six
autotubes with a wall thicker than their radius; - four
autotubes on a tube whose own radius isauto, taken from the nose cone ahead of it;
- on a 20 mm (0.79 in) tube: 1, 2 and 5
autotubes. One and two take the body’s 20 mm (0.79 in); five take the closed form’s 28.5 mm (1.1 in).
OpenRocket’s answers are in validation/fixtures/ork/openrocket-conventions.json. The test
a_tube_fin_sets_automatic_radius_reads_as_openrocket_does in hpr-validate holds HPR Sim to them:
| quantity | HPR Sim against OpenRocket, on all 19 |
|---|---|
| the tubes’ radius and wall | within 1e-15, relative, in the test (equal when the oracle script compares them in Python) |
| the number of tubes | the same |
| each part’s mass | within 1e-14, relative; the one nose cone, on the probe whose tube takes its radius from it, within 5e-5, the gap nose walls already had (above) |
| each part’s center of mass, along the airframe | within 1e-15 m; that nose cone within 5e-6 m |
OpenRocket’s Tube fin rocket example is the only design in the reference library with tube fins, in two copies. It now reads with its tube fins. Its mass is within 5.0e-6 of OpenRocket’s, and its center of mass is within 2.4e-6 of its length (Mass properties).
What differs: the roll and pitch inertia. HPR Sim keeps its own figure for both, each a departure: a difference kept on purpose, measured and pinned by the same test.
- Roll (spin about the airframe’s axis). For two tubes or more, OpenRocket’s roll inertia for the set is larger than any mass inside the ring could have. For a single tube the two agree.
- Pitch (turning end over end). OpenRocket’s figure has no term for how far the tubes sit from the airframe’s axis. Per kilogram, it is the number of tubes times one tube’s own figure about its own middle. On the probes it is 1.3 to 2.6 times HPR Sim’s. Some mass inside the ring could have that much, but not tubes where both programs put them.
Mass properties has the numbers. On the Tube fin rocket, HPR Sim’s roll inertia is 98.7% below OpenRocket’s. Its pitch inertia is 1.98% below, almost all of it OpenRocket’s pitch rule.
How they fly. Since M2.2e9, HPR Sim has tube fin aerodynamics, and a design with tube fins flies. Its aerodynamics takes each tube as a ring wing. It uses a cited slope, a center from Fletcher’s measurements and HPR Sim’s own derivation, and drag from the fin rules (Tube fins). The Tube fin rocket’s apogee is 6.95% above OpenRocket’s. On OpenRocket’s own drag, HPR Sim’s apogee is within 0.03%, so the net gap is the drag’s (tube fins flown as ring wings). OpenRocket’s tube-fin drag was refined against measured flights, so HPR Sim’s probably reads low (#228).
The surface finish
A surface finish is a roughness height : the size of the bumps a painted or bare surface leaves. It sets skin friction (drag). OpenRocket writes one of five words for it. What each is worth in micrometers is not in the file format documentation. These are the only numbers on this page that come from neither the documentation nor the corpus:
<finish> | OpenRocket calls it | roughness | where that number comes from | components in the corpus |
|---|---|---|---|---|
rough | Rough | 500 µm | the author | 8 |
unfinished | Unfinished | 150 µm | the author | 2 |
normal | Regular paint | 60 µm | technical documentation §6 and the user guide’s dialog | 348 |
smooth | Smooth paint | 20 µm | the author | 88 |
polished | Polished | 2 µm | the author; see the caveat below | 14 |
Only the default is officially documented, and it twice over. Section 6 of the technical documentation describes its test design. It says “the ‘regular paint’ finish was selected, which corresponds to an average surface roughness of 60 µm”. The user guide’s body-tube dialog reads “Component finish: Regular paint (2.36 mil)”, which is 59.9 µm. The user guide gives no numbers. It names all five and their order: “Rough, Unfinished, Regular paint, Smooth paint, and Polished, each with a decreasing (CD) from rough to polished”. The other four come from OpenRocket’s author, in post #6 (22 August 2013) of The Rocketry Forum thread “Open Rocket Finishes”. The post reads: “Rough (500 µm) / Unfinished (150 µm) / Regular paint (60 µm) / Smooth paint (20 µm) / Polished (2 µm)”.
Each becomes a Finish::Custom height (a roughness given as a number), not one of
HPR Sim’s named finishes. Those names (“raw wood”, “dip-galvanized metal”) mean other surfaces that
happen to share a height.
polished is the one to doubt. Its 2 µm rests on a 2013 forum post and on nothing else. The
number also sits oddly. In the table the OpenRocket technical documentation itself
reprints (Table 3.2, from Hoerner), 2 µm is aircraft-type sheet metal. In that table
“finished and polished surface” is 0.5 µm. So OpenRocket’s “Polished” is not the row its name
points at, and a later version could reasonably have moved it. Rocketry-forum posts from 2023
onward list nine finishes rather than five. That suggests the list has indeed changed, though
neither the 23.09 nor the 24.12 release notes mention it.
What it would cost: skin friction in the fully-rough branch goes as
(drag). So 0.5 µm instead of 2 µm is a 1.32× change in the
skin-friction coefficient of whatever part says polished. In the corpus that is 14
components. No file in the
corpus writes any word but the five, so nothing here can settle it; the
OpenRocket oracle can. A word HPR Sim has no sourced roughness
for is read as OpenRocket reads it, regular paint on an outside part, and a warning says so.
A part with no <finish> is read as OpenRocket reads it. On the outside (a nose cone, body
tube, transition, fin set, tube fin set, launch lug or rail button) it is regular paint, 60 µm.
Inside the body (an inner tube, coupler, ring, bulkhead, mass, parachute or shock cord) it has no
finish, as in OpenRocket. With every finish taken out of its 17 example designs, or gilt put in
each, OpenRocket 24.12 reads all 134 outside parts so
(finish.py,
#216). Before, HPR Sim gave such a
part 20 µm and flew the pod probes 6.0% to 7.3% high. The 60 µm is OpenRocket’s choice, not a
measured finish: painted and sanded surfaces measure smoother
(hobby finishes).
HPR Sim reads it so that the two programs agree. When HPR Sim writes a file, an outside part at
its 20 µm default is written smooth; a finish none of the five words fits is left out with a
warning, and OpenRocket reads that part as 60 µm.
Clusters
An inner tube can be a cluster: several like tubes side by side, each
holding a motor. The file names a pattern in clusterconfiguration, spreads it with
clusterscale (1 unless written) and turns it with clusterrotation (degrees, as every .ork
angle). HPR Sim reads every tube into the inner tube’s list of places,
cluster_m, and the
motor in it becomes one motor per tube (Clusters).
No published document gives the patterns, so OpenRocket 24.12 was asked, run as an outside program
through its public interface (validation/oracles/openrocket/clusters.py, ADR-075).
Each pattern is a figure of points , one per tube, in units of (defined below):
| pattern | tube count | figure |
|---|---|---|
single | 1 | one tube |
double, 3-row, 4-row | 2 to 4 | a row, one apart |
3-ring, 4-ring, 5-ring | 3 to 5 | a triangle, a square, a pentagon, each of side one |
6-ring | 6 | a hexagon of side one |
3-star, 4-star, 5-star, 6-star | 4 to 7 | a center tube and a ring of radius one |
9-grid | 9 | a 3 × 3 grid, 1.4 apart |
9-star | 9 | a center tube and eight on a ring of radius 1.4 |
The unit is , for the tube’s outer radius and the scale . At scale 1 neighboring
tubes touch, except in 9-grid and 9-star. The rows and columns of 9-grid are 1.4 diameters
apart, and the ring of 9-star is 1.4 diameters from its center tube. The pattern is
turned by the tube’s roll angle less the rotation ( turns a point by that angle):
measured from the tube’s own radial offset. For example, a 3-ring of 40 mm (1.6 in) tubes at scale 1 puts
the three axes 23.09 mm (0.91 in) from the center (). OpenRocket’s are read as HPR Sim’s
, the same assumption as for every roll angle (above).
HPR Sim was checked on 25 probes: every pattern, a scale, a rotation, a radial offset, and all
three at once. It puts every tube within 1e-15 m of where OpenRocket does (the test
every_tube_of_a_cluster_is_where_openrocket_puts_it in hpr-validate). A pattern name OpenRocket
doesn’t know (4-square), it reads as one tube; so does HPR Sim, with a warning.
A cluster’s mass and center of mass agree with OpenRocket’s. Its inertia does not: OpenRocket weighs the tubes as if stacked on the cluster’s axis, and HPR Sim weighs each where it sits (Mass properties). Two more readings differ from what a builder would expect:
- A centering ring with an automatic bore beside a cluster takes one tube’s radius as its bore, as
OpenRocket gives it. The tubes then run through the ring, and that mass counts twice. Take a
3-ring of 40 mm (1.6 in) tubes in a ring 98 mm (3.9 in) across. The ring weighs about two thirds
more than one with three holes would. The design checks warn of it (
ring_overlaps_inner_tube). - A part inside an inner tube set off the body’s axis is read at its own offset from the body’s
axis. No parent’s offset is added. OpenRocket places it from the tube’s axis. An engine block
in a tube 10 mm (0.39 in) off the axis sits on that tube’s axis in OpenRocket. In HPR Sim it
sits on the body’s axis. The simulator warns of it (
Unusual), and no file in the survey has one (#181). A cluster on the axis, the common case, is not affected. Neither is a motor in a mount that sits in the body tube, whose nozzle takes its mount’s offset.
A configuration with a motor in a cluster flies with one motor in every tube. OpenRocket’s Clustered motors example has four motors in a 4-ring. On it, all five configurations are within 1% of OpenRocket’s apogee and largest speed, with the parachute-opening cause removed (HPR Sim’s flights against OpenRocket’s). The milestone for this check set a 5% bar before measuring.
Pods
A pod set hangs pods beside a body tube. Each pod is the stack of nose
cones, body tubes and transitions written inside the podset, with everything on and in them.
instancecount of them are spaced evenly around the axis. HPR Sim reads it into a
PodSet (M1.13b). The first pod’s roll angle is
angleoffset, read as every angle is (which way round). Pods fly from
M1.13c1, each pod’s parts with their own normal force and
drag (aerodynamics: Pods).
Five probe designs with pods fly within 0.92% of OpenRocket’s apogee, and so does the same airframe without pods (a pod design against OpenRocket). The pods hold bodies, fins, a tail cone, winglets and motors. The probes are listed apart from the designs, at the end of the report.
The one private design with pods, C02, has only a launch lug on each. So its flights, within
2.2% of OpenRocket’s apogee
(HPR Sim’s flights of the private designs), check
the pods’ placement and weight, not their aerodynamics. Of OpenRocket’s own two pod examples,
Pods--airframes and winglets flies since M4.5g4, the
milestone that reads its cockpit fin on the nose cone. Pods--powered with recovery deployment
flies since M4.5i. That milestone weighs its rail buttons’
screw heads and flies motors in more than one pod set (the decision behind it). Its
flights are below.
How far from the axis depends on the method written on radiusoffset, and no document says
how. OpenRocket 24.12 was asked, as an outside oracle, on probe designs
(validation/oracles/openrocket/pods.py, eighteen of them). It puts each pod’s axis at this
distance from the body’s (OpenRocket’s own names for the methods in brackets):
radiusoffset method | distance | tube 50 mm (2.0 in) in radius, pods 10 mm (0.39 in) in radius, number 20 mm (0.79 in) |
|---|---|---|
relative (“surface of the parent component”) | tube radius + pod radius + the number | 80 mm (3.1 in) |
surface (“… without offset”) | tube radius + pod radius; the number is ignored | 60 mm (2.4 in) |
free (“center of the parent component”) | the number, from the axis | 20 mm (0.79 in), inside the tube |
The pod radius is the widest of the pod’s own parts. One probe has a stated 10 mm (0.39 in)
nose. Its three tubes are 10 mm (0.39 in), 15 mm (0.59 in) and 10 mm (0.39 in). OpenRocket
puts the pod at the 15 mm (0.59 in) radius. That is not the first part’s, the first tube’s or the
last part’s. HPR Sim’s test
(every_pod_is_where_openrocket_puts_it, in hpr-validate) holds every part in every pod to
OpenRocket’s place, to . An automatic radius inside a pod can only take a radius stated in
the pod, so HPR Sim takes the widest stated one.
HPR Sim fixes each pod’s distance when it reads the file, so it cannot work out an automatic tube
radius later. When the tube’s radius is automatic, HPR Sim uses the number OpenRocket cached for it
and warns that it did. With nothing cached, the pod set is left out. A method HPR Sim does not know
is read as relative, and a missing radiusoffset as touching the tube, each with a warning.
A pod of no length. OpenRocket’s own example Pods--airframes and winglets hangs its winglets from a pod. The pod’s only part is a tube of no length, no wall and, usually, no radius. OpenRocket names that tube “(phantom body)”. HPR Sim reads such a pod as written:
- The tube weighs nothing.
- The pod’s radius is the tube’s, usually 0. The distance table above applies with it: for
relative, the pod’s axis is the body tube’s radius plus the number out. - Fins and a launch lug on the tube sit on its surface, as on any tube. With a radius of 0 that is the pod’s own axis. The fins’ roots meet there, and a lug’s axis is the lug’s own radius out from it, at the lug’s angle. A lug 3 mm (0.12 in) in radius sits on a pod 62 mm (2.4 in) from the axis, turned to 180°. Its axis is 59 mm (2.3 in) from the body’s.
- Everything turns with its pod, as in any pod.
- A tube of no length has no room inside and no wall. A pod set whose tube of no length holds a part inside it is left out, with a warning. A fin tab deeper than the tube’s radius is dropped, also with a warning, and the fins are read without it.
OpenRocket 24.12 agrees on six probes:
- two fins at 90° on a tube of no radius;
- three fins on each of two pods, on a tube of no radius;
- two fins on a tube 10 mm (0.39 in) in radius;
- two pods at 30° on a tube 10 mm (0.39 in) in radius, three fins each at 20°, showing each fin turned with its pod;
- a lug turned to 180°, and two at 0°.
Each fin’s root and each lug’s axis is where OpenRocket puts it, to (the test
every_pod_is_where_openrocket_puts_it, in hpr-validate).
A pod set that holds nothing is read too, and weighs nothing, in OpenRocket as in HPR Sim. A mass override on one is dropped, with a warning. OpenRocket 24.12 puts that mass at the rocket’s tip, on its axis, where no design means it to be.
What it weighs. The test pods_weigh_as_openrocket_s, in hpr-validate, compares HPR Sim with
OpenRocket on every probe:
| quantity | how close to OpenRocket |
|---|---|
| each tube, fin set and lug in a pod: mass and center | 2 parts in |
| a pod’s nose cone: mass, center | 8.3 parts in , 4.0 parts in |
| the whole rocket: mass | 1.2 parts in |
| the whole rocket: center of mass | 1.10 parts in with pods that have a length, 1.13 parts in with pods of no length |
| roll inertia, with OpenRocket’s fin shortcut in place of HPR Sim’s | 2 parts in |
| pitch inertia about , with no fins in the pods | 6.1 parts in |
OpenRocket weighs a nose cone a little differently from HPR Sim. The probes’ own nose, on the airframe, is 5.1 parts in apart in mass. That alone puts the bare airframe 1.17 parts in from OpenRocket’s. No probe with pods is further from OpenRocket than that.
HPR Sim works out a fin’s roll inertia exactly, and OpenRocket takes a shortcut. The two differ by up to 5% on a fin set (mass: fins). The 2 parts in holds only once OpenRocket’s shortcut is swapped in for HPR Sim’s (why fin roll inertia differs). OpenRocket’s rule for a fin’s pitch inertia is not known. So where the pods hold fins the pitch gap is only pinned: 2.6 parts in to 3.4 parts in .
OpenRocket gives one pitch inertia for both pitch axes. With one or two pods the rocket is not the same both ways. So HPR Sim’s inertia about differs from that one number, by 0.3% to 1.1% on the probes of pods that have a length (M1.13b1). HPR Sim’s is the true inertia about that axis. With three pods the two agree.
A flipped nose cone, anywhere in a design, is a tail cone. HPR Sim reads it as one: a transition from the nose’s base radius to a point. Its base is forward, so an automatic radius takes the part ahead of it. With one end a point, a clipped and an unclipped transition are the same whole nose shape (shapes). The only one in the corpus closes a pod.
Left out, with a reason. A pod set is left out with a Skipped warning when HPR Sim cannot lay
it out, in any of these cases:
- a pod holds a nose cone or transition of no length, or a part of negative length;
- a pod’s tube of no length holds a part inside it;
- its pods’ radii are all automatic;
- the tube’s radius is automatic with nothing cached;
- the distance comes out negative;
- it hangs from anything but a body tube;
- it sits inside a pod.
The corpus has none of these. A part directly inside a pod set that is not a nose cone, body tube or transition is left out on its own. An override on a pod set is its pods’ total, since a pod set weighs nothing of its own.
cargo xtask ork counts them. On the corpus, September 27, 2026:
| pod sets | count |
|---|---|
| written | 9 |
read into PodSet | 9, holding 12 pods |
| left out | 0 |
cargo xtask ork on September 27, 2026 also weighs each design against OpenRocket 24.12:
- Pods--powered with recovery deployment (a public example): its mass is now within 1% of OpenRocket’s. It was 12.5% light with its pods left out (M1.13b1).
- Pods--airframes and winglets: with its winglet pod left out, its roll inertia was 1.78% below
OpenRocket’s, even with OpenRocket’s fin shortcut. With the pod read, it is no longer among the
designs
cargo xtask orklists outside 1% with that shortcut. Its freeform cockpit, on the nose cone, is read since M4.5g4 (Fins on a nose cone or a transition).
Parallel stages
A <parallelstage> inside a body tube, on a rocket of one stage on the axis, is read as a stage
of its own. It is laid out as a pod set on that tube. OpenRocket uses a parallel stage for
boosters strapped beside the core. HPR Sim reads it since M4.5m
(a parallel stage is a pod set that separates). Its copies sit as a pod set’s pods do
(Pods). They number instancecount, sit radiusoffset from the axis, and the first is at
angleoffset, at its axial position along the tube. Its parts weigh to its own stage, not to the
tube’s, and its own separationevent drops it, read as an axial stage’s is. Its mass and center
of gravity overrides are read as a stage’s too, not as a pod set’s
(A stage’s mass and center of gravity overrides).
The design’s side is in Parallel stages, and the flight’s in Boosters beside the core. When its motors light, and why one with no motor that lights stays on, is in Delays and ignition. The writer puts a parallel stage it read back inside its tube.
Left out, with a Skipped warning naming the reason. HPR Sim leaves out a parallel stage:
- on a rocket of more than one stage on the axis. OpenRocket numbers the parallel stages among the axial ones, and no example or library design has one to check a reading against;
- inside a pod or another parallel stage;
- with no nose cone, body tube or transition in it;
- placed
afterthe part before it, since a parallel stage sits along its tube; - in any case where a pod set would be left out (Pods).
One written directly under <rocket>, as in Loft’s demo-quirks.ork, is not read there, and
stays in the tally of tags HPR Sim does not read. OpenRocket 24.12 refuses to open that file. Every
parallel stage left out is kept whole for writing the file back
(what HPR Sim keeps).
Measured. OpenRocket’s Parallel booster staging example flies both its configurations as
saved. They are flown under OpenRocket’s stored conditions, with recovery as saved
(the report).
A configuration is named by its motors, stage by stage with the sustainer first, the stages
separated by ;. For example, [I115W-10; 2× E12-0] is an I115W-10 in the core above two E12-0s in
the boosters, and None is a stage with no motor.
| configuration | apogee, OpenRocket / HPR Sim (m) | apogee | largest speed |
|---|---|---|---|
[I115W-10; 2× E12-0] | 1,123.6 / 1,137.5 | +1.23% | +3.25% |
[I115W-10; None] | 851.8 / 857.6 | +0.68% | +1.56% |
In the first, the boosters drop at 2.44 s, at the E12s’ charge, as in OpenRocket. In the second,
they hold no motor and stay on. The survey’s only other parallel stages are the library’s copy of
the same example and demo-quirks.ork’s.
What is left out, and why
A part HPR Sim cannot give an honest shape is left out with a Skipped warning, not guessed at.
The warning names the part and the reason. The design still opens and still lays out; what is
missing is named, never silent. No part in the whole corpus is left out now, under these rules:
| rule | in the corpus |
|---|---|
| an external part other than a fin set on anything but a body tube: a lug’s or a button’s footing on a nose cone is not a straight line | none |
| a fin set on a nose cone or a transition whose root can’t be read along the surface (below) | none; the 2 fin sets it caught, the cockpit of Pods--airframes and winglets in the jar’s copy and the corpus’s, are read since M4.5g4 |
| a freeform outline on a body tube that does not end on the root, which would have to be closed along a body it never touches | none |
| a part whose automatic radius needs a bore its parent has not got: a filled nose cone, or a packed part inside a nose cone (above) | none; the 1 coupler in a nose cone it caught is read since M2.2e7 |
Another rule left out the 2 tube fin sets whose radius OpenRocket sizes from the body. That held until the milestone on tube fins sized from the body worked that radius out (Tube fins sized from the body).
What a part left out does to the numbers
Most warnings give a direction, not a size; some give none. The directions follow from the physics
below and are tested on invented designs, not real ones. A warning that leaves a part out says what
the part and the parts inside it carried. Then it says which way the rocket’s numbers lean without them,
against the same rocket with them. hpr sim flies none of the file’s configurations once a part is
left out (which configurations fly). So the leans matter where
the rocket is still used: the library, the Python package, and a design hpr convert writes.
What a part carried counts everything inside it too, so a pod set holding a parachute says both its lift and its canopy:
| carried | by | which way the numbers lean without it |
|---|---|---|
| mass | every part but a pod set or a parallel stage, whose parts carry it | the mass reads low |
| drag | a nose cone, body tube, transition, fin set, tube fin set, launch lug or rail button | the drag reads low |
| lift | a nose cone, body tube, transition, fin set or tube fin set | the stability margin can read high or low |
| mass, and no lift | a launch lug, a rail button, a parachute, a streamer, or a part inside the body: a tube, coupler, engine block, ring, bulkhead, mass component, shock cord or fin tab | the stability margin reads high for a part aft of the center of gravity, low for one ahead |
| drag under canopy | a parachute or a streamer | the descent rate reads high if it opens in flight, low if it doesn’t |
A tag HPR Sim doesn’t read may carry mass, drag or lift, so its warning says the mass and the drag can read low. It names the descent rate only when a parachute or a streamer is written inside it.
A part’s mass and drag are never negative, so without them both read low. A canopy that opens sets the descent rate, so without it the rocket falls faster. One that never opens carried only mass, and a lighter rocket falls slower. Take away a part of mass at station , with the rocket’s mass with the part. The center of gravity moves away from where the part sat:
Say a 0.2 kg (7.1 oz) part 1.5 m (4.9 ft) aft of the tip is left out of a 2.0 kg (4.4 lb) rocket whose center of gravity is 1.0 m (3.3 ft) aft of the tip. The center of gravity moves 0.2 × (1.0 − 1.5) / 1.8 = −0.056 m, 56 mm (2.2 in) forward. The margin is , so on a rocket 100 mm (3.9 in) across it reads 0.56 calibers high.
A part with lift moves the center of pressure too. Light fins at the aft end then read the margin low, and the same fins at the front read it high. Heavy fins at the aft end can read it high as well: their mass moves the center of gravity further than their lift moves the center of pressure.
A warning gives no direction for a number that something else in the rocket changes with the part:
- An override above it. OpenRocket can set the mass, center of gravity or drag of a part and everything inside it. A number set that way stays as the override sets it. The warning says so: “The mass and center of gravity stay as the body tube’s override sets them”. An override that sets the mass but not the center of gravity, or the other way round, leaves the margin free to move either way.
- A part sized or placed from it. A centering ring with an automatic bore takes it from the inner tube beside it. Without the tube, the ring closes to a solid disc. A part placed after it moves to follow the part before it instead. In the tests’ invented design, a 100 mm (3.9 in) tube sits aft of the center of gravity between two such rings. Without it the rocket weighs 89.6 g (3.16 oz) instead of 87.7 g (3.09 oz), and the margin reads 5.38 calibers instead of 5.48. That’s low, where a tube alone aft of the center of gravity reads it high. So the warning says “The mass and stability margin can read high or low, as parts sized from it change too”. In another, a heavy mass placed after a tube in the nose slides to the tip without it, and the margin reads high, where a tube alone ahead of the center of gravity reads it low.
The tests in
crates/hpr/src/tests/left_out.rs
read one invented design with each kind of part, then with it left out. They check each lean and
the warning’s words.
Some warnings give no lean at all. A part written as none of itself, such as a fin set of none, has nothing to count. Neither has an empty pod set. Their warnings say no number depends on them. An override on a pod set that holds nothing is left out, and the pod set’s own figures are used: no mass and no drag.
Fins on a nose cone or a transition
This covers how HPR Sim reads a fin set that sits on a nose cone or a transition. There the body’s surface is not level along the fin’s root (the edge where the fin meets the body). This reading is checked on one fin on one design, against OpenRocket only, and no measured flight checks it.
OpenRocket gives a fin’s outline as points : aft of the root’s leading edge and
out from the body’s surface there. The root runs along the surface. On a body tube the surface is
a straight line at ; on a nose cone it curves. The cockpit of OpenRocket’s Pods--airframes
and winglets is a single fin on the last 50 mm (2.0 in) of a
tangent ogive nose. Its outline is (0, 0), (9.35, 6.96) and
(50, 2.23) mm. The last point is 2.23 mm (0.088 in) up. That is because the ogive’s surface rises
2.23 mm (0.088 in) over those 50 mm (2.0 in).
HPR Sim reads such a fin as it is written (the decision on fins on a nose cone):
- The outline is kept as written. The root is drawn through 63 points on the parent’s profile
between its ends, 64 straight pieces in all. On the cockpit each piece sits at most 0.14 µm
inside the curve (
a_root_along_a_nose_cone_stays_within_its_documented_sag). - The fin’s heights are measured from the radius at its root leading edge. That radius is also the body radius for its mass and its fin-body interference.
- The design’s layout checks that every root point is within a micron of the surface. It also checks that the straight pieces between them cut off or add no more than 0.1% of the fin’s area.
How well it matches. Through OpenRocket’s own 21 root points, HPR Sim’s area, mass and center of
mass for the cockpit are OpenRocket’s (1.44954e-4 m², 0.172 g). They agree to the six digits
OpenRocket printed (a_root_along_a_nose_cone_is_openrockets). HPR Sim’s 64 pieces give 0.029% less
area, nearer the curve. Closed straight along its chord instead, the cockpit would have 12.8% more
area than the file’s. All five configurations of the example fly in hpr sim as saved. Its
centering rings wrap its 18 mm motor tube and fit the airframe around it (a ring around its
tube):
| configuration | OpenRocket’s apogee (m) | HPR Sim’s (m) | difference |
|---|---|---|---|
| [A8-3] | 32.3 | 32.3 | −0.13% |
| [B6-4] | 90.5 | 90.7 | +0.18% |
| [C6-5] | 199.7 | 200.7 | +0.48% |
| [C12-6] | 207.5 | 207.7 | +0.10% |
| [D16-6] | 245.7 | 246.0 | +0.10% |
These come from the committed comparison (HPR Sim’s flights against OpenRocket’s). The cockpit’s drag counts: without it the [C6-5] would reach 204.4 m (671 ft).
What disagrees.
- Stability margin. As the rocket leaves the rod, HPR Sim’s margin is 0.071 to 0.076 calibers above OpenRocket’s on all five configurations. That is the flattering side, and it does not come from the cockpit. At the margin’s wind direction the single fin lies in the airflow’s plane, and neither code counts it. Probes put it on two older departures:
- Cockpit normal force. Across the airflow, the cockpit’s own normal force is 31.5% above OpenRocket’s (0.2784 against 0.2117 per radian at Mach 0.3). The cockpit’s center of pressure is 0.13 mm (0.0051 in) from OpenRocket’s. The curved root isn’t the cause (#326). HPR Sim’s larger cockpit normal force acts forward of the center of mass. So it shortens HPR Sim’s margin against OpenRocket’s, the safe side.
A fin set there is left out, with its reason, when:
- it is trapezoidal or elliptical (HPR Sim reads the root along the surface only from a freeform outline);
- it carries a tab or a fillet, whose models take a body tube;
- it is placed after a sibling or at an absolute station, where the reader can’t find the surface;
- the body’s radius is automatic, which the layout settles only after the reader draws the root;
- its root runs past the body’s ends;
- its outline ends off the surface;
- the body narrows along its root (a boattail).
A design built in code that puts such a fin on a nose cone gets the same checks from the layout.
They come as a DesignError::Geometry, where the reader leaves the fin out with a warning. On a
body tube an outline that ends off the root is still left out. Writing the design back, HPR Sim
writes the outline alone, as OpenRocket does. So a root drawn through other points than the reader’s
comes back through the reader’s.
One more thing is read as the simpler part HPR Sim models: a row of more than one ring read as one. A warning makes what is missing from a mass visible. It is a measured departure, not a silent compatibility claim (the decision on visible departures). A rail button’s screw head was another until the screw head was weighed (Mass properties; its decision record). A cluster of motor tubes was a third until every tube was read (above). A fin’s fillets were another until they were weighed as OpenRocket does (Mass properties).
A tube of no wall thickness carries no mass, among them couplers in two of OpenRocket’s own
example designs. Reading those as solid would invent the mass. A solid coupler filling a 50 mm (2.0 in) airframe for 180 mm (7.1 in) is a few hundred grams the design never had. Since
the milestone on what a .ork leaves unsaid, the rule holds
for every part, and it is not warned of. OpenRocket 24.12 gives an inner tube, coupler, lug, nose
cone, transition, body tube or shoulder of no wall no mass either. That was measured on probe
designs (the decision on what a .ork leaves unsaid). A solid body component is written
<thickness>filled</thickness>. An inner tube, coupler or lug that writes no thickness at all is
still read as no wall, with a warning. OpenRocket gives it a wall of its own, and no file in the
library has one (Mass properties).
Checked against the answers OpenRocket cached
auto 0.0125 is more than a flag. The number is what OpenRocket itself last worked out (in
OpenRocket 24.12, at least; older releases may differ, as the note below explains). That makes an
oracle for the resolution rules that needs no OpenRocket. cargo xtask ork runs it over the corpus.
It covers every automatic dimension that caches a number and sits on a component the file gives an
<id>. On September 27, 2026, with pods read, 71 of 75 agree to a part in . The 4 added since
September 23, 2026 are the pods’ nose cones, and all 4 agree. Of the 4 that disagree, the 2 body radii are
settled in HPR Sim’s favor below. The 2 packed radii follow the bore of
that tube. So they are settled with it by the bore rule, not measured (the oracle reads body radii
only).
What that number is, measured. OpenRocket 24.12 writes the radius it resolved, not the number
it read. A tube that says auto 0.04 and has nothing to take is saved again as auto 0.025. It
also ignores the number when it opens a file (below).
One older statement disagrees. The 2021 change that started writing the number,
OpenRocket PR #998, calls it the “manual
value”, the last one typed in. So a file saved by some release between then and 24.12 may cache a
hand-typed number rather than an answer. Which releases wrote which is not settled. That is one
more reason HPR Sim never reads the number as a radius.
HPR Sim reads the number in one place only: as the wall of a filled tube whose radius is automatic
but reachable. Such a tube has no other number to be solid to, and a warning says so. No file in the
corpus has one. (A tube whose radius takes OpenRocket’s default is solid to that default instead,
below.)
What the oracle does not reach. A cached answer only exists where OpenRocket wrote one. It never
writes one for two of the tags that matter most here. Across the whole corpus, outerradius caches
a number 0 times out of 131 and innerradius 0 out of 80. So the 71 comparisons are all
aftradius, foreradius, radius and packedradius. The two rules this milestone adds are an
inner tube’s automatic outer radius and a ring’s automatic bore. They have no oracle coverage
in these files (the evidence row). They rest on their unit tests and on the
argument for them, until an OpenRocket oracle reads those parts too. The one
below reads body radii only. The rest belongs to
the OpenRocket reference-program milestone. cargo xtask ork
prints the per-tag denominators and names the tags nothing reaches, so the gap is in the report
rather than only here. Since the fin-fillet and inner-tube milestone,
fourteen probe designs run in OpenRocket do reach an inner tube’s automatic outer radius, a ring’s
and a bulkhead’s. They do so inside a nose cone, a transition and a body tube
(above). The library’s own files still cache no such number.
The four cached numbers that disagree (not the four inside a pod) are one body tube and the parachute packed inside it. The parachute’s radius follows the tube’s bore. Both are in OpenRocket’s own “Dual parachute deployment” example, which the corpus holds twice: once inside the jar and once cached beside it. Its spine is a nose cone and four body tubes. The third tube states a radius of 0.028321 m (0.09292 ft). Every automatic radius caches 0.028321 m (0.09292 ft) too, except that the first tube caches 0.025 m (0.082 ft). HPR Sim resolves them all to 0.028321 m (0.09292 ft).
OpenRocket itself settles it, and agrees with HPR Sim. Run on that file (below), OpenRocket 24.12 first reads the first tube as 0.025 m (0.082 ft), its default. Once it works the design out again, as it does when saving, it reads 0.028321 m (0.09292 ft), and writes that. The first reading depends on an unrelated part, the coupler inside the second tube, whose own radius is automatic. The tenth and eleventh rows of the table below are the same small design without and with such a coupler. Only the one with it is first read at the default. So the 0.025 m (0.082 ft) in the file is most likely a first reading that an earlier save wrote out. The probe reads before and after a save, not twice without one. Nothing yet checks which radius OpenRocket’s own simulation uses after a plain open. The OpenRocket reference-program milestone will. HPR Sim is held to the answer OpenRocket settles on.
Held against OpenRocket itself. cargo xtask ork also compares every body radius HPR Sim
resolves with the one OpenRocket 24.12 settles on for the same file. The settled radii are read from
the oracle’s committed results in validation/fixtures/ork/openrocket-automatic-radius.json. The
command prints the result on its line “body radii against OpenRocket 24.12 run on the same file”.
The comparison covers 18 of the 19 files OpenRocket was run on: the 17 examples in its jar, and the
parachute catalog below. OpenRocket refuses the 19th, below. 67 of 67
agree: body radii this time, a different 67 from the cached numbers above. Unlike the cached
answers, this reaches every body radius, fixed or automatic, including the Dual parachute tube.
When an automatic radius has nothing to take
Sometimes a chain of automatic radii has no fixed radius anywhere along it, so the neighbor
rule has nothing to work from. For example, a nose
cone’s base follows the tube behind it, and that tube follows the nose cone. Two designs in the
reference library do this. HPR Sim gives each such radius OpenRocket’s own default, 25 mm (0.98 in), as a fixed radius. It raises a warning at the radius’s tag, naming the radius. A document
whose <rocket> holds nothing at all is not a design, and is reported that way.
If you see that warning, the design has a radius its author never set. OpenRocket 24.12 shows a tube there at 25 mm (0.98 in) too. It shows a nose cone’s base or a transition’s end that looks at another automatic radius at −1 m (−3.3 ft). No shape can have such a radius. Neither is likely to be the rocket that was built. Set the radius in the design (in OpenRocket, untick Automatic and type the diameter) and open it again.
Why 25 mm (0.98 in). OpenRocket’s user guide doesn’t say what happens here. Its issue tracker does:
- A maintainer: “OR returns the default radius” (#1988).
- An open issue: a tube left with nothing to take “reverts to default diameter” (#1992).
- A user reports a nose cone that “may be retaining the default 1.969 in. base diameter” (#871). That is 50.0 mm (2.0 in) across, or 25 mm (0.98 in) of radius. It is a user’s guess, so the number rests on the measurement below.
Since 2021, OpenRocket’s dialogs gray out the checkbox where a radius would have nothing to take (PR #998). Even so, #1988 shows a later version still leaving one ticked. So chains like these come mostly from older or hand-written files.
Measured. validation/oracles/openrocket/automatic_radius.py runs the OpenRocket 24.12 program
on fifteen small designs of its own and records the radius it gives each body component. It
records it twice: when the file is first opened, and once OpenRocket has worked the design out
again, as saving makes it do. The results are committed in
validation/fixtures/ork/openrocket-automatic-radius.json, and the test
hpr_io::ork::tests::a_radius_with_nothing_to_take_is_openrockets_default holds HPR Sim to them.
In the table, radii are listed forward to aft. “30 to 20” is a transition’s forward and aft
radius, and “|” is a stage boundary. OpenRocket’s column is the settled answer. unset is
OpenRocket’s own mark for a radius it hasn’t worked out. OpenRocket stores that mark as a radius of
-1.
| design | what the file says | OpenRocket 24.12 | HPR Sim |
|---|---|---|---|
| a tube | auto | 25 mm (0.98 in) | 25 mm (0.98 in) |
| a tube | auto 0.04 | 25 mm (0.98 in) | 25 mm (0.98 in) |
| two tubes | auto, auto 0.04 | 25, 25 mm (0.98 in) | 25, 25 mm (0.98 in) |
| a nose cone | auto | 25 mm (0.98 in) | 25 mm (0.98 in) |
| a nose cone | auto 0.03 | 25 mm (0.98 in) | 25 mm (0.98 in) |
| a transition | auto 0.03 to auto 0.02 | 25 to 25 mm (0.98 to 0.98 in) | 25 to 25 mm (0.98 to 0.98 in) |
| a nose cone, a tube | auto 0.03, auto 0.03 | unset, 25 mm (0.98 in) | 25, 25 mm (0.98 in) |
| a nose cone, a tube, a transition, a tube | auto 0.033, auto, auto to 22 mm (0.87 in), 22 mm (0.87 in) | unset, 25 mm (0.98 in), unset to 22 mm (0.87 in), 22 mm (0.87 in) | 25, 25, 25 to 22, 22 mm (0.87 in) |
| a nose cone, a tube (the control) | auto, 30 mm (1.2 in) | 30, 30 mm (1.2 in) | 30, 30 mm (1.2 in) |
| a nose cone, two tubes, a tube | auto, auto, auto, 30 mm (1.2 in) | 30, 30, 30, 30 mm (1.2 in) | 30, 30, 30, 30 mm (1.2 in) |
| the same, a coupler of automatic radius in the third component | as above | 30, 30, 30, 30 mm (1.2 in, first read: 30, 25, 30, 30) | 30, 30, 30, 30 mm (1.2 in) |
| a tube, two tubes | 30 mm (1.2 in), auto, auto | 30, 30, 30 mm (1.2 in) | 30, 30, 30 mm (1.2 in) |
| a tube, a transition, a tube | 30 mm (1.2 in), 30 mm (1.2 in) to auto, auto | 30, 30 mm (1.2 in) to unset, 25 mm (0.98 in) | 30, 30 to 25, 25 mm (0.98 in) |
| a nose cone, a transition, a tube | auto, auto to 20 mm (0.79 in), 20 mm (0.79 in) | unset, unset to 20, 20 mm (0.79 in) | 25, 25 to 20, 20 mm (0.79 in) |
| a nose cone, a tube | a tube | auto, auto | 30 mm (1.2 in) | 30, 30 | 30 mm (1.2 in) | 30, 30 | 30 mm (1.2 in) |
What the table shows:
- The number cached after
autois ignored. OpenRocket gives the tube that caches 0.04 m (0.13 ft) 25 mm (0.98 in), and HPR Sim does the same. The cache is an answer OpenRocket once wrote, never an input. - A chain that reaches a fixed radius takes it, in every case probed. That holds with up to two automatic radii in between, and across a stage boundary too, in both programs. The default is only for a chain with nothing fixed on it.
- HPR Sim departs from OpenRocket in one way, on purpose. Where a nose cone’s base or a transition’s end looks at another automatic radius, OpenRocket gives it −1 m (−3.3 ft). No shape can have a negative radius, so HPR Sim gives it 25 mm (0.98 in) too. The chain is then one radius end to end. That is 6 of the 39 radii in the table.
- OpenRocket’s first reading can differ from its answer. With a coupler of automatic radius in the third component, OpenRocket first reads the tube ahead of it at its default. It corrects it to 30 mm (1.2 in) when it works the design out again. That is the Dual parachute example’s cached 25 mm (0.98 in) (above).
Worked example. The eighth row is the chain in Loft’s quirks fixture, on a small copy
the oracle script automatic_radius.py writes itself. It holds a nose cone whose base is automatic
(it caches 0.033 m (0.11 ft)) and an automatic tube. Then comes a transition whose forward end is
automatic and whose aft end is fixed at 22 mm (0.87 in). A 22 mm (0.87 in) tube follows. Each
automatic radius follows another automatic radius. A transition’s two ends never follow each other.
So the fixed 22 mm (0.87 in) stops at the transition, and none of the three ever reaches it. (The
same is why, in the thirteenth row, a transition’s fixed forward end doesn’t reach its automatic aft
end.)
HPR Sim gives all three 25 mm (0.98 in). The nose cone ends at 25 mm (0.98 in) and the tube is 25 mm (0.98 in). The transition narrows from 25 mm (0.98 in) to 22 mm (0.87 in). The cached 0.033 m (0.11 ft) is not used, and three warnings name the tags.
A tube’s wall is judged against the default. A tube whose automatic radius takes the default
has its wall read again, now there is a radius to read it against. The rule is the one a stated
radius gets. A wall that is filled, or at least as thick as 25 mm (0.98 in), is solid to 25 mm
(0.98 in).
The test
a_tube_given_the_default_has_its_wall_judged_against_it holds that.
The three files this settles (cargo xtask ork prints the counts):
| file | what it holds | what happens |
|---|---|---|
Debrief’s sample-design.ork | a <rocket> with a name, a comment and nothing else, plus a stored simulation | holds no design; counted apart, not as a failure. Its stored simulation is read (stored simulations) |
the openrocket-database parachute catalog | four tubes, every radius a bare auto, carrying the catalog’s parachutes | lays out, four tubes at 25 mm (0.98 in), just as OpenRocket 24.12 opens it |
Loft’s demo-quirks.ork | the worked example’s chain, and a parallel stage placed directly under the rocket | lays out as in the worked example. OpenRocket 24.12 will not open this file: it refuses a parallel stage there, so its answers for this chain come from the oracle script’s copy. HPR Sim opens it and skips the parallel stage with a warning: HPR Sim reads a parallel stage only inside a body tube (Parallel stages) |
How it was decided, and the sources quoted in full, are in the decision on an automatic radius with nothing to take.
Measured on the reference library
cargo xtask ork, over the 73 readable files, on October 24, 2026:
designs whose Rocket lays out | 72 of the 72 files that hold a design |
| documents that hold no design | 1, among the 73 readable files |
| automatic radii given OpenRocket’s default, 25 mm (0.98 in) | 7, in 2 designs: 5 on body tubes, 1 on a nose cone, 1 on a transition |
| body radii against OpenRocket 24.12 run on the same file | 67 of 67 agree, over 18 of the 19 files it was run on |
| body components | 274 |
| parts on and inside them | 802 |
| by kind | 198 centering rings, 161 inner tubes, 134 parachutes, 114 fin sets, 82 mass components, 42 shock cords, 28 launch lugs, 16 rail buttons, 9 pod sets, 8 body tubes, 4 nose cones, 2 streamers, 2 transitions, 2 tube fin sets |
| automatic dimensions marked for the layout to resolve | 321, plus the 7 above given the default: 328 in the files |
| parts left out, with a reason | none; 2 before M4.5g4 read a fin set on a nose cone, 4 before M2.2e8 read tube fins sized from the body, 5 before M2.2e7 read a coupler inside a nose cone |
| parts that lay out weighing nothing | 25, every one explained (below) |
| warnings raised | 10: 1 skipped, 9 unusual (what they are, and how many there were before each milestone that cut them) |
| tags no milestone reads yet | none since parallel stages are read (Parallel stages); 3 parallelstage before, and 9 podset too before pods were read (Pods) |
The 25 parts that weigh nothing are worth checking. A structural part with no mass is silent by nature: the design lays out, the report is written, and the mass is missing. All 25 are accounted for:
- 11 are pod sets. A pod set weighs nothing of its own, and a parallel stage is laid out as one (Pods, Parallel stages).
- 8 are inner tubes (couplers among them) whose wall the file states as zero. OpenRocket gives those
no mass too (the decision on what a
.orkleaves unsaid). - 3 are body tubes of no length, no wall and no radius. Each is the “phantom” tube that a pod’s parts hang from (A pod of no length).
- 1 is a mass object the file says weighs 0 kg.
- 2 are transitions the designs override to zero mass. That override is OpenRocket’s “base drag hack”: a massless, dragless transition added only to change the base geometry.
cargo xtask ork counts them by kind, so a new one would show up. Before
the milestone on what a .ork leaves unsaid the survey
counted 21 here. The 7 extra (2 body tubes, 2 fin sets, 2 inner tubes and a nose cone) name no
material, and now take OpenRocket’s default.
What the 10 warnings are. Every one is a reading this page
explains, and none of them means a file is broken. Before
parallel stages were read there were 12. Before
a rail button’s screw head was weighed there were 14.
Before fins on a nose cone were read there were 16. Before
tube fins sized from the body were read there were 18.
Before fin fillets were weighed and an automatic radius inside a nose cone was
read there were 21. Before
the old override flag was read as OpenRocket does there
were 31. Before pods were read there were 35, and before
clusters were read 39. Before
the packed-radius change there were 57: 5 more for a
packedradius the file does not give, read as zero. HPR Sim now reads that as OpenRocket’s 12.5 mm
(0.49 in) (packed parts).
| kind | count | what raised it |
|---|---|---|
Unusual | 1 | a part with no axial offset |
Unusual | 7 | automatic radii with nothing along their chains to take, given OpenRocket’s default (above) |
Unusual | 1 | a <rocket> holding nothing, so the document holds no design |
Skipped | 1 | a tally of the tags HPR Sim does not read where they are written, kept in x-openrocket, one per design that has any: the parallel stage directly under the rocket in demo-quirks.ork (Parallel stages); 3 before parallel stages were read, 7 before pods were read |
Every design that holds a design lays out. The one readable document that doesn’t is Debrief’s demonstration file. It holds no design at all: it is a stored simulation with a rocket’s name on it. The two designs that needed a radius the file doesn’t give are above.
Motors and recovery
The motors each configuration flies, and when parachutes open and stages separate.
Motors and their configurations
In short. HPR Sim reads every motor a design names, in every configuration, with when it lights
and its ejection delay. It finds the thrust curve in the file itself, in curves a caller supplies,
or in HPR Sim’s bundled catalog. A configuration becomes one the rocket can fly only when every
motor in it has a curve. Each motor must also light at a moment HPR Sim can fly. Of the 170
configurations in the reference library and OpenRocket’s examples, 154 fly with HPR Sim alone,
and 161 with OpenRocket’s motor database supplied (cargo xtask ork counts it). The rest are read, kept, and say why not.
A configuration is one set of motors to fly the design with. OpenRocket calls it a flight configuration, and a design can have several, one per motor choice. The file keeps it in two places:
<rocket>declares each one: aconfigid, a name, whether it is the one OpenRocket opens with (default="true"), and which stages fly.- Each motor mount (a body tube or inner tube holding a motor) holds a
<motor configid="…">per configuration. It gives the manufacturer, the designation such asH148R, and adigest(OpenRocket’s fingerprint of the thrust curve’s data). It also gives the case diameter and length, and the ejection delay. The mount also says when its motor lights, and may say it differently for each configuration.
So HPR Sim collects each mount’s motor into its configuration. A mount that names a configuration the rocket never declares still gets one, with a warning (a Loft lesson).
Where the thrust curve comes from
A <motor> names a motor; it does not describe one. HPR Sim looks for its thrust curve in three
places, in this order:
- Inside the file. From schema 1.11 (the
versionon the file’s<openrocket>element), OpenRocket can save each motor’s curve in the archive asthrustcurves/<digest>.rse. The file is named by thedigestthe<motor>gives (a Loft lesson). That is exactly the curve the design was saved with. OpenRocket 24.12 still writes 1.10, so few files carry one yet: one file in the reference library does. - Curves a caller supplies, each for one digest, through
design_with. A supplied curve is never matched by name, only by the digest. HPR Sim ships none: the validation survey supplies OpenRocket’s own motor database (motors in the reference library). - HPR Sim’s bundled catalog: ThrustCurve.org’s 1,004 solid motors. The
manufacturer and the designation must both match, ignoring case, spaces and hyphens. Both are
needed: an Estes
B4is not a QuestB4.
OpenRocket’s own order is the other way round: its motor database first, then the curve in the file. Its reason is that the database “may have more accurate or updated data” (its file specification). The curve in the file is the exact one. So HPR Sim reads the file first. On a file that carries curves, HPR Sim and OpenRocket can fly different curves for the same motor.
HPR Sim builds the motor from the curve file’s header, as it does for any catalog motor. The header holds the case size and the loaded and propellant masses. HPR Sim does not use the mass or center-of-gravity column listed beside each thrust point. A warning says so where the design’s case size and the curve’s differ by more than a millimeter. The design’s size places the motor, and the curve’s gives its mass. A motor found in none of the three places is kept with its reason. Nothing is invented for it. A hybrid motor (solid fuel burned with a liquid or gas oxidiser) never gets a curve: HPR Sim flies commercial solid motors only.
To fly a motor none of the three places has, build the configuration yourself. Read its .eng or
.rse file with hpr_motor (Solid motors) and put it in an
hpr_design::Configuration.
Delays and ignition
| the file says | it means | source |
|---|---|---|
<delay>6.0</delay> | the ejection charge fires 6 s after burnout | OpenRocket’s technical documentation, p. 8 |
<delay>0.0</delay> | the charge fires at burnout | the same, p. 10: “zero-delay motors” |
<delay>none</delay> | plugged: no ejection charge | the same, p. 8 (“P … stands for plugged”); OpenRocket issue #2002 |
<ignitionevent>automatic</ignitionevent> | the bottom stage lights at launch; a stage above lights at the ejection charge of the stage below | OpenRocket’s FAQ, “How do I create a staged rocket?” |
launch, burnout, ejectioncharge, never | at launch; at the first burnout or ejection charge of the stage below; never | OpenRocket 24.12’s labels, with every word measured by a committed probe (below). A word HPR Sim does not know is kept as written |
<ignitiondelay>1.5</ignitiondelay> | 1.5 s after that event | the technical documentation, section 4.2.6 |
A 0 means something different here than in a motor file. An .eng file has no word for plugged,
so HPR Sim reads its 0 as “zero or plugged” (ejection delay). A
.ork has none for plugged, and OpenRocket flies a 0 as a charge at burnout. In its own
“Parallel booster staging” example, the E12-0’s burnout and ejection charge are stored at the same
2.44 s. Until OpenRocket 23.09 put plugged in its delay list
(issue #2090), few authors knew to type
none. Some used 0 to mean plugged, as OpenRocket’s own examples did
(issue #2111). So a 0 in an older design
may be meant as plugged; HPR Sim reads it as the file says, as OpenRocket does. 21 motors in the
reference library have one.
A configuration’s own <ignitionconfiguration> replaces the mount’s event and delay one at a time:
whichever it leaves out, the mount’s own value stands.
HPR Sim flies each motor’s ignition as the file says it. Here is the ignition delay, and a
missing delay is 0. “The stage below” is the next stage aft on the axis, since a parallel stage
hangs beside its stage, not below it. Its burnout is its first motor’s. That is the first of its
motors to burn out, by each one’s ignition time plus its curve’s burn time, whichever mount holds
it. On a tie, the first in the file counts. The rules are also in the
hpr_io::ork::staging module’s documentation.
| the file says | HPR Sim lights the motor |
|---|---|
launch plus | seconds after launch |
automatic plus , in the bottom stage | seconds after launch (an air start when is more than 0) |
automatic plus , in a stage above | as ejectioncharge |
ejectioncharge plus | at the burnout of the stage below’s motor, plus that motor’s ejection delay, plus ; refused when the stage below has motors in more than one mount |
burnout plus | seconds after the stage below’s first burnout: the first of its motors to burn out, by each one’s ignition and curve |
never | never: the motor rides loaded, with no thrust |
burnout or ejectioncharge, in the bottom stage | never, since it has no stage below |
ejectioncharge or automatic, when the stage below’s motor is plugged | never, since a plugged motor fires no charge |
automatic plus , in a parallel stage hung on the last stage on the axis | seconds after launch, as OpenRocket lights the E12s of its Parallel booster staging with the I115W at 0 s |
launch plus or never, in a parallel stage | as written |
| any other event in a parallel stage | refused by name: HPR Sim has no reading for it |
A motor that never lights is flown as OpenRocket flies it: carried with all its propellant, giving
no thrust. So is a motor that waits on one that never lights. That follows from the probes, since
a motor that never lights has no burnout or charge, but no probe chains two. A stage that
separates at the burnout or ejection charge of its own motor, when that motor never lights, never
separates. A parallel stage with no motor that lights stays on too. Its burnout or ejection
separation never comes. In configuration 2 of Parallel booster staging, OpenRocket records no
STAGE_SEPARATION event and the boosters land with the core
(the parallel-stage decision). upperignition as a parallel stage’s separation is
refused by name.
These rules come from a committed probe, validation/oracles/openrocket/unlit_motors.py
(the unlit-motor milestone). It flies OpenRocket’s
Two stage high power rocket example, an I59WN over an I357T, five ways. In three, the booster never lights (set
never, or at burnout or ejectioncharge in the bottom stage) and the sustainer lights at
launch. In two, the booster is plugged and lights at launch, and the sustainer waits on its charge
(ejectioncharge, or automatic). Each time, OpenRocket lights one motor and separates nothing.
The booster’s separation is set at its own motor’s burnout and ejection in two of them, which
measures that rule. In the other three it is never.
By apogee the rocket has lost exactly that motor’s propellant: the sustainer’s 0.272 kg, or the
booster’s 0.1792 kg. The unlit one keeps all of its own. Two controls fly the example as written,
and with the booster not plugged, where its charge lights the sustainer 14 s after its burnout.
One exception is recorded apart: with an H148R-0 in both stages, OpenRocket’s mass column loses
nothing while a motor burns (#185). The test
openrocket_flies_a_motor_whose_ignition_never_comes_unlit in crates/hpr-io/src/ork/tests.rs
holds the record.
A configuration is still not flown when a motor names a word HPR Sim does not know. It is also not
flown when a motor waits on a stage below with no motor (not yet probed). The same goes for a motor
that waits on the charge of a motor that states no delay. Nor is it flown when a motor waits on the
charge of a stage below with motors in more than one mount. That covers ejectioncharge, or
automatic in a stage above. It is not flown there, because which fires its charge first is not
measured. And it is not flown when no motor of it lights at all, since the rocket would not leave
the pad. Its reason is a motor HPR Sim can’t light as written.
A stage’s burnout is its first motor’s. A second committed probe,
validation/oracles/openrocket/first_burnout.py, shows it
(a stage’s first burnout;
the first-burnout decision). It flies the first configuration of OpenRocket’s
Pods--powered with recovery deployment, with nothing deployed. Its booster holds a motor in its
main tube and one in each of two pods. As saved, the main tube’s B6 burns out first, at 0.86 s, so
it can’t tell the first burnout from the main tube’s. With a C6 in the main tube instead, the C6
burns out at 1.86 s. OpenRocket separates the booster and lights the sustainer at the pods’ burnout,
1.01 s. With C6s in the pods instead, OpenRocket does both at the B6’s 0.86 s. So the stage burns
out with its first motor, whichever mount holds it, not with the main tube’s or the last. The record
is validation/fixtures/ork/openrocket-first-burnout.json.
Which configurations the rocket flies
HPR Sim reads each motor’s ignition (above) and each stage’s separation
(below) into the flight. It has done so since
the milestone that flew .ork staging. The decision record is
a .ork file’s ignitions and one powered separation. A configuration becomes
one of the rocket’s only when all of these hold. Otherwise flying it would be wrong, for example
lighting a sustainer on the pad.
- Every motor has a thrust curve, and a case diameter and length.
- Every motor lights at a moment HPR Sim can fly. That is at launch, at a time after launch, or after the stage below burns out or fires its charge. Or it never lights, as above.
- No motor sits in a part HPR Sim doesn’t read yet. Examples are a parallel stage on a rocket of several stages and a pod set HPR Sim could not lay out (parts kept unread). A motor in a parallel stage HPR Sim reads flies (Parallel stages). A motor in a cluster of motor tubes flies with one motor in every tube (above).
- No stage is switched off in the configuration’s own stage list
(
<stage number="1" active="false"/>). OpenRocket leaves a switched-off stage out of the flight, and HPR Sim flies every stage. - The rocket and its motor mounts were read without a single warning. Nothing was left out (a pod,
a parallel stage HPR Sim can’t read, a part HPR Sim could not shape). Nothing was dropped or
simplified (a ring written as a row read as one, a material that could not be read). Nothing was
assumed (a shape HPR Sim does not know read as a cone).
Otherwise HPR Sim might fly a different rocket from the design, so no configuration of it is
flown. One design in the library was held back only by its shoulders of no wall. Since
the milestone on what a
.orkleaves unsaid reads them as OpenRocket does, it flies. - No mount holds two motors for the configuration. Which one OpenRocket would fly is not known, so neither flies.
- Its stages come apart in a way HPR Sim can fly. Each separation is flown, from the tail forward.
Each one’s time must be known before the flight: a time after launch, or after a motor lights,
burns out or fires its ejection charge. At that time a motor ahead of it must still be burning or yet to
light, and no motor behind it may be. That is a powered separation, which drops the stages
behind it and flies the rest on as a sustainer
(Several separations). One exception: a separation
at its own stage’s first
burnoutmay drop the stage’s own other motors still burning, as OpenRocket does. It drops only motors lit strictly before the split, and only when the split is powered. That means a motor ahead of it burns then, or lights then or later. The reader marks such a stagingdrops_burning, and HPR Sim’s flight drops a burning motor only for a marked staging. A delay after that burnout counts too, though OpenRocket’s probe measured only a split with none. The dropped part flies with no thrust, andhpr simnotes the impulse it leaves out (A booster dropped still burning). A motor behind it still to light, or lit at the split itself, is refused. So is any other separation while a motor behind it burns. Any other separation must come only at apogee or on the way down; the configuration then flies whole (below). A separation at the burnout or charge of the stage’s own motor that never lights never comes, and is left out (above). Otherwise its reason is stages HPR Sim can’t separate as written. Examples include a separation at or after apogee beside another, one that comes before the separation behind it, and a negative delay. Others are a sustainer already burnt out at the split and one at the ignition of a motor that never lights. A separation at launch is another. A separation timed after launch but before the rocket leaves the rod fires only as it leaves. HPR Sim’s flight fires none on the rod (#231).
Every other configuration is still read, whole, with the first reason it can’t be flown. The motors’ reasons are checked first, each across every motor, and the two about the whole rocket last.
This is the doctest on
hpr_io::ork::design, which CI runs. The Estes F15 has no
curve in the file, so it comes from the bundled catalog: 49.6 N·s over 3.45 s, as ThrustCurve.org
lists it. The rocket assembles with it. assemble takes the configuration’s configid; its name
is for display, and may be one of OpenRocket’s templates, such as [{motors}].
let read = hpr_io::ork::read(xml)?;
let design = hpr_io::ork::design(&read.value).value;
// The F15 has no curve in this file, so it comes from the bundled catalog...
let motor = &design.motors.configurations[0].motors[0];
assert!(matches!(motor.curve, hpr_io::ork::Curve::Catalog { .. }));
assert_eq!(motor.delay, Some(hpr_motor::Delay::Seconds(4.0)));
let impulse_ns = motor.curve.motor().expect("a curve").curve().total_impulse_ns();
assert!((impulse_ns - 49.61).abs() < 0.01, "{impulse_ns}");
// ...and it ignites at launch, so the configuration is one the rocket flies.
let assembly = design.rocket.assemble("c1")?;
assert_eq!(assembly.motors[0].mount, "body");
How many configurations hpr sim flies
In short. hpr sim flies 136 of the survey’s 170 motor configurations as saved, offline
after one fetch, and 25 more with --accept-design-errors; 9 are refused. These are counts, not
accuracy. A configuration counted as flying is one hpr sim accepts and flies to the ground. How
close each flight comes to OpenRocket’s is
HPR Sim’s flights against OpenRocket’s.
The survey is every .ork that Checked against real files reads.
That is the design library under refs/, which is other people’s designs and not in the
repository, and the 17 examples inside OpenRocket 24.12’s jar. A motor configuration is one set
of motors to fly a design with (above). A file found in two
places is counted in each.
These counts of the same 170 differ by where the thrust curves come from. hpr sim also
refuses a design its checks find an error in, unless given --accept-design-errors:
| Curves from | Configurations that fly | Counted by |
|---|---|---|
| The file and HPR Sim’s bundled catalog alone | 154 | cargo xtask ork |
Those, and ThrustCurve.org’s, as hpr sim fetches them | 136 | cargo xtask ork-cli |
Those, flown with --accept-design-errors | 161 | cargo xtask ork-cli (136 + 25) |
| Those, and OpenRocket’s own motor database | 161 | cargo xtask ork |
HPR Sim doesn’t ship OpenRocket’s database, so 136 is what a user of hpr sim gets, and 25 more fly
with --accept-design-errors. The 161 is the
validation survey’s count (Motors in the reference library).
The 136 come from the committed report, which cargo xtask ork-cli writes
(the CLI’s corpus count). It runs each configuration
through the same function the hpr command runs, as hpr sim --json --offline --config ID FILE.
A first pass with the network caches every curve hpr sim fetches
(Where the thrust curve comes from), and the counts are
taken offline after it.
A configuration refused as saved is flown again with --accept-design-errors. The 25 that fly
then were refused only because the design’s own checks found an
error. An example is a ring or tube wider than the tube it sits in. Their flights list those
errors in their notes (The command line).
Of OpenRocket’s 56 example configurations, 54 fly as saved, 0 more with --accept-design-errors,
and 2 are refused. Deployable payload’s five fly with warnings. Its payload and its parachute are
drawn 25 mm (0.98 in) across in a 21 mm (0.83 in) bore, so they can’t fit as drawn. But a packed
part’s width sets only its own inertia
(a packed part wider than its bore,
the milestone on such a part). Parallel booster staging’s two
fly since the parallel-stage milestone read its boosters
(Parallel stages). Pods--powered with recovery deployment’s first flies since
the first-burnout milestone read its booster’s burnout as its
first motor’s (Delays and ignition). The 2 refused are Simulation
extensions and Simulation scripting, for a hybrid motor: HPR Sim flies commercial solid motors
only until release 1.0.
Two of the library’s refusals are motors with no curve whose file records no
digest, OpenRocket’s fingerprint of the curve. hpr sim
supplies a fetched curve only by its digest, so it fetches none for them. The report gives every
reason’s count.
Counting again needs the private library under refs/ and, once, the network. Run it after any
change to the reader or to hpr sim:
cargo xtask ork-cli --fetch # once, with the network: fills the motor cache
cargo xtask ork-cli # offline: writes validation/reports/ork-cli-flights.{json,md}
cargo xtask ork-cli --check # fails unless the committed report is still what hpr sim flies
Motors in the reference library
In short. Most designs in the reference library don’t carry their motors’ curves. They name each curve by its digest, OpenRocket’s fingerprint (a hash) of the curve’s data. OpenRocket finds the curve in the motor database that ships inside its program. The validation survey supplies that database to HPR Sim, so 161 of the 170 configurations fly instead of 154. Every curve involved matches OpenRocket’s total impulse, and in every configuration HPR Sim flies with a supplied curve, OpenRocket places that curve too. What still differs is where the motor’s weight sits (below).
How it works:
- An oracle,
validation/oracles/openrocket/motor_database.py, records OpenRocket 24.12’s own database: 1,452 motors. cargo xtask orkhands each solid motor’s curve to the reader for its digest, throughdesign_withandSuppliedCurves. A curve the file embeds still comes first, and HPR Sim’s bundled catalog last.- A supplied curve is never matched by name. In the database, 286 manufacturer-and-designation pairs have more than one curve.
- The database’s curves come from ThrustCurve.org by way of OpenRocket, and OpenRocket publishes no terms for reusing them (ADR-067, the decision on OpenRocket’s curves); the curves embedded in the designs belong to their owners. So the record stays on the machine that ran it, and only counts are published here. ThrustCurve.org itself grants no license for its records and reserves copyright.
To repeat the survey you need the private design library under refs/, which most readers won’t
have. You also need Java 17 and the OpenRocket jar (cargo xtask refs fetch), as for the
mass comparison. Then, from the repository root:
refs/venv/bin/python validation/oracles/openrocket/motor_database.py \
corpus-out/openrocket-motors.json refs --jar
cargo xtask ork
cargo xtask ork, over the 72 designs, with that record, on October 5, 2026, after
the milestone that read a stage’s first burnout. The counts
are of motors, one per mount per configuration:
| motors | count |
|---|---|
| read into their configurations | 208: 138 single-use, 65 reloads, 3 hybrids, and 2 not written, read like the rest |
| left out, in parts not read yet | 0; 2, both in parallel stages, before they were read (Parallel stages), and 6 before pods were read (Pods) |
| thrust curve from the file itself | 4 |
| thrust curve from OpenRocket’s database, by digest | 178 |
| thrust curve from the bundled catalog | 1 |
| no curve | 25: 3 hybrids, and 22 with no curve in any of the three places |
| ejection delays | 132 in seconds, 21 at 0 s, 53 plugged (none), 2 not written |
And of configurations, over 80 motor mounts in 63 designs (none named only by a mount):
| configurations | count |
|---|---|
| declared | 170 |
| the rocket flies | 145, in 41 designs, and all 145 assemble |
| left out, by the first reason the reader finds | 24 a motor with no curve, 1 stages HPR Sim can’t separate as written, and none now a motor HPR Sim can’t light as written (1 before M4.5n read a stage’s first burnout); before parallel stages were read, 2 more for a motor in a part not read and 2 for an airframe not read exactly as written |
On September 28, 2026, after the milestone that read tube fins sized from the body, 109 flew in 30 designs. Another 15 were held back as an airframe not read exactly as written, and 19 as stages HPR Sim can’t separate as written. On September 25, 2026, before pods, the old override flag, fillets, the bore inside a nose cone and tube fins were read, 93 flew in 23 designs. Another 30 were held back as an airframe not read exactly as written.
What the database changed. On that date, with the bundled catalog of 32 motors alone, 166 configurations were held back for want of a curve, and 4 flew. The table follows those 166. A configuration that now has its curves can still be held back for another reason, so these counts differ from the table above:
| what became of the 166 | configurations |
|---|---|
| fly | 141 |
| held back for another reason: stages HPR Sim can’t separate as written | 1 |
| still no curve: the motor records no digest, and the bundled catalog lacks it | 20 |
| still no curve: a hybrid | 3 |
| still no curve: a digest the database lacks | 1 |
- Total impulse is within 0.1% of OpenRocket’s on every curve, and the survey fails otherwise.
All of them agree to the last bit. The two checks differ in strength:
- The 3 curves the designs embed are real checks. HPR Sim parses each file itself, as for the bundled curves.
- For the 1,288 solid database curves, both codes integrate the same samples, which OpenRocket has already parsed. That check proves the hand-off, not two independent readings.
- The curve OpenRocket flies. The oracle opens each design in OpenRocket with the database loaded, and records the digests of the motors it places in each configuration. The survey fails unless, in every configuration HPR Sim flies with a supplied curve, OpenRocket places each supplied curve too. It does in all 142 such configurations (177 motors), and OpenRocket opens every design they are in, as the survey prints.
- What the survey doesn’t supply:
- the 164 hybrid motors;
- 6 digests that are each shared by two motors whose data differ (samples, case or masses), in OpenRocket 24.12’s database;
- one motor whose propellant mass gives an effective exhaust velocity of 10.1 km/s, which HPR Sim refuses as impossible.
- Other masses are taken as OpenRocket holds them, including some that are physically unlikely.
- Where the weight sits differs. HPR Sim builds every motor from its envelope. The center of mass sits at mid-case, and the dry case is a thin tube. OpenRocket gives each database motor a fixed center of mass of its own, and treats the motor as a solid cylinder for inertia. The 1,288 solid motors are 1,221 digests once the 54 repeats, the 12 motors sharing 6 digests and the refused one are set aside. For 163 of those 1,221, OpenRocket’s center of mass is more than 1 mm (0.039 in) from mid-case. Among the 55 distinct supplied motors the designs fly, 6 are, by up to 6.5 mm (0.26 in). This matters to stability margin and roll, and the milestone that flies these designs against OpenRocket will meet it when it flies them.
How this was decided, and the counts in full, is in the decision on OpenRocket’s own database.
The reading order for curves is in the decision on which motors a .ork flies.
When parachutes open and stages separate
In short. HPR Sim reads when each parachute and streamer opens, with the drag coefficient it
states, and when each stage separates, in every configuration. Since
the milestone that flew a .ork’s recovery, parachutes and
streamers fly as HPR Sim’s own recovery devices. They fly the way
OpenRocket flies them (flown as OpenRocket flies them). Since
the milestone that flew .ork staging against OpenRocket, a
configuration’s powered separation is flown. That is one whose time is known before the flight.
At that time a motor ahead of it is still burning or yet to light, and none behind it is. It drops the
booster and flies the sustainer on. Since
the milestone for a stage’s first burnout, one at its own
stage’s first burnout may also drop the stage’s other motors still burning. OpenRocket does the
same.
Since the several-separations milestone, a configuration’s
several powered separations are flown in turn, from the tail forward. A separation at apogee or
on the way down is part of the descent. It is left out, and the configuration flies whole, even
when a sustainer sits ahead of it. That assumes every motor is spent by apogee, which the report’s
tool checks of every flight. Any other separation, such as one after a sustainer has already burnt
out, is not flown
(which configurations the rocket flies). Every device
and stage in the reference library is read. The separations of its 2 parallel stages are read since
the parallel-stage milestone
(Parallel stages), and the 2 parachutes inside pods since Pods are.
A deployment is an event, a height for the event that needs one, and a delay after it. A parachute or streamer states its own, and a configuration may change any of the three:
<deployevent>ejection</deployevent>,<deployaltitude>200.0</deployaltitude>(meters) and<deploydelay>0.0</deploydelay>(seconds) are the device’s own.<deploymentconfiguration configid="…">changes them for one configuration. Whichever of the three it leaves out, HPR Sim keeps the device’s own, as it does for a motor’s ignition. That is HPR Sim’s reading: OpenRocket was not probed on a file that leaves one out.
A stage’s separation is written the same way, with <separationevent>,
<separationaltitude>, <separationdelay> and <separationconfiguration configid="…">. The stage
that states it is the one that drops away: OpenRocket’s labels (below) speak of the “current
stage” and the “upper stage”.
What the words mean
OpenRocket’s documentation lists none of these words. The committed probe
validation/oracles/openrocket/events.py runs OpenRocket 24.12 and sets every value of each event
through the program’s public setters. It saves the design and records the word written and the
label OpenRocket shows. Its results are in validation/fixtures/ork/openrocket-events.json, and the test
hpr_io::ork::tests::every_event_word_openrocket_writes_is_read holds HPR Sim’s reader to every
word.
| deploy word | OpenRocket’s label |
|---|---|
launch | “Launch (plus NN seconds)” |
ejection | “First ejection charge of this stage” |
apogee | “Apogee” |
altitude | “Specific altitude during descent” |
lowerstageseparation | “Lower stage separation” |
never | “Never” |
| separation word | OpenRocket’s label |
|---|---|
launch | “Launch” |
ignition, burnout, ejection | “Current stage motor ignition”, “… burnout”, “Current stage ejection charge” |
upperignition | “Upper stage motor ignition” |
altitudeascending, apogee, altitudedescending | “Specific altitude during ascent”, “Apogee”, “Specific altitude during descent” |
never | “Never” |
The same probe measures three things the words do not say:
- A deploy height is above the ground, meaning the launch site: OpenRocket has no terrain. The
probe flies in calm air with a fixed seed, so it writes the same numbers every run. The pad
stood 1,000 m (3,281 ft) above sea level. A parachute set to
altitude30 m (98 ft) opened at 29.9 m (98 ft) above the ground. That is 1,029.9 m (3,379 ft) above the sea. A height read above the sea would never have been reached. - Set above apogee, it did not open. Set to 100 m (328 ft), on a flight whose apogee was 51.7 m
(170 ft), the parachute never opened. The flight reached the ground. That is one run of one design, not a
rule OpenRocket states. HPR Sim’s own altitude trigger opens at apogee instead
(Recovery), so the two differ here. HPR Sim
keeps its own rule for a
.orktoo, andhpr sim’s notes say when it applies. <cd>auto</cd>is reported as 0.8 for a parachute, on the canopy’s area. OpenRocket’s technical documentation gives 0.8 as the default (section 4.2.5), and the probe reads it back. For a streamer it is worked out from the strip’s length and material, on the strip’s area (appendix C, equations C.4 and C.5). The values are 0.089, 0.060 and 0.050 for strips 0.5, 1.0 and 1.5 m (4.9 ft) long. They are for a material of 67 g/m², which the three values imply by equation C.5. The documentation puts that estimate’s accuracy at about 20%. One user’s report (issue #2031) finds a 2.5 by 44 in streamer’s 0.06 far too small. HPR Sim keeps theautoor the stated number as the file wrote it.
Flown as OpenRocket flies them
A configuration’s parachutes and streamers fly as OpenRocket flies them. They land at
OpenRocket’s speed to within 0.021% on 50 of its 53 example flights, and within 0.12% on all 53.
hpr::ork::recovery turns each one into a flight device, and
hpr sim flies them through it, so its numbers are the library’s. This is
checked against OpenRocket alone, not against a real flight. Recovery
has the model and the full results. The reasoning is in
the decision record on flying a .ork’s recovery.
- How. The drag is the file’s , or OpenRocket’s own for
auto: 0.8 on a parachute’s canopy, and appendix C’s estimate for a streamer. Each device opens fully at once, the file’s delay after its event. The descent is a point mass under the open devices’ drag alone, as in OpenRocket.apogee,altitude,ejectionandlaunchfly;never, andejectionon a plugged motor, open nothing. - How close. On 48 of OpenRocket’s example flights, the landing speed is +0.00% to +0.02% off OpenRocket’s and the flight time −1.57% to +3.16%. The 48 are the report’s 51 with no named cause for an apogee gap, less the Base drag hack’s three. The flight time of those three runs up to +7.07%. 40 meet every target set before measuring. The other 8 miss only on a deployment’s time, which the climb’s own apogee gap and OpenRocket’s time step explain (the report’s descents).
- The limits. A device inside a part HPR Sim doesn’t read and an unknown event are refused. The
flight falls on its airframe alone, with the reason in its notes. In a stage where
no motor lights, a device set to open at its stage’s ejection charge never opens. OpenRocket does
the same (the powered pods example;
the pods-powered decision).
One set to open at
lowerstageseparationopens at a split with nothing left to burn, and is refused otherwise. A device set above the apogee opens at apogee, where OpenRocket’s one probed run never opened it. HPR Sim counts a height from the ground, OpenRocket from where the center of mass starts on the pad. - A stage that separates under power.
hpr::ork::separated_recoveryputs each device on the part its stage is in. The booster tumbles from the split until its first own device opens, and a sustainer with no device tumbles from its apogee. The sustainer’s descent is held to the same targets. On the Two stage high power rocket’s two configurations, its landing speed is +0.00% off OpenRocket’s and its flight time +0.32% and +0.73%. The first meets them once sized, as its main opens 1.09 s early on an apogee 1.79% low. OpenRocket’s record keeps only the sustainer’s branch, so the booster’s descent is not compared (the decision on powered separation inhpr sim).
Recovery in the reference library
cargo xtask ork, over the 72 designs, on October 5, 2026, after
the milestone that read parallel stages:
| quantity | count |
|---|---|
| parachutes and streamers read | 136: 134 parachutes, 2 streamers; 134 before parallel stages were read |
| left out, inside pod sets HPR Sim did not read then | 2; since pods are read (Pods), none |
| drag coefficient | 79 auto, 57 stated |
| deploy event | 79 ejection, 32 apogee, 18 altitude, 6 lowerstageseparation, 1 never |
| devices a configuration changes | 11, with 25 changes in all |
| stages that state a separation | 20 of 92: 14 ejection, 4 upperignition, 2 burnout; 15 changes per configuration |
| separations left out, in parallel stages HPR Sim does not read | 0; 2 before parallel stages were read (Parallel stages) |
How this was decided is in the decision on reading a design’s recovery and separation.
What OpenRocket last did: stored simulations
In short. A .ork keeps the simulations OpenRocket last ran on the design, and HPR Sim reads
them back. It reads the launch conditions each was flown in, the ten summary figures, and each
stage’s time series with its events. Reading a result is not the same as validating it. HPR Sim
applies a reference gate, a screen deciding whether stored data may be used as a reference datum
(the stored-results milestone). The gate checks current
status, two known OpenRocket provenance markers, plausible stored values, and internally consistent
series data. It does not re-run OpenRocket or compare the stored flight with a fresh HPR Sim or
OpenRocket flight. An eligible stored run may still disagree with that later comparison. Every
parseable result stays visible, including results that fail the screen.
The reference screen and HPR Sim’s reproduction screen answer different questions. The first asks whether stored data is suitable as a reference datum. The second asks whether HPR Sim can reproduce the named design and motor configuration. A complete OpenRocket result can pass the first and fail the second when its motor curve is absent or its airframe is reduced. A later flight-comparison gate must report both screens rather than treating either one as a physics validation.
A stored simulation has three parts:
<conditions>: the launch rod, the wind, the launch site, the atmosphere and the time step.- The summary: ten figures on
<flightdata>, such asmaxaltitudeandoptimumdelay. - The time series: a
<databranch>per stage. Itstypesname its columns:Time,Altitudeand the rest, 58 in the files OpenRocket 24.12 writes (other versions differ). Its<datapoint>rows give a value for each. Beside the rows are the flight’s<event>s (launch,apogee,recoverydevicedeploymentand so on) and any<warning>OpenRocket stored.
What the numbers mean
The file-format page gives units only for the multilevel wind (meters, m/s and radians). Its
own example writes a launch rod’s direction as 90.0 and a wind’s as 1.5707963267948966. Here
SI means the International System of Units. Lengths are meters, times seconds, speeds meters
per second, pressures pascals and angles radians unless the table says otherwise. A denominator
is the count of runs used to calculate a reference statistic. The
committed probe validation/oracles/openrocket/conditions.py runs OpenRocket 24.12, sets the
conditions through its public setters, saves, loads them again and flies them. Its results are in
validation/fixtures/ork/openrocket-conditions.json, and the test
hpr_io::ork::tests::wind_direction_is_not_rod_direction holds HPR Sim’s reader to them.
| the file says | it means | HPR Sim gives |
|---|---|---|
<launchrodangle>5.0</launchrodangle> | the rod tilts 5 degrees from vertical | rod_angle_rad, 0.0873 |
<launchroddirection>45.0</launchroddirection> | toward a compass bearing of 45 degrees, clockwise from north | rod_direction_rad, 0.785 |
<winddirection>0.5</winddirection> | the wind blows from a bearing of 0.5 radians, about 29 degrees | wind_from_rad, 0.5 |
<windturbulence>0.1</windturbulence> | turbulence intensity: the wind speed’s standard deviation over its mean | wind_turbulence, 0.1 |
<atmosphere model="extendedisa"> with <basetemperature> and <basepressure> | the standard atmosphere from a temperature (K) and pressure (Pa) at the launch site | Atmosphere::Extended |
Here ISA means International Standard Atmosphere, the reference atmosphere; K means kelvin,
Pa pascal and rad radian. The probe also flies the example, in three ways that settle what the
directions mean:
- The rod’s direction is a compass bearing. In calm air, a rod tilted 10 degrees toward bearing 0 (north) lands the rocket 21.3 m (70 ft) north. Tilted toward 90 (east), it lands the rocket 21.3 m (70 ft) east. In both, the example’s own wind setting stays at 90 degrees. OpenRocket’s preferences page still calls the direction relative to the wind, but the program does not treat it so.
- The wind’s direction is where it blows from. From a vertical rod, a steady 5 m/s (16 ft/s) wind from bearing 90 (east) lands the rocket 48.4 m (159 ft) west. The same wind from bearing 0 lands it 48.4 m (159 ft) south.
<launchintowind>rewrites the rod. With it true, OpenRocket overwrites the rod’s direction with the wind’s bearing, in degrees. A wind from 0.5 radians is written as a rod direction of 28.648.
All of this is measured on OpenRocket 24.12. A file written by a much older version may have meant the rod’s direction otherwise, which is not measured.
The rod’s direction and the wind’s are different numbers in different units.
Loft read the wind’s direction from launchroddirection
(L64). HPR Sim reads each from its own tag.
The probe saves a flight and compares one stored row with the same quantities as OpenRocket held.
It does so in eight columns: time, altitude, vertical velocity, two angles, latitude, air
temperature and air pressure. These are SI (the International System of Units). Lengths are in
meters, times in seconds, pressures in pascals and speeds in meters per second. Angles are in
radians and latitude in degrees. Values are rounded when stored, to three decimal places (287.857 K, 0.218 rad), so a small quantity keeps few digits. A large one is rounded to four significant
figures (100,796.6 Pa is stored as 100,800). NaN means “not a number”. OpenRocket did not compute
that quantity at that step. HPR Sim stores it as Rust’s None value, meaning no numeric value is
available. A design with stored results therefore survives being saved as JSON and read back.
This is from the test stored_results_are_read_back: a stored run reads back through design.simulations, and a column comes out by its name.
hpr_io::ork::StoredSimulation::reference_exclusion then classifies the stored run without
altering it. An explicitly uptodate run must name both RK4Simulator and BarrowmanCalculator,
the simulator and aerodynamic calculator markers shown in the public file specification’s
Simulation Data example. These strings identify recorded provenance, not the complete OpenRocket
version, settings or design. The run must have finite, non-negative values, positive altitude, speed
and time to apogee, and no contradiction between its summary and time series. A missing summary or
flightdata, a backwards time series, or a time-series altitude materially different from the stored
apogee is excluded with a stable reason. The comparison allows max(0.1% of the stored apogee, 1 mm) for stored-value rounding. It is a data-integrity policy, not an accuracy claim about the
flight model. For example, with a 100 m (328 ft) stored apogee, 100.05 m (328.2 ft) passes this
screen and 100.2 m (329 ft) fails it. The
comparison test
pins the two-sided allowance and its boundary.
For this screen, HPR Sim treats the first branch with an apogee event in file order as the summary
branch. The
selection test
exercises that implementation policy. The rule has not been independently validated against
multi-stage OpenRocket output. A single altitude-bearing branch is checked even when its apogee
event is missing. Multiple branches without an apogee event are uninspectable because their summary
branch cannot be identified. Times in rows and events must be finite, non-negative and ordered.
When the summary is present, no time may exceed the stored flight time beyond the 1 ms allowance
for stored precision. The first apogee event must also agree within 1 ms with timetoapogee. Fatal
events (such as SIM_ABORT, with case, underscore and hyphen variants normalized) are excluded.
There is no arbitrary minimum apogee: a small but self-consistent flight is not rejected merely for
being small.
Design::reproduction_exclusion is a second, stricter screen. It excludes reduced designs, missing
or unknown configurations, configurations HPR Sim cannot assemble, and configurations left out while
reading the design. These reasons describe HPR Sim’s current ability to reproduce the design, not
the stored result’s provenance or physical correctness.
What the summary words mean
Each of the ten summary figures on <flightdata> (the summary words, such as maxvelocity) has
a meaning in OpenRocket 24.12. The meanings here are measured on flights OpenRocket ran itself.
HPR Sim’s own flights of the same configurations are compared with them in the next
section, HPR Sim’s flights against OpenRocket’s.
A word names a quantity, but not how it was taken. deploymentvelocity could be the speed at the
first parachute or at the last. timetoapogee could be the apogee event’s time or the time of the
highest stored step. Another tool, or another OpenRocket version, can use the same word for a
different quantity (Loft lesson L80).
So HPR Sim will compare a stored value only through a written definition for the version that wrote
it. Only OpenRocket 24.12’s are measured. A file’s writer is its root creator attribute
(OpenRocket 24.12). For any other version, every summary value is withheld, not compared.
How they were measured. The oracle script
flights.py
runs the OpenRocket 24.12 program file (its jar). It flies every motor configuration of the public
designs: the 17 examples inside the jar and the seven Loft demos. Each flight uses the design’s
first stored launch conditions, in calm air (no wind, no turbulence). Of the demos, only one has a
motor OpenRocket finds, and demo-quirks.ork does not open. That leaves 18 designs with 57 motor
configurations between them, so 57 runs. OpenRocket aborted one of them, Pods--powered with
recovery deployment [C6-7; 2× A3-4, B6-0], at 1.81 s and 85 m (279 ft) up (“Stage began to
tumble under thrust”). The brackets list its motors by stage, sustainer first. The stages are
separated by ;: a C6-7 in the sustainer, two A3-4s and a B6-0 in the booster. Its figures are where the run stopped, not a
flight’s, so it is not a reference, which leaves 56 complete flights. The record,
validation/fixtures/ork/openrocket-flights.json, keeps each word beside the quantities of
OpenRocket’s own time series (its stored steps) that the word could mean. The test
stored_metric_definitions_are_per_tool_and_version
holds each defined word to its quantity on all 56, to 1 part in . Nine of the ten words are
defined; the tenth, optimumdelay, is withheld, with the flights that rule out its two obvious
readings.
| word | OpenRocket 24.12 means | shown by the record |
|---|---|---|
maxaltitude | the largest altitude above the launch site | 56 of 56 |
maxvelocity | the largest total speed (not the vertical speed) | 56 of 56 |
maxmach | the largest Mach number | 56 of 56 |
timetoapogee | the time of the highest stored step | 56 of 56; the apogee event’s time differs on 13 |
flighttime | the time of ground hit, the last step | 56 of 56 |
launchrodvelocity | the total speed at the first step past the rod’s length | 56 of 56; 0.06% to 7.50% above the speed at the rod’s end, placed by interpolating linearly in height |
deploymentvelocity | the total speed at the last deployment, interpolated between the steps either side | 56 of 56; 53 deployments fall between steps, and on 17 flights the first deployment’s speed differs |
groundhitvelocity | the total speed at ground hit, the last step | 56 of 56 |
maxacceleration | the largest total acceleration before the first deployment | 56 of 56; over the whole flight it differs on 15, whose largest acceleration comes after a deployment |
optimumdelay | not measured: withheld | on 15 flights it is not the time of apogee less the time of the last burnout, nor that of the same flight flown again with nothing deployed |
| (no word) stability margin | the distance from the center of gravity (CG) aft to the center of pressure (CP), in calibers, at rod clearance | the stability column, 56 of 56 |
The stability margin follows Niskanen’s definition (N09 p. 12): the
CP’s distance behind the CG, divided by the reference length
and so counted in calibers. OpenRocket’s reference length is by
default the largest body diameter, and that is the setting on all 57 runs. The optimum delay is the
best ejection delay. The 15 flights it misses are exactly those on
which a recovery device deploys before apogee. Five others fire an ejection charge before apogee
but deploy only after it, and agree. Flown again with nothing deployed, every one of the 56 gives an
optimumdelay equal to its apogee less its last burnout. So an early deployment is what changes the
figure, but how is not known, and the figure is not used.
OpenRocket does not say which point on the rocket its speeds belong to. RocketPy’s are the center of dry mass’s, and RocketPy’s rail exit is where the rocket’s travel equals the rail, found between steps (ADR-021). So RocketPy’s and OpenRocket’s largest speed and rail-exit speed are kept as different definitions.
A worked example. The Chute release example with a G40W-7 fires its ejection charge after apogee and opens its main parachute lower down:
| deployment | time, s | speed, m/s |
|---|---|---|
| first | 9.301 | 8.305 at the 9.3 s step, 8.329 at 9.3025 s: 8.314 interpolated |
| last | 20.514 | 14.231, on a step |
OpenRocket’s deploymentvelocity is 14.231 m/s (46.69 ft/s): the last deployment. A comparison
using the first deployment would have set HPR Sim’s value against 8.31 m/s (27.3 ft/s) instead. The
interpolation matters too. For the 3D printable nose cone and fins example with a B6-4, the one
deployment is at 4.861 s. It falls between steps at 4.86 s (0.6575 m/s (2.157 ft/s)) and 4.8625 s
(0.6330 m/s (2.077 ft/s)). OpenRocket reports 0.6477 m/s (2.125 ft/s), the value interpolated at
4.861 s, not either step’s.
An event that never happened has no value. The record also holds a 58th flight, outside the
57: the A simple model rocket example edited so its parachute never opens. It flies to the ground, and OpenRocket writes
NaN for deploymentvelocity. On every complete flight, a speed taken at an event is NaN exactly
when the event is missing. Loft scored such values as 0
(L81). HPR Sim’s
compare
never scores them. When neither flight had the event, the metric is withheld. When only one did,
the flights disagree about what happened, and the comparison fails. Every figure of an aborted run
is withheld. The test
metric_for_missing_event_is_withheld_not_scored
checks all three.
The simulator’s flights against OpenRocket’s
HPR Sim’s whole flights are compared with OpenRocket 24.12’s on the 54 configurations. They are the configurations of OpenRocket’s example designs that HPR Sim can fly, in 15 of the examples. OpenRocket aborts its own flight of one of them. The figures below are over the other 53, and that one is checked up to the abort (below). This is a code-to-code comparison: agreeing with OpenRocket is not the same as agreeing with real flights. Use it to judge how closely HPR Sim’s flight matches OpenRocket’s on ordinary hobby rockets.
-
The stability margin as the rocket leaves the rod agrees within 0.016 calibers on 41 of the 53. HPR Sim’s margin here is taken with the air along the rocket’s axis (the 0° plane), as OpenRocket’s is, not in HPR Sim’s weakest plane. On
[C6-7; B6-0]of Pods--powered with recovery deployment it is +3.74 calibers along the axis. Therehpr simprints a least margin of −4.21 calibers in the weakest plane. The Tube fin rocket’s margin is 1.08 calibers short of OpenRocket’s. The two codes’ tube fins differ (Tube fins). The three-stage example’s three are 0.039 to 0.058 calibers short, about as much as HPR Sim’s center of mass sits further aft there. The Pods--airframes and winglets example’s five are 0.071 to 0.076 calibers long, the flattering side. HPR Sim’s center of pressure sits 2.6 mm (0.10 in) aft of OpenRocket’s there (#325, fin-fin interference; #326, a kinked fin’s center of pressure). The Pods--powered with recovery deployment example’s three are 0.070 calibers long, the same side. HPR Sim’s center of pressure sits 2.4 mm (0.094 in) aft of OpenRocket’s there, a gap not yet traced. -
Pods--airframes and winglets flies since the milestone that reads its cockpit fin on the nose cone (Fins on a nose cone or a transition). Its five apogees are within 0.5% of OpenRocket’s, −0.13% to +0.48%, and its margin 0.07 calibers high.
-
Pods--powered with recovery deployment flies since the milestone for its rail buttons’ screw heads and pod sets. That milestone weighs the screw heads and flies the motors in two pod sets (the decision). Its first configuration,
[C6-7; 2× A3-4, B6-0], flies since the milestone for a stage’s first burnout. It is checked up to OpenRocket’s abort (below). Its sustainer alone,[C6-5; None], reads 0.36% low, and its booster alone with its two pod motors,[None; 2× A10-3, B6-4], 1.86% low. On the booster-alone flight the two pod parachutes open at launch + 5.35 s in both programs. Its landing speed is +0.00% off OpenRocket’s and its flight time −1.02%, and both descents meet their targets (the decision). Its staged flight,[C6-7; B6-0], is the eighth apogee more than 5% off (below). The file flies inhpr simas saved. The centering rings on the booster’s 18 mm motor tube wrap it (a ring around its tube). One fits the booster’s airframe. The other, in a coupler, reaches 0.76 mm (0.030 in) past the coupler’s bore and warns as a fit to sand. -
The mass at launch agrees within 0.21% on all 53. The center of mass (CG) as the rocket leaves the rod agrees within 0.016 calibers on all but the three-stage example’s three. Those are 0.043 to 0.062 calibers further aft (mass and center of mass). That is where OpenRocket’s recorded mass falls as if every motor of the booster’s type burned from launch (#185). Whether that accounts for the gap is not sized.
-
On the 36 flights with no named cause, HPR Sim’s apogee is from 4.34% low to 1.95% high. Only 14 read high:
- the five Airstart timing flights
- the ARC payload rocket
- the Deployable payload on an A8-3
- four of the five Pods--airframes and winglets flights
- both Parallel booster staging flights (+1.23% and +0.68%, Parallel stages)
- Base drag hack (short-wide), the highest
-
On the six Dual parachute deployment flights, HPR Sim’s apogee is 0.63% to 4.34% low. The cause is not traced.
-
A two-stage design, a three-stage design, a cluster, an air start and boosters beside the core fly. Every flight of each is within 5% of OpenRocket’s apogee and largest speed, the bar set before measuring. Five of their apogees are compared with OpenRocket’s flight with no parachute, since its parachute opened early (staged, clustered and air-start flights, below).
-
Six probe designs, five with pods and one without, are not counted among the 53. They were written for a pod design against OpenRocket. They fly within 0.92% of OpenRocket’s apogee and 1.24% of its largest speed, and their margins are within 0.0014 calibers (aerodynamics: Pods).
-
The bar, set for the whole corpus (OpenRocket comparisons), is that every apogee more than 5% off has a written cause. Eight apogees are more than 5% off, and each has a named cause. Seven are sized in one of two ways:
how the cause is sized flights Flights within 5% after OpenRocket flies the flight again with its causes taken out (M2.2e4) 6 4 HPR Sim flies the flight again on OpenRocket’s own drag (ADR-097) 1 1 The two of the six still over 5% are the Base drag hack on a D12-3 and an E12-4. With nothing deployed in OpenRocket either, HPR Sim reads 5.84% and 8.92% high. Flown on OpenRocket’s own drag along that flight, HPR Sim comes within 0.10%. So what is left is the drag coefficient. By OpenRocket’s part-by-part breakdown, the gap is in the nose’s drag (#177, a very blunt nose’s drag; see below).
The seventh is the Tube fin rocket, 6.95% high. On OpenRocket’s drag HPR Sim comes within 0.03%, so its cause is HPR Sim’s own drag. The net gap is the drag’s, though parts of it could cancel. Its written breakdown is in its decision record.
The eighth is Pods--powered with recovery deployment on
[C6-7; B6-0], 37.93% low, its largest speed 15.76% low. Its sustainer is unstable when the air crosses it edge-on to its two-fin strake set. In the conditions of OpenRocket’s record it turns over before apogee in both programs, which is the cause the report names. OpenRocket’s own record tumbles at 2.84 s. Its calm, vertical flight holds the angle of attack at zero until then. Seeded with a 0.5° rod tilt, OpenRocket aborts the flight at 1.71 s and 51 m (167 ft) up (a scratch run, not committed). HPR Sim’s sustainer turns over as the Earth’s rotation at the record’s site, 28.61° N, tips it. Its angle of attack passes 90° at 2.25 s. Athpr sim’s default site, on the equator, nothing tips it and it stays upright (Stability margin). Its descent lands at OpenRocket’s speed (+0.00%), but its flight time is 52.64% short. Since #329, HPR Sim’s printed margin is the weakest direction’s.hpr simprints this configuration’s least margin as −4.21 calibers, at the separation (0.86 s), where it printed +1.56 before (Stability margin).
How they were flown. cargo xtask ork-flights flies every configuration of the record in the
section above that HPR Sim can fly. It uses the conditions OpenRocket flew. The launch rod is as
recorded: its length, its angle from the vertical and the compass bearing it leans toward, as
below. The site is the recorded one, the atmosphere is the
standard atmosphere and there is no wind. Each figure is
taken the way OpenRocket takes it, by the definitions above:
- The apogee is the highest point above where the rocket started. OpenRocket counts altitude from 0 at launch, so HPR Sim counts its center of mass’s height from where it stood on the pad.
- The largest speed is the peak speed on the way up, taken over every sample from launch to apogee. OpenRocket’s rockets come down under parachutes, but HPR Sim’s flight compared here flies none, so its unbraked fall is left out. Until the fin-fillet and inner-tube milestone, HPR Sim ended the search at the first sample whose vertical speed was no longer above zero. A rocket held on the pad can read a few µm/s up or down (#223: a vertical-speed drift on the pad). On one private flight, the drift stopped the search before liftoff.
- The stability margin at rod clearance is the distance from the center of mass aft to the center of pressure, in body diameters. It is taken at the step where OpenRocket’s rocket had just traveled past the rod’s length, at that step’s time and Mach number.
The design checks are HPR Sim’s tests of whether the parts fit together. Where they only warn, HPR Sim flies the design as OpenRocket does. The comparison flies even a design with errors, and the report lists any errors. They find none on OpenRocket’s examples. The Deployable payload’s payload mass component and parachute are 25 mm (0.98 in) across in a 21 mm (0.83 in) bore. They can’t go in as written, but as packed parts they warn (a packed part wider than its bore). The two pods examples write each centering ring as a child of the 18 mm motor mount it wraps. A ring around its tube is checked in the part around it, at its own station (the rule, the milestone that added the check). Pods--airframes and winglets’ rings fit its airframe. Of Pods--powered’s, one fits the booster’s airframe. The other, in a coupler, reaches 0.76 mm (0.030 in) past the coupler’s 31.45 mm (1.2 in) bore: a fit to sand, so it warns. Elsewhere the checks give only warnings (the decision on which fits warn). One is a coupler whose wall reaches 0.46 mm (0.018 in) past the bore it sits in, a fit within the tolerance for that size. Another is bulkheads sized to the airframe on the ends of couplers, which are caps. The third is a 29 mm motor in a 28.956 mm (1.14 in) mount, which its real case fits.
The record holds 57 powered configurations. These fly since the milestone each item names:
- The two payload designs, whose payload drops away with nothing left to burn, since a payload’s split.
- The three-stage example, since several separations.
- Pods--airframes and winglets, since fins on a nose cone.
- Three of the four configurations of Pods--powered with recovery deployment, since screw heads and motors in several pod sets. Its first, which OpenRocket aborts, flies since a stage’s first burnout.
- Both of Parallel booster staging, since parallel stages.
The other 3 are listed in the report with the reason HPR Sim doesn’t fly them yet. The reason is a motor with no thrust curve, among them the one powered Loft demo.
Of the other six Loft demos, five have no motor OpenRocket finds, and OpenRocket does not open
demo-quirks.ork.
Where to find it. The committed report has every flight’s figures, and its JSON twin the same with more digits. Flying them needs the pinned OpenRocket jar and the record of OpenRocket’s motor database, which only a local checkout holds. CI does not fly them again. It checks that every figure of OpenRocket’s in the report is the record’s, and that every outcome, summary and table follows from HPR Sim’s figures.
Results (HPR Sim less OpenRocket):
| metric | named cause | flights | median | range |
|---|---|---|---|---|
| apogee | none | 36 | −0.18% | −4.34% to +1.95% |
| apogee | OpenRocket’s parachute opened before apogee | 15 | +0.10% | −1.24% to +13.80% |
| apogee | HPR Sim’s own drag, sized on OpenRocket’s | 1 | +6.95% | +6.95% |
| apogee | the rocket turns over before apogee in both tools | 1 | −37.93% | −37.93% |
| largest speed | none | 51 | +0.46% | −0.69% to +6.10% |
| largest speed | HPR Sim’s own drag, sized on OpenRocket’s | 1 | +6.40% | +6.40% |
| largest speed | the rocket turns over before apogee in both tools | 1 | −15.76% | −15.76% |
| margin at rod clearance | none | 53 | −0.0003 cal | −1.0768 to +0.0764 cal |
The margin’s −1.0768 cal is the Tube fin rocket’s, whose tube fins’ center of pressure the two programs place differently (aerodynamics: Tube fins). The +0.0764 cal is the Pods--airframes and winglets example’s on an A8-3. Its five flights read +0.0706 to +0.0764 cal, HPR Sim’s margin above OpenRocket’s, the flattering side (#325, #326). The three Pods--powered with recovery deployment flights read +0.0695 to +0.0702 cal, on the same side. The other 44 flights’ margins are within −0.0580 to +0.0045 cal. Below −0.0151 cal are only the three-stage example’s three, −0.0387 to −0.0580 cal.
The rocket’s mass and center of mass, over the same 53 flights (HPR Sim less OpenRocket):
| quantity | flights | median | range |
|---|---|---|---|
| mass at launch | 53 | +0.008% | −0.016% to +0.209% |
| mass as the rocket leaves the rod | 53 | +0.012% | −0.030% to +3.257% |
| center of mass as the rocket leaves the rod | 53 | +0.0007 cal | −0.0028 to +0.0624 cal |
A positive center-of-mass difference means HPR Sim’s is further aft than OpenRocket’s. That shortens the margin by the same number of calibers. So the flight at +0.0624 cal, the three-stage example on an A8-5, is also the one whose margin is 0.0580 cal short.
- Mass doesn’t explain the apogee misses with no named cause. On 35 of those 36 flights HPR Sim’s mass is within 0.05% of OpenRocket’s at launch. As the rocket leaves the rod it is within 0.04% too, on all but four. The first is the two-stage example on two H148R-0 motors, where HPR Sim is 1.65% heavier. The second is the three-stage example on C6 motors, 3.26% heavier (see below). The other two are the two Parallel booster staging flights, 0.041% and 0.063% heavier. The 36th, the Base drag hack on a C11-5, is 0.21% heavier, which would lower its apogee, yet it reads 1.95% high. On the largest miss, Dual parachute deployment with a J570W (−4.34%), HPR Sim is 0.01% lighter as it leaves the rod. That would raise its apogee, not lower it.
- The largest launch-mass differences are on the Base drag hack. Its three flights are 0.18% to 0.21% heavier at launch, which would lower their apogees, yet all three read high. As the rocket leaves the rod, only the two-stage flight on two H148R-0 motors (+1.65%) and the three three-stage flights (+1.80% to +3.26%) differ more.
- The largest center-of-mass differences are on two designs. The three-stage example’s three flights are +0.043 to +0.062 cal, as the rocket leaves the rod. That is the moment OpenRocket’s recorded mass reads light (#185, above). The six Dual parachute deployment flights are +0.010 to +0.016 cal, and they account for almost all of those flights’ margin difference. That design overrides a part’s mass, covering everything inside it, which HPR Sim applies as OpenRocket does. So its launch masses match exactly, and the matched mass says nothing about HPR Sim’s own mass model there. Every other flight is within 0.0054 cal, the most the Pods--airframes and winglets example on a D16-6.
An early parachute can move only the apogee, which is why more flights count toward the largest speed than toward the apogee. The early-parachute group’s median means little. On a rocket whose parachute opens only a little early, the parachute’s cost and HPR Sim’s own miss can cancel. The largest speed’s +6.10% is the Base drag hack on an E12-4, the same drag coefficient that leaves its apogee high (below).
A named cause, and its size. A named cause is only a guess until it is sized (sizing the causes; the decision). So for every flight with a named cause, the oracle flies OpenRocket’s same configuration again with the cause taken out. The report compares HPR Sim’s apogee with that flight too. Nothing else changes between the two OpenRocket flights. So the difference between them is what the cause costs in OpenRocket. What is left against HPR Sim is what the cause does not explain. A cause counts as sized to the bar when every such flight is within the same 5% of HPR Sim’s. Each of those flights has all its causes taken out.
-
HPR Sim’s flight compared here flies no parachute. Its descent is compared on a second flight, with the devices (flown as OpenRocket flies them). With a short motor delay, OpenRocket’s parachute opens while the rocket is still climbing, and stops it lower. Take the A simple model rocket example with a C6-3. Its parachute opens 2.99 s before the apogee the same flight reaches with nothing deployed. OpenRocket’s apogee is 280.2 m (919 ft), and HPR Sim’s, with no parachute, is 318.9 m (1,046 ft): +13.80%. Flown again with nothing deployed, OpenRocket climbs to 322.4 m (1,058 ft), and against that HPR Sim reads −1.08%. On the 3D printable nose cone and fins example the same pair reads +12.18% and −0.16%, and on the Clustered motors example +9.43% and −0.72%.
-
The check both ways. A test (
a_parachute_moves_openrockets_apogee_only_when_it_opens_before_itinxtask/src/ork_flights.rs) runs over all 56 flights of OpenRocket’s record that finished. On the 41 whose parachute opens at or after apogee, the flight with nothing deployed reaches exactly the same apogee, to the last bit. Nothing else differs between the two runs. On 14 of the 15 whose parachute opens before apogee, the flight with nothing deployed climbs higher. The 15th opens only 0.10 s early, and its two apogees differ by 1 mm (0.039 in). OpenRocket records that flight every 0.05 s near the top. Its highest recorded point can move by up to 3 mm (0.12 in) with timing alone, and 1 mm (0.039 in) is within that. -
A part set to no drag flies as OpenRocket flies it, since the milestone for a part’s drag override (the decision). The Base drag hack (short-wide) example is a short, wide rocket with four fins. Behind it sits a weightless cone, flaring from a point to the body’s full width. OpenRocket is told the cone has no drag. That is a modelers’ trick for stubby rockets: it moves the center of pressure aft, since the cone still gives lift. Before that milestone, HPR Sim read the setting but charged the cone the drag of its shape (#165, the drag override not applied). Now it flies the cone with no drag, as OpenRocket does (A part’s stated drag coefficient). HPR Sim’s apogee against OpenRocket’s:
motor before now now, recovery in both now, against OpenRocket’s flight with nothing deployed C11-5 −16.77% +1.95% +1.95% +1.95% D12-3 −15.47% +12.96% +4.52% +5.84% E12-4 −19.13% +10.79% +7.80% +8.92% The “recovery in both” column is the apogee of each flight’s descent in the report’s JSON (
descent.apogee_m), also in the decision’s table. The C11-5’s parachute opens after apogee, so it changes nothing there. On the D12-3 and E12-4 OpenRocket’s parachute opens 1.80 s and 1.24 s before apogee, while HPR Sim’s flight in the “now” column flies none. That early parachute is the named cause of +12.96% and +10.79%. With it held in OpenRocket too, the D12-3 and E12-4 still read 5.84% and 8.92% high, more than 5% off. Flown on OpenRocket’s own drag along that flight, HPR Sim comes within 0.10% of it. So what is left is the drag coefficient, not the setting.
What the causes leave. On the three C6-3 flights, what is left is −0.16%, −1.08% and −0.72%, like the flights with no named cause. The Deployable payload’s C6-3, +13.75% against OpenRocket’s flight, is left at +2.63%, but that pair is not like for like. In OpenRocket’s flight with nothing deployed the payload still drops its booster and climbs on alone. HPR Sim’s flight compared here climbs as the whole stack. The Base drag hack reads high on all three motors, +1.95% to +8.92% with nothing deployed in either program, more so on bigger motors. That is more than any other flight with no named cause reads high. Of the 35 other such flights, 22 read low. The 13 that read high are at most +1.23%. They are the five Airstart timing flights, four Pods--airframes and winglets flights and the two Parallel booster staging flights. The rest are the two payload examples’: the ARC payload rocket and the Deployable payload on an A8-3.
A one-off check compared the two programs’ drag part by part at the same speeds. It is not part of the report. It suggested two candidates, both on the side of HPR Sim flying higher. The report now sizes one of them, and nothing here measures which program is right.
- The nose. OpenRocket charges this very blunt, rounded nose, whose length is only 0.58 of its diameter, some pressure drag even at low speed. Its coefficient, referenced to the body’s cross-section of 48.7 cm², goes from 0.0117 at Mach 0.1 to 0.0482 at Mach 0.25. That is about the fastest these flights go. HPR Sim charges it 0.0008. That is read off a straight line between two round heads Hoerner measured. A hemisphere reads 0.01 and a head one diameter long reads −0.05 (blunt ellipsoids; a blunt ellipsoid’s measured drag). A one-off probe, not committed, found that bringing the E12-4 within 5% would take about 0.013 to 0.015, more than the hemisphere’s. HPR Sim keeps the measurement, and the gap stays. By OpenRocket’s breakdown, this is where the drag coefficient differs.
- The base while the motor burns. HPR Sim takes the motor’s area off the base drag while it burns, and OpenRocket 24.12 doesn’t. The report flies HPR Sim again with OpenRocket’s base drag under power. On the D12-3 and E12-4 it reaches the same apogee as on its own drag, so this candidate moves nothing on this rocket.
#177 (a very blunt nose’s drag below Mach 0.8) holds the numbers. The decision record holds the measurement and the decision.
The margin, part by part. The report also lists the parts of each margin at rod clearance. They are the mass, the center of mass, the center of pressure and the reference diameter. The reference diameters agree exactly, and the centers of pressure within 0.25 mm (0.0098 in) on every flight but two examples’. The Tube fin rocket’s tube fins put HPR Sim’s 26.6 mm (1.0 in) forward of OpenRocket’s. On Pods--airframes and winglets HPR Sim’s is 2.6 mm (0.10 in) aft. Apart from those two and the three-stage example’s (above), the largest margin gaps are on the Dual parachute deployment example, −0.0097 to −0.0151 calibers. HPR Sim’s center of mass is 0.6 to 0.9 mm (0.024 to 0.035 in) aft of OpenRocket’s there. Mass times that gap, from the report’s JSON figures, stays between 1.1 and 1.35 g·m on all six motors. Over those motors the rocket’s mass runs from 1.49 to 2.18 kg. So the gap is probably in the airframe, not the motors, but it is not traced yet.
What it leaves out. Every flight is calm and vertical, with no wind and no recovery. One
flight, the Dual parachute deployment example on a J570W, is briefly faster than sound
(OpenRocket’s largest Mach number is 1.147). The other 52 stay below Mach 0.72, so this barely
tests HPR Sim faster than sound. That flight is also the largest gap with no named cause: −4.34% in
apogee, with its largest speed −0.69%. The Earth is not the same in both programs. HPR Sim’s is the
WGS 84 ellipsoid, with its gravity and rotation. OpenRocket’s runs record
a flat Earth for 23 of the 53 flights and a spherical one for the other 30 (the record’s
geodetic field). Each program keeps its own
model, and the effect of the difference is not measured. The decision is in
its decision record.
Staged, clustered and air-start flights
HPR Sim flies three kinds of flight it used to leave out. They are a rocket that drops a booster, a cluster of motors, and an air start. It has flown them since the milestone that added them. The bar was written down before any of them was measured (the decision record). It is that every flight of a design is within 5% of OpenRocket’s apogee and of its largest speed. Where OpenRocket’s parachute opened before apogee, the apogee is held to OpenRocket’s flight of the same configuration with nothing deployed. All three designs meet it. So does a fourth, the three-stage example, flown since the milestone for several separations. A fifth staged design, Pods--powered with recovery deployment, flown since the milestone for its pods, does not. In the conditions of OpenRocket’s record its sustainer turns over before apogee in both programs (above). Its first configuration, which OpenRocket aborts, is checked up to the abort instead (below). A sixth, Parallel booster staging, flown since the milestone for parallel stages (Parallel stages), meets it. The figures are HPR Sim less OpenRocket:
| design | what it tests | flights | apogee | largest speed |
|---|---|---|---|---|
| Two stage high power rocket | a booster that separates, and a sustainer lit after it | 2 | −1.79% and −0.13% | −0.54% and −0.04% |
| Three stage low power rocket | a booster, then a middle stage, each dropping at its burnout as the stage ahead lights | 3 | −1.48% to −0.95%, two against the flight with nothing deployed | +0.25% to +1.64% |
| Clustered motors | four motors in a 4-ring, one in each tube | 5 | −0.79% to −0.35%, three against the flight with nothing deployed | +0.20% to +0.92% |
| Airstart timing | a 3-ring of I211W motors beside a K550W in its own mount, the ring lit at launch or 1, 2, 4 or 6 s later | 5 | +0.48% to +1.03% | +0.46% to +0.81% |
| Parallel booster staging | two boosters beside the core, lit with it at launch and dropped at their charge at 2.44 s; or carried to apogee with no motor | 2 | +1.23% and +0.68% | +3.25% and +1.56% |
- The two-stage flights separate when OpenRocket’s do, at 1.535 s and 1.515 s after launch (the decision record). OpenRocket’s record keeps the part with the nose, so both programs’ apogee and largest speed are the sustainer’s. For its descent, HPR Sim gives the booster a recovery device that opens at the split and the sustainer one that opens at its apogee. Neither acts on the climb, which is what is compared. How HPR Sim flies a separation is in Staging.
- The three-stage flights separate twice when OpenRocket’s do, at 0.857 s and 1.714 s on the B6-0 boosters. On the C6-0s they are at 1.860 s and 3.720 s. The two splits come at the booster’s burnout, then at the middle stage’s. HPR Sim flies each split in turn, from the tail forward (Several separations). The sustainer lands within 0.009% of OpenRocket’s landing speed on each.
- The rocket a configuration builds doesn’t carry the separations. The reader hands them
over separately, as the configuration’s
stagingandlater_stagings(MotorConfiguration::stagingslists them all, from the tail forward). A program turns them into the flight’s separations withhpr::ork::separationsand passes those to the flight. HPR Sim refuses that flight unless each part has a recovery device, so the example gives both parts one.hpr::ork::separated_recoverygives each part the file’s own devices instead.hpr simflies a powered separation that way (Separation). The exampleork_two_stage.rsdoes this for a made-up two-stage.ork. Run it withcargo run --example ork_two_stage -p fusionspace-hpr. - On two H148R-0 motors, OpenRocket’s rocket gets lighter twice as fast before the sustainer lights. From launch to rod clearance it loses 0.0823 kg, and HPR Sim’s 0.0412 kg: 1.9992 times as much. The launch masses agree, so HPR Sim is 1.65% heavier as it leaves the rod. On the other configuration, with two different motors, the two programs lose the same mass. OpenRocket’s recorded mass falls as if both H148Rs lost propellant from launch. The three-stage example shows the same. OpenRocket’s drop is 2.0000, 1.9998 and 2.9944 times HPR Sim’s, the count of motors of the booster’s type in each configuration. So HPR Sim is 1.80% to 3.26% heavier as it leaves the rod. What that does to the apogee is not sized (#185).
- Three of the cluster flights have a parachute that opens early in OpenRocket, 0.37 s, 2.59 s and 0.59 s before apogee. Against its own record, the C6-3 reads +9.43%; against its flight with nothing deployed, −0.72%.
Flights OpenRocket aborted
HPR Sim’s flight of Pods--powered with recovery deployment’s first configuration,
[C6-7; 2× A3-4, B6-0], is within 5% of OpenRocket’s at two points up to where OpenRocket
stops. That is a check of the climb’s first 1.81 s, not of an apogee. OpenRocket aborts the
flight at 1.81 s: “Stage began to tumble under thrust.” Its record then has no apogee, largest
speed or margin, so the first table withholds them. Up to the abort the record is a flight like
any other. So cargo xtask ork-flights compares HPR Sim’s height above its start and its speed at
two points. The first is OpenRocket’s separation: its row just after the split, against HPR Sim’s
sample at its separation event, the whole stack’s center of mass. The second is OpenRocket’s last
row. The check is met when both separate at the same time and each value is within 5% of
OpenRocket’s. That is the band an apogee gets before it needs a written cause
(the decision record):
| OpenRocket (s, m, m/s) | HPR Sim (s, m, m/s) | difference | |
|---|---|---|---|
| separation, s | 0.86 | 0.86 | 0 s |
| height at the separation, m | 22.44 | 22.18 | −1.17% |
| speed at the separation, m/s | 46.08 | 46.06 | −0.04% |
| height at OpenRocket’s last row (1.81 s), m | 85.0 | 84.0 | −1.18% |
| speed there, m/s | 76.8 | 79.9 | +4.02% |
This is weaker evidence than an apogee. It is two points on the way up, and the second is where OpenRocket’s flight is breaking up. When OpenRocket aborts is its own call, too. The committed probe of this configuration with nothing deployed (Delays and ignition) aborts at 2.40 s, not 1.81 s.
The booster’s B6 burns out first, so the booster drops at 0.86 s with both pods’ A3s still
burning, as in OpenRocket (Delays and ignition). Its least static margin,
in the weakest plane, is −4.21 calibers at the split: the same unstable sustainer as
[C6-7; B6-0] (above). The +4.02% in speed comes just as both rockets start to turn over.
OpenRocket’s speed peaked at 77.5 m/s (254 ft/s) and is falling at its last row, while HPR Sim’s still climbs.
The report’s
Flights OpenRocket aborted
section has the row.
Whether HPR Sim’s sustainer turns over depends on how it is launched. In the record’s
conditions, a 0.15 m (0.49 ft) rod at 28.61° N with no wind, HPR Sim’s sustainer turns over at
2.04 s. Its angle of attack is then past 90°. From hpr sim’s defaults, a 1.5 m (4.9 ft) rail with no
wind, it does not. So the apogee hpr sim prints assumes the unstable sustainer stays upright.
Why the two launches differ is not traced
(evidence row G17). hpr sim prints the least margin of −4.21 calibers with
a warning. The warning says the rocket is unstable under power and its apogee is not a prediction
(Flight metrics: unstable under power;
#335).
A tilted launch rod
HPR Sim flies a tilted launch rod the way OpenRocket records it (the tilted-rod work, issue #173). The check is only against OpenRocket, on one small probe airframe and one private design, from a 1 m (3.3 ft) rod in calm air. Three things are not tested. One is a tilted rod in wind (or with OpenRocket’s launch into wind setting). The others are a longer rod and the rocket’s roll on the rod.
OpenRocket stores the rod’s angle from the vertical and the compass bearing it leans toward, as
the conditions probe found. The flight comparisons here give HPR Sim’s
rail the same bearing and an elevation of 90 degrees less the tilt. A rod 10 degrees from the
vertical is a rail at 80 degrees. Like the vertical rod before it, the rail has no friction. The
conversion is in the comparison tool (cargo xtask ork-flights), which takes the conditions from
OpenRocket’s record. The .ork reader stores the file’s degrees as radians, as the table above
says. Loading a design does not set up a rail, though: a program that flies it gives its own.
How it was checked. Four small probe designs fly the airframe of the
pod probes in both programs. The airframe is a 0.2 m (0.66 ft) cone and a
0.6 m (2.0 ft) tube 60 mm (2.4 in) across. It has three fins and an AeroTech H128W. The rods are tilted
5° toward north, 10° toward east, 10° toward south-west and 20° toward east. The same airframe
from OpenRocket’s default vertical rod (pods-none) is the control. From the
public report’s table
(September 27, 2026):
| rod | apogee lost to the tilt, OpenRocket | HPR Sim | where the rocket is at apogee, OpenRocket | HPR Sim |
|---|---|---|---|---|
| 5° toward north | 0.65% | 0.63% | 99.2 m (325 ft) north | 98.5 m (323 ft) north |
| 10° toward east | 2.60% | 2.52% | 195.0 m (640 ft) east | 194.3 m (637 ft) east |
| 10° toward south-west | 2.60% | 2.54% | 138.5 m (454 ft) west, 138.1 m (453 ft) south | 138.1 m (453 ft) west, 137.6 m (451 ft) south |
| 20° toward east | 10.09% | 9.82% | 370.6 m (1,216 ft) east | 369.6 m (1,213 ft) east |
At apogee both rockets are on the same bearing from the pad to within 0.03 degrees. HPR Sim’s is
at most 0.64% nearer. In calm air, the direction of the tilt changes only where the rocket goes,
not how high: the two 10° rods lose the same apogee. The test
tilted_rods_fly_as_openrocket_flies_them (in xtask/src/ork_flights.rs) holds each probe to
three bounds. The bearing must agree within 0.1 degrees of OpenRocket’s, the distance within 1%, and
the apogee it loses within 0.5 percentage points (the tilted-rod decision). The small differences left are partly OpenRocket’s
position being read from its highest recorded step rather than the apogee itself. They are partly
sideways motion across the tilt. HPR Sim’s fits Earth’s rotation in sign and size. OpenRocket’s
goes the other way and has no measured cause.
What differs: the margin. OpenRocket’s rocket reaches its first step past the rod’s end (rail exit) at a small angle of attack. The angle grows with the tilt: none from the vertical rod, 0.116 degrees at 10 and 0.228 at 20. Its center of pressure moves forward with the angle, so its stability margin falls, by 0.016 calibers at 20 degrees. HPR Sim takes the margin at no angle of attack, so there the margins part by 0.017 calibers. Taken at OpenRocket’s angle, HPR Sim’s margin falls by 0.012 calibers, to 0.005 from OpenRocket’s. So most of the gap is the angle at which each program looks. The rest grows with the tilt too, because HPR Sim’s center of pressure moves about a fifth less than OpenRocket’s for the same angle.
Vertical rods too. OpenRocket records a direction for a vertical rod as well (90 degrees by default). On a vertical rail it only sets which way the fins face on the pad. Taking it as recorded moved the public flights’ apogees by under 0.001%. That is enough to change one rounded apogee in the report by 0.1 m (0.33 ft).
OpenRocket’s flights of the private designs
These are the counts of OpenRocket 24.12’s flights of the private design library, the corpus.
It is 27 .ork files, which stay out of this repository
(OpenRocket flies the corpus). The designs are flown the
same way as the public designs. Every motor
configuration is flown in calm air, from the launch conditions of
the design’s first stored simulation. HPR Sim’s flights
of them are compared below.
The flights are written to the gitignored corpus-out/, because a flight’s numbers can identify
someone’s design. Only counts are published. cargo xtask ork-flights --corpus prints them from that
record, and never prints a file name.
Counts on September 25, 2026, by where the design was found. Distinct means distinct in content (by SHA-256 hash). Flown to the end means the simulation ran to its end, not stopped by OpenRocket (aborted). The last row shows each such flight recorded the stability margin the next comparison needs.
| the private library | OpenRocket’s examples | elsewhere under refs/ | |
|---|---|---|---|
| design files | 27, all distinct | 17 | 31, 25 distinct |
| refused by OpenRocket | 0 | 0 | 4 |
| configurations declared | 89 | 56 | 24 |
| with no motor OpenRocket loaded | 1 | 0 | 16 |
| aborted by OpenRocket | 0 | 1 | 0 |
| flown to the end | 88, in all 27 designs | 55, in all 17 | 8, in 4 designs |
| with a margin at rod clearance | 88 | 55 | 8 |
- OpenRocket flew every configuration of the private library it loaded a motor into. None was refused and none aborted.
- The one configuration without a motor names one in its file, with its thrust curve’s digest. OpenRocket loaded no motor for it, so it had nothing to fly.
- The record doesn’t keep OpenRocket’s warnings on loading a file, or the digest of the thrust curve each flight used. So a flight on a curve other than the one saved in the file would not show here. HPR Sim’s comparison checks each curve against the motor record before it compares (below).
- 15 of the 27 files are public designs: 13 are the very files of OpenRocket’s examples, and two are edited copies of examples. So the library holds 12 private designs, other people’s.
- All 27 files have a stored simulation, so every flight took its launch conditions from the design’s first one. As those simulations were set, OpenRocket flew 64 of the 88 on a spherical Earth and 24 on a flat one. HPR Sim uses the WGS 84 ellipsoid. The effect of that difference is not measured yet.
- The examples column is a new run of the 17 examples inside OpenRocket’s jar. It repeats the run described in OpenRocket’s flights of the public designs, with the same 56 configurations and one abort. That earlier run’s 57 also counted a Loft demo, which is in elsewhere here.
- Elsewhere is mostly the test and demo designs of Loft and
Debrief, the two projects this one took over. It also holds one private design log’s
.orkand nine from OpenRocket’s database repository. OpenRocket refuses four of them. Most of their configurations have no motor. - Left out: the library’s 4 RASAero
.CDX1and 4 RockSim.rktfiles. HPR Sim can’t read either format yet, so there is nothing to compare them with. The flight script fails on three of them (#168). The decision is recorded in the corpus decision.
To repeat it, you need the private library under refs/, which most readers won’t have. You also
need Java 17 and the OpenRocket jar (cargo xtask refs fetch), as for the
mass comparison. Then, from the repository root:
# --jar also flies the 17 examples inside OpenRocket's jar
refs/venv/bin/python validation/oracles/openrocket/flights.py \
corpus-out/openrocket-flights.json refs --jar
cargo xtask ork-flights --corpus
The simulator’s flights of the private designs
HPR Sim’s flights of the 12 private designs are compared here with OpenRocket’s (HPR Sim’s flights of the corpus). The definitions are the same as in the public comparison, which does this for OpenRocket’s examples. It is a code-to-code comparison with no target, and HPR Sim flies 11 of the 12 designs.
On four of them, C03, C06, C08 and C09, HPR Sim’s stability margin is clearly larger than
OpenRocket’s. So it calls those rockets more stable than OpenRocket does. C03 and C09 are open
(#172). C08 has a lead
(#186). C06’s gap is mostly its
center of mass. A likely cause is its airfoil fins, which OpenRocket weighs at 0.85 of a slab and
HPR Sim at 0.6851 (the mass survey’s fin-section cause).
That cause is sized on the structure alone, not on this flight. A fifth, C12, reads larger too,
but mostly because it leaves a tilted rod at an angle of attack (below).
One flight, the only supersonic one, climbs 13.60% higher than OpenRocket’s, and the cause is the drag coefficient (below). Nobody without the private library can fly these flights again. CI checks only that the report adds up and names nothing of a design.
How far it gets. The OpenRocket comparison asks for at least 20 designs compared in five ways: apogee, largest speed, stability margin, mass and center of mass. With the public report’s 15, these make 26, so that count is met. Its mass conventions are rolled up too. Two checks carried over from Loft end it (below). One passes. The other, the tube-fin center of pressure, is missed, with the gap measured and pinned.
Staging and clusters (the staging milestone) added one of these
private designs and three public ones. A tilted launch rod
(the tilted-rod work) added one private design, and reading
the old override flag as OpenRocket does
(the override-flag work) added another. Weighing fin fillets
and reading an automatic radius inside a nose cone added two more, C01 and C06.
The work is in the fillet and radius milestone and
#174: airframes read simpler than written.
Flying tube fins
(the tube-fin work) added OpenRocket’s Tube fin rocket.
The twentieth, C04, flies since the unlit-motor work.
One of its motors is set to light at an event that never comes. HPR Sim now flies that motor
unlit, as OpenRocket does (above). HPR Sim’s apogee is 0.88% above
OpenRocket’s (the report’s row C04/1). It is a staged flight, the kind in which OpenRocket’s
recorded mass has gone wrong before
(#185). A check run locally on the
private file, not committed, found OpenRocket’s mass falling by each burning motor’s propellant
along this flight. So that fault does not show there, but no committed check holds it.
Two checks carried over from Loft, the project before this one, end the comparison (the closing checks). The error-statistics check passes. The tube-fin check does not, and its gap is measured instead:
- Tube fin center of pressure: a tube fin set’s center of pressure should be within a quarter caliber of OpenRocket’s. It is not. On the Tube fin rocket HPR Sim’s is 1.07 calibers forward. That is nearly all of the 1.08 calibers between the two margins, HPR Sim’s 0.79 and OpenRocket’s 1.87. A test measures and pins the gap on 14 probe designs and on this rocket. Nothing measured says which code is nearer (tube fins).
- Error statistics: a case let off a pass-or-fail bar still counts in the
error statistics. A test holds the accuracy census to it. Every
number the reports compare is counted, including the misses that have a written cause or
explanation. A rocket with two references counts against both: RocketPy’s flight of Juno III,
for one, and its team’s altimeter log. The results stored inside
.orkfiles never enter the census, so this does not cover them.
Still not flown:
- stages HPR Sim can’t separate yet: the second of the two private designs the old override flag was blamed for. Its flag reads the same either way. What holds it is a separation that comes while a motor behind it still burns. The two public payload designs that waited here fly since a payload’s split was read;
- none held back by what HPR Sim leaves out any more. The library’s copy of Parallel booster staging flies since HPR Sim read parallel stages. The pods themselves fly since the pod milestone. The cockpit on Pods--airframes and winglets’ nose flies since the cockpit work. Pods--powered with recovery deployment was once held back by its rail buttons’ screw heads. It flies since the screw-head work.
What is published. The designs are other people’s, so the
report
holds only differences, each HPR Sim’s number less OpenRocket’s. They are in per cent for apogee,
largest speed and mass. They are in calibers (OpenRocket’s reference diameters) for the
stability margin, the center of mass (CG) and the center of
pressure (CP). A design’s own values are never written: next to its difference, HPR Sim’s value
would let anyone work out OpenRocket’s, and so the design’s. Each design is an id, C01 to C12,
in the order of its file’s SHA-256 hash. Each flight is the design’s id and the configuration’s
place in the file: C09/2 is the second configuration of design C09. A CI test checks that the
report holds only these ids, reasons and differences from fixed lists. The differences are rounded
so that no rounding residue gives a value back. The test also checks that the summary matches its
rows.
Which flights are compared. HPR Sim flies a configuration only when it can show both programs used the same thrust curves. Each curve must be the one saved in the design file. Or it must come from OpenRocket’s motor database, matched by its digest (OpenRocket’s fingerprint of a curve). The record of OpenRocket’s run must also show it loading exactly those curves. One configuration is left out because HPR Sim’s curve came from its own catalog, found by the motor’s name. A tilted rod is flown as recorded, as in A tilted launch rod.
The 35 flights (from the committed report):
| metric | flights | median | from | to |
|---|---|---|---|---|
| apogee, no named cause | 28 | −0.25% | −4.84% | +1.17% |
| apogee, OpenRocket’s parachute open before apogee | 6 | −0.32% | −3.09% | +2.15% |
| apogee, HPR Sim’s own drag coefficient | 1 | +13.60% | +13.60% | +13.60% |
| largest speed, no named cause | 34 | +0.27% | −0.65% | +2.28% |
| largest speed, HPR Sim’s own drag coefficient | 1 | +7.98% | +7.98% | +7.98% |
| margin at rod clearance | 35 | +0.0308 cal | −0.0166 cal | +0.1108 cal |
| mass at launch | 35 | +0.000% | −0.770% | +0.070% |
| center of mass at rod clearance | 35 | −0.0004 cal | −0.1102 cal | +0.0198 cal |
For example, C09/9 reads −4.84% in apogee: HPR Sim’s rocket peaks 4.84% lower than OpenRocket’s on
the same design and motor. Its largest speed is +0.26%, so the two agree on the climb under thrust
and part on the coast, where drag matters most.
- One apogee is more than 5% from OpenRocket’s:
C06/1, +13.60%. Its cause is sized below. No flight has a part with a drag override. - An early parachute lowers OpenRocket’s apogee, so it can make HPR Sim read high but not low. It
cannot explain the four that read low (
C03/3,C03/4,C02/4,C02/5). It could explainC07/1, which reads +0.68% with the parachute 0.55 s early. It could also explainC02/2, which reads +2.15% with the parachute 1.45 s early, the longest of the six. How much of either it explains is not measured. - The 14 flights of
C03andC09, launched above sea level, all read low in apogee. The 15th above sea level,C06/1, reads high for its drag (below). Of the 20 at sea level, the 4 ofC07,C08andC11read high. So doesC04/1, flown since a motor that never lights flies.C01, flown since fillets are weighed, reads once each way.C02, flown since pods fly, reads high once and low four times.C05, flown since the old override flag is read as OpenRocket reads it, reads high four times and low once, all within 0.26%.C12, flown since a tilted rod flies, reads high once and low twice. Most of the public report’s flights with no named cause read low as well (22 of 36). Every public flight launches at sea level: its record gives a launch altitude of 0 m (0.0 ft) throughout. So altitude does not yet explain the sign. The apogee-cause work sized only the apogees more than 5% off, so this pattern is still untested. - HPR Sim’s margin is larger than OpenRocket’s on four designs: HPR Sim calls them more stable,
the direction to worry about.
C03andC09come first, thenC08andC06/1.C03reads +0.056 to +0.073 calibers. On every flight HPR Sim’s CP sits 0.061 calibers further aft than OpenRocket’s, and the CG accounts for the rest.C09reads about +0.04, half from its CP (+0.020) and half from its CG. HPR Sim puts that CG forward of OpenRocket’s by 0.0145 to 0.0273 calibers. The reference diameters agree on all 35 flights, so the calibers are the same. On the public designs the margin gap is at most 0.0151 calibers. The largest (−0.0151) has HPR Sim calling the rocket less stable. No milestone covers it yet: it is #172. A third design,C08, is a two-stage rocket flown since the staging milestone. It reads +0.1108 calibers because HPR Sim puts its CG 0.1102 calibers forward of OpenRocket’s at rod clearance. The mass there is within about 0.001%. That gap is older than the staging: HPR Sim’s structure alone puts the CG forward by less than the mass survey’s 1% of length. A stage whose mass is set at several times its parts’ own weight magnifies where those parts sit. Two of those parts differ. One is an airfoil fin set, a departure HPR Sim keeps on purpose (the fin decision). The other is packed parachutes whose automatic radius OpenRocket may meet by stretching the packed length (#186). C05reads within 0.0007 calibers on four flights. OnC05/2it reads +0.0113, nearly all from its CG (−0.0111 calibers), with the mass there within 0.005%. Not traced.C06/1reads +0.0604 calibers, +0.0540 at OpenRocket’s angle of attack. Most of it is its CG, 0.0447 calibers forward of OpenRocket’s, with HPR Sim’s mass at launch 0.770% below OpenRocket’s. The mass survey names a sized cause for this design: its airfoil fins. OpenRocket weighs an airfoil fin at 0.85 of a square slab of its outline. HPR Sim weighs it at 0.6851, so HPR Sim’s fins are lighter. Weighed OpenRocket’s way, the design’s structure comes within the survey’s 1% thresholds (the fin-section cause). Those thresholds are coarser than this flight’s 0.0447 calibers. No flight has been flown with OpenRocket’s fin weighting. So the fins are a lead for this gap, not its size.C01reads −0.0166 and +0.0025 calibers. OnC01/1HPR Sim calls the rocket less stable, from a CG 0.0198 calibers further aft.C12, launched from a tilted rod, reads +0.0125 to +0.0366 calibers, nearly all from its CP. OpenRocket’s rocket clears the rod at an angle of attack, as on the probes. With HPR Sim’s CP taken at that angle (the report’s at OR’s ),C12reads +0.0033 to +0.0074. So most of its gap is the angle each program looks at.- HPR Sim’s design checks find errors on 8 of the flights. On
C07/1,C11’s two andC12’s three, an inner part is wider than its parent’s bore by more than the fit tolerance. OnC06/1a motor’s case can’t fit its mount. OnC08/1a fin is off its body tube. On all ofC03’s flights the inner part is within the tolerance, so it only warns (the decision on which fits warn). Such a part puts mass in a slightly different place, not lift, so it cannot move the CP.C03’s CG agrees within 0.013 calibers. - The one design HPR Sim does not fly waits on stages HPR Sim can’t separate as written. In that design, a separation comes while a motor behind it still burns. The report lists each configuration with its coarse reason. The breakdown is in HPR Sim’s flights of the private library and the old override flag.
To repeat it, you need the private library, OpenRocket’s flights of it and the motor record, as above, OpenRocket’s drag curves, and OpenRocket’s nose columns for every library design it flew. Then:
refs/venv/bin/python validation/oracles/openrocket/drag_curves.py \
corpus-out/openrocket-drag-curves.json refs
refs/venv/bin/python validation/oracles/openrocket/nose_columns.py --public \
corpus-out/openrocket-library-nose-columns.json \
refs/*/imported/loft-fixtures/openrocket/*.ork
cargo xtask ork-flights --library # writes the report
cargo xtask ork-flights --library --check # compares with the committed one
A supersonic flight, and a cause in the drag
C06/1 is the first supersonic flight in either OpenRocket report. HPR Sim’s apogee is 13.60% above
OpenRocket’s, and its largest speed 7.98% above. The mass at launch is within 0.77%, and the
difference builds during the burn. No parachute opens early, and no part states its own drag
coefficient. The work on causes for apogees more than 5% off
asks for a written cause with a size, not just a candidate.
Part by part, with the rocket pointing into the airflow, OpenRocket’s drag differs from HPR Sim’s in two ways. They pull opposite ways:
- Base drag while a motor burns. HPR Sim takes the burning motor’s cross-section off the aft
base, following Niskanen (who cites Fleeman for it). A base the size of the motor has no base
drag. OpenRocket 24.12 keeps the whole base’s drag while the motor burns. On
C06the motor fills most of the base, so HPR Sim has less drag under power and climbs higher (Aerodynamics). What OpenRocket does is measured from its own output. Which rule is right is not. On a NACA missile model’s measured flight below Mach 0.8, HPR Sim’s rule reads low (its motor case is wider than its base, so no base drag is left) and the whole base high, and the jet more than doubled the base drag, which neither rule does (the base under power, against a measured flight). OnC06/1the choice moves HPR Sim’s apogee difference from +13.60% to −10.71%, about 24 percentage points. That is more than any other known cause (#222, open on both drag questions).- The measurement is a committed probe,
validation/oracles/openrocket/base_drag.py. It records OpenRocket’s base drag on its own example designs, the rows while a motor burns against the rows after, invalidation/fixtures/ork/openrocket-base-drag.json. Take all 42 of its flights of one data branch (nothing separating). OpenRocket’s base drag while a motor burns is exactly what the whole base gives, to 1e-12 on every one. It does not subtract the motor, even where the motor covers 94% of the reference area. The drag it flies is the sum that includes that base drag. A test inhpr-validateholds it (the decision on sizing a drag cause). - Motors in pods are among them. The one such flight of OpenRocket’s powered-pods example that burns pod motors keeps its base whole too. HPR Sim’s opt-in treats a pod’s motors the same way.
- The measurement is a committed probe,
- Supersonic pressure drag. This is the drag from the pressure on the nose, the fins’ edges and any step faster than sound. Much of it is wave drag. HPR Sim’s is about twice OpenRocket’s, read from OpenRocket’s per-component output but not kept as a record. OpenRocket gives the nose almost none well above Mach 1, and the fins about a quarter of HPR Sim’s. So HPR Sim’s rule gives more supersonic pressure drag than OpenRocket’s (#222: which supersonic pressure drag is right).
How the cause is sized. HPR Sim flies the flight again on OpenRocket’s own drag coefficient. An
oracle, validation/oracles/openrocket/drag_curves.py, flies each configuration as flights.py
does, with nothing deployed. From launch to apogee it records OpenRocket’s drag coefficient as two
curves in Mach number. Power on is the rows while a motor burns, and power off is the rows after
the last one that burns. cargo xtask ork-flights --library flies HPR Sim on them as a
drag table. It does so for any apogee more than 5% off with no other
named cause and no stage separation. Where HPR Sim’s apogee then comes within 5% of OpenRocket’s,
the apogee’s cause is HPR Sim’s own drag coefficient. The same goes for the largest speed, judged
on its own number. That says the difference is in the drag, not which drag is right. So each such
flight also gets a written breakdown, held by a test
(the decision on sizing a drag cause).
The report also flies HPR Sim’s own drag with OpenRocket’s base rule alone, through
Simulation::with_full_base_drag_under_power (Aerodynamics):
C06/1, flown by HPR Sim on | apogee | largest speed |
|---|---|---|
| its own drag | +13.60% | +7.98% |
| OpenRocket’s drag coefficient | +1.11% | +1.04% |
| its own drag with OpenRocket’s base rule | −10.71% | −3.43% |
| its own drag with OpenRocket’s nose column | +31.73% | +13.32% |
| its own drag with OpenRocket’s nose column and base rule | +0.45% | +0.82% |
On OpenRocket’s drag the flight is within the 5% bar, so the drag is the cause. Switching HPR Sim to OpenRocket’s base rule alone lowers its apogee from +13.60% to −10.71%, 24.3 percentage points. Switching the rest of the drag to OpenRocket’s then raises it to +1.11%, 11.8 percentage points. A look at OpenRocket’s per-component columns, not kept as a record, points that rest to the supersonic pressure drag. The second number is by subtraction, and the split depends on which change is made first. Which supersonic pressure drag is right is open. Neither code has been checked against a measurement on this shape, and the public report has no supersonic flight.
The last two rows swap the nose. Any flight that passes Mach 1 in HPR Sim before its apogee, with
a tangent-ogive nose at the front of its airframe, is flown twice more, or skipped under a reason
the report names. Each time, the nose’s pressure drag above Mach 1 is OpenRocket 24.12’s for that
nose, its column, not HPR Sim’s: once with HPR Sim’s own base drag, and once with OpenRocket’s
base rule as well. The rest of the drag stays HPR Sim’s.
validation/oracles/openrocket/nose_columns.py --public records each library design’s column in
the gitignored corpus-out/openrocket-library-nose-columns.json. The report’s last part lists
each such flight, swapped or skipped with its reason. Two library flights qualify, and both are
swapped. They keep HPR Sim’s own thrust and mass, since the library holds no record of
OpenRocket’s against time. So this is not
the tangent-ogive nose’s line of the private
collection, which is taken on OpenRocket’s.
Above Mach 1, OpenRocket’s column is far below HPR Sim’s pressure drag of the nose
(OpenRocket’s issue #3391). On
the public probe,
OpenRocket’s is 0.6% to 32.2% of HPR Sim’s from Mach 1 to 1.3, and under 1% at Mach 1.3, 1.5
and 2. Flown on that column, HPR Sim has less drag and climbs higher. On C06/1 the column alone
raises the apogee from +13.60% to +31.73%.
With OpenRocket’s base rule as well, C06/1’s apogee comes to +0.45%. That is 0.66 percentage
points below the flight on OpenRocket’s whole drag coefficient, +1.11%. By subtraction again,
with the base rule already in: from its −10.71%, the nose column adds 11.16 of the 11.82 points
that the rest of OpenRocket’s drag adds. So on this flight the two rules, the base under power
and the nose’s pressure drag, leave under a point of the gap.
That holds for one flight, not for the library. C03/5, transonic and within 5% of OpenRocket’s,
moves from −4.83% to −3.35% with the column, and to −6.97% with the base rule as well. Which
pressure drag of the nose is nearer a real tangent ogive is still open: neither code’s has been
checked against a measurement.
The drag curves are OpenRocket’s numbers for private designs, so they stay in the gitignored
corpus-out/ with the other records.
Stored simulations in the reference library
cargo xtask ork, over the 73 readable files, on October 24, 2026:
| quantity | count |
|---|---|
| stored simulations | 174, in 61 documents: 139 uptodate, 17 external, 11 outdated, 7 notsimulated |
| stored reference screen | 91 eligible, 83 excluded: 47 inconsistent, 17 external, 11 outdated, 7 not-simulated and 1 missing simulator; only the 91 may enter a stored-data reference denominator (the count of runs used to calculate a reference statistic) |
| HPR Sim reproduction screen | of those 91, 82 can be reproduced when OpenRocket’s database is supplied (1 without it); 9 can’t, because their configuration can’t be flown |
| with launch conditions | 173; 129 state the wind’s direction, and 135 launch into the wind |
| atmosphere | 172 isa, 1 not written |
| with a summary | 162 |
| with a time series | 142, over 176 stage branches and 97,541 rows |
The screen counts are separate from the unconditional census below. Conditions, summaries, time series, branches, rows and events are counted across all 174 stored simulations, including runs that fail either screen. The counts are an as-of snapshot of this private corpus, not a universal property of every OpenRocket file.
How the stored-result policy was decided is in the stored-results decision. The underlying read-back policy is in the read-back decision.
Writing the file back
What the simulator keeps that it doesn’t model, how it writes a .ork with it, and what it does not read yet.
What the simulator keeps for writing the file back
In short. HPR Sim’s design does not model some of what a .ork holds. This covers a parallel
stage it can’t read, OpenRocket’s 3D-view settings, a simulation’s plug-ins, a part’s color, a material’s
group. HPR Sim keeps each whole, beside the design, in an extension (a named slot for data
another program wrote) called x-openrocket. Each is kept at a path that leads back to where it
was. So writing the file back out puts it back
(writing a .ork back out). A design whose rocket is missing parts
this way says it is reduced. The flag is on the design, not on its rocket, so check it before
using the rocket on its own.
Four kinds of thing are kept: parts, sections, tags and attributes. A tag or attribute is kept for one of two reasons: no reader asked for it, or the reader that asked dropped what it says.
-
Parts HPR Sim does not read:
- a parallel stage outside a body tube, or on a rocket of several stages (Parallel stages, the parallel-stage lesson);
- a pod set it cannot lay out (Pods);
- a part HPR Sim cannot give an honest shape (above);
- a tag it has never seen.
-
Sections of the document HPR Sim does not read:
<photostudio>(the 3D view);<docprefs>(the design’s own materials);- anything else beside
<rocket>and<simulations>; - the parts of a stored simulation beyond its conditions and results, such as an
<extension>.
-
Tags no reader asks for, inside a part, stage or stored simulation HPR Sim does read, or inside a tag it does read:
- a part’s color (
<appearance>); - a catalog preset, a comment, or a wind’s standard deviation;
- a drag coefficient stated on the
<rocket>element itself; - a tag HPR Sim has never seen.
HPR Sim records every tag its readers ask for while it reads a file, so a tag is kept when nothing asked for it.
- a part’s color (
-
Tags a reader asks for and then drops are kept too, because the design does not hold what they say. Examples:
- an override on a pod set that holds nothing;
- a ring written as a row of three;
- a tube fin set of more than eight tubes;
- a fin section or finish HPR Sim has no reading for;
- the older of two names for one value when the two disagree.
A value HPR Sim reads exactly, such as a fin set’s count, is not kept.
-
Attributes no reader asks for, on an element HPR Sim does read: a material’s
groupand an event’sid. Another is the reference an angle or radius offset is measured from. HPR Sim does not read that yet but for a pod set’sradiusoffset(Pods; issue #145). An attribute whose value a reader drops is kept too, such as a material’s declared kind where the part needs another.
A kept value goes back as it was. When the design is written out as a .ork again, each kept
tag goes back. It takes the place of anything the writer would have written under that name from the
design. Take a ring written as a row of three. HPR Sim reads one ring and warns, and the file it
writes still says <instancecount>3</instancecount>. So OpenRocket reads the rings the original
had. Reading the written file gives the same warning. As with the original, that warning means HPR
Sim doesn’t fly the rocket’s configurations. That is because only a rocket read without such a
warning flies
(the decision on which rockets fly).
A rail button’s screw height was this page’s example until
the screw-head work. The design holds it now
(RailButton::screw_height_m), and the writer
writes <screwheight> from the design.
Each is kept with its path, such as openrocket/rocket/stage[0]/bodytube[1]/podset[0]: the
podset that is the first part inside the second part of the first stage. A part counts among all
the parts beside it, since their order is where they stack. A tag’s step starts with @ and
counts only among the tags of its own name. openrocket/rocket/stage[0]/nosecone[0]/@appearance[0]
is that nose cone’s first <appearance>, wherever it stood. A tag inside it adds another,
such as …/@wind[0]/@gusts[0]. A section counts the same way. A tag that belongs to one
configuration, by its configid, names it. It counts only among that configuration’s tags of its
name: …/@deploymentconfiguration(b)[0]. OpenRocket reads no meaning into
the order of tags. Counting by name lets an export put each tag back without knowing where
it stood (the decision on writing from the design). An attribute is kept with
the path of the element it was on, its name and its value. The function hpr_io::ork::element_at
follows a path back to the element.
The extension is written under its namespace when the design is saved as JSON, and reads back
unchanged. The test hpr_io::ork::tests::unknown_content_round_trips_through_x_openrocket checks
both, and that each kept element is the one at its path in the file:
let json = serde_json::to_string(&design.extensions).expect("JSON");
assert!(json.starts_with(r#"{"x-openrocket":"#), "{json}");
let back: Extensions = serde_json::from_str(&json).expect("read back");
assert_eq!(back, design.extensions);
What is not kept. The text of a second copy of a tag a reader takes once by name. A reader asks
for a tag by name and uses the first copy. So the second’s own value is taken as read, though its
attributes and anything unread inside it are kept. 13 fin tabs in the library carry a second
<tabposition> this way. That text, and everything else, is still in the document itself, which
HPR Sim keeps whole when it opens a file (the whole-document decision).
Kept in the reference library
cargo xtask ork, over the 73 readable files, on October 5, 2026, after
the change that read parallel stages:
| quantity | count |
|---|---|
| parts kept | 1, in 1 reduced design: the parallel stage directly under the rocket in demo-quirks.ork (Parallel stages). There were 3, in 3, before parallel stages were read. On 2026-09-23 there were 17, in 10; pods (Pods), tube fins (Tube fins sized from the body), a tube coupler and 2 freeform fin sets on a nose cone (Fins on a nose cone or a transition) are read since |
| sections kept | 87: 42 <photostudio>, 36 <docprefs>, 9 simulation <extension>s |
| tags kept | 1,857, most often a part’s <appearance> (309), <radialdirection> (170), <instanceseparation> (159), a wind’s <standarddeviation> (129) and <preset> (127). None of them is a value a reader drops; 16 were, rail buttons’ <screwheight>, before M4.5i read it into the design. Parts’ drag overrides, 2 with their 2 flags before M4.5h (a part’s drag override), are read into the design since |
| attributes kept | 3,209, most often an event’s id (1,623), a material’s group (594), an active stage’s number (201) and a stored branch’s optimum altitude and its time (168 each) |
| kept elements and attributes found again at their path | 5,154 of 5,154 (the survey fails if one is not) |
The decision record says how this was decided.
Writing a .ork back out
In short. hpr_io::ork::export writes a design as a .ork file for OpenRocket 24.12. The file
uses schema 1.10 (the file-format version OpenRocket 24.12 writes), and is zipped with the design
as rocket.ork, as OpenRocket packs one. It writes from HPR Sim’s design alone, not from a copy of
the file it came from. So a design built in HPR Sim is written the same way. One exception: a value
kept from the original file is written as the file had it, even after the design is edited. Read
back, the written file gives the same design, bit for bit, for each of the 73 designs HPR Sim
reads. They are among the .ork files the checks use (which files).
Some of those files are other people’s private designs, so the counts are published but those
files are not. OpenRocket 24.12 opens every written file whose original it opens. It flies each
configuration it can fly (151) to the original’s apogee within 0.002%. The largest difference is
0.00005%.
The written file is not a copy of the original. It is laid out afresh, and it states some values
the original left to OpenRocket’s defaults, such as each part’s roll angle. Its root’s creator
attribute names the program that wrote it, its version and its designation in the FusionSpace
product system. Every file HPR Sim writes does this:
creator="FusionSpace HPR 0.1.0 · FS-ACHERNAR · SW · TOOL 001" (hpr-sim before release 0.1’s
rename; a file with that creator still reads).
The measurements above were remade on October 11, 2026 with files written in this form: OpenRocket
opens and flies them within the same bar.
How it is written. Each part of the design is written as the tags HPR Sim reads it from. What
HPR Sim keeps but doesn’t model goes back where it was
(what HPR Sim keeps). A parallel stage
HPR Sim can’t read goes back in its place among the parts. A part’s color goes back in the part,
and a simulation’s plug-in in the simulation. A value HPR Sim read and dropped goes back as the file wrote it. A ring written
as a row keeps its <instancecount>, even though HPR Sim reads one ring. A parallel stage HPR Sim
read goes back inside its body tube (Parallel stages). Two functions do the
work:
export::document(&design)gives the document, with a warning for anything kept that has no place any more.export::write(&design, &attachments)gives the file’s bytes. The attachments are the original’s other zip entries (OrkFile::attachments), such as a preview image.
The API reference has a worked example
(hpr_io::ork::export).
Seven mistakes of Loft’s exporter (Loft is the project before
this one) are pinned by two tests, round_trip_keeps_delays_ignition_conditions_and_override_flags
(L67) and fin_points_clusters_and_floats_round_trip_exactly
(L68), in hpr_io::ork::export::tests. They run on invented
designs, as does a third test holding a small design’s written document to one worked out by
hand:
| Loft wrote | HPR Sim writes |
|---|---|
| a plugged delay as 0 s | none, which reads back as plugged |
| ignition only for the whole mount | each configuration’s own ignition event and delay |
| no launch conditions | every condition of every stored simulation |
| masses it had worked out, as overrides | only the overrides the design has, with their flags |
| a freeform fin as a trapezoid of the same area | every point of the outline |
| a cluster without its scale and rotation | the cluster’s pattern, scale and rotation |
| each number to six decimals | the shortest number that reads back to the same bits |
Numbers to the last bit. A length of 0.1 + 0.2 meters is written 0.30000000000000004,
because 0.3 would read back as a different number. Angles are stored in radians and written in
degrees. The writer picks the shortest number of degrees that converts back to exactly the stored
radians: a fin set at 45° is written 45.
What OpenRocket insists on. These were found by opening written files in OpenRocket 24.12, and flying them (checked in OpenRocket). Reading a file back in HPR Sim is not enough. Before the last of these was found, every design read back the same. Yet one of OpenRocket’s own examples flew 0.6% to 0.9% low and a private design 10% to 11% low.
- An id that isn’t a UUID (a 36-character code such as
0f0e0d0c-0b0a-4900-8800-070605040302) makes OpenRocket refuse the whole file. So such an id is left out, and OpenRocket gives the part one of its own. A part the file gave no id reads back with the same id HPR Sim made up for it. - OpenRocket reads an inner tube’s roll angle, and a parachute’s or a mass’s, only under the older
tag
radialdirection. So they are written under that tag. - OpenRocket applies a part’s catalog preset (
<preset>, a maker’s part number) when it reads that tag. It applies it over the sizes and material it has read so far. HPR Sim keeps the tag without reading it, and writes it first, after the part’s name and id, as OpenRocket does. Written after the part’s own sizes, it had OpenRocket fly the catalog’s part instead: one design flew 11% low.
What is still lost. None of these happens in the reference library:
- A tag the file leaves out, where HPR Sim assumes a value (a radius with nothing to take, a missing wall or density). The written file states the assumption, so reading it again no longer warns.
- A second motor in one mount for one configuration.
- A configuration with no id, or one declared twice.
- Simulation rows and events HPR Sim left out on reading.
- The text of a second copy of a tag (above).
After an edit to the design, a kept tag’s text still wins over the edit. Change a ring written as
a row in HPR Sim and its original <instancecount> is written as it was. A rail button’s screw height is the
design’s since the powered-pods milestone, which weighed rail-button screw heads, so an edit to it is written.
Checked on the reference library. cargo xtask ork writes every design out, reads it back,
compares the two, and writes the design read back once more. It fails on any difference. On
September 29, 2026:
| quantity | count |
|---|---|
| designs written | 73 |
| read back as the same design | 73 |
| written again the same, byte for byte | 73 |
| export warnings | 0 |
cargo xtask ork # counts, and fails if a design comes back different
cargo xtask ork --export corpus-out/written # also saves each written file, by the original's path
The decision record says how this was decided.
Checked in OpenRocket
In short. OpenRocket 24.12 flew each design twice: as the original file, and as HPR Sim’s export of it. Every export opened where its original did, and every configuration that flew both ways reached the same apogee within 0.002%. Both flights are OpenRocket’s, so this checks the file HPR Sim writes, not HPR Sim’s physics. How HPR Sim’s own flights compare is in HPR Sim’s flights against OpenRocket’s. HPR Sim itself flies a written file exactly as it flies the original, since it reads back the same design.
The files. The check uses every .ork file the survey (cargo xtask ork) finds:
| where | files |
|---|---|
| the example designs that ship with OpenRocket | 17 |
the private design library (the corpus; the report’s row ending imported/loft-fixtures) | 27 |
other .ork files under refs/, mostly Loft’s and Debrief’s test designs (listed above; the report’s elsewhere under refs/) | 31 |
| all | 75 |
HPR Sim reads 73 of them; the other two are malformed XML, which OpenRocket refuses too. OpenRocket’s examples and most of the other files are public.
How they are flown. Each flight takes its launch conditions from the file’s
first stored simulation, or OpenRocket’s defaults
when it has none. Each flight is in calm air, with random seed 1. A configuration passes when the
export’s apogee is within 0.002% of the original’s. The roadmap’s bar for
writing .ork files was 0.5% until
a decision record
set it at about four times OpenRocket’s own spread (below). A bug an earlier .ork writer had was
rounding every number to six decimals. A writer that did so passed 0.5% but fails 0.002% on 20 of
the 55 public example configurations. That check was a one-off, recorded in that decision and not in
the committed report. The bar is a margin measured on these designs, not derived and not a bound for
any design. If a new design or OpenRocket release differs by more, the check fails and the cause is
traced. A decision record comes before the bar moves.
| quantity | count |
|---|---|
| designs | 75 |
| opened as written | 71 |
| opened as exported, of those | 71 |
| designs with a configuration flown both ways | 48 |
| configurations of the opened designs | 169 |
| configurations flown neither way | 18 |
| configurations flown both ways | 151 |
| within 0.002% of the original’s apogee | 151 |
| the same apogee to the last bit | 142 |
| largest apogee difference | 0.00005% |
- Four designs don’t open as written. HPR Sim can’t read two of them, so it writes nothing. OpenRocket refuses the exports of the other two with the same error as their originals.
- 23 opened designs have nothing to fly. They have no configuration, or none with a motor.
- Eighteen configurations fly neither way. Seventeen have no motor. OpenRocket aborts the other one both times, for the same cause.
- Nine configurations differ, by OpenRocket’s own spread. All nine are in six private designs
(the report’s row ending
imported/loft-fixtures); the largest is 0.00005%. In those six designs, every number in the rocket that the two files share is the same to the bit. The originals flown again differ from their own record in 8 of the 151 configurations. One configuration flown 45 times (43 in fresh OpenRocket launches) spread over 0.00051%. Both are one-off reruns, recorded in the decision that tightened the bar and not in the committed report. OpenRocket reports the highest of its time steps (0.05 s on most designs). So a last-bit change that moves its step grid moves the reported apogee by millimeters. How many come out the same to the bit varies by run: 142 to 144 of 151.
The committed report,
openrocket-export-flights.md,
gives these counts by where the designs came from. The flights themselves stay in the gitignored
corpus-out/, since they could identify private designs
(OpenRocket’s flights of the private designs).
Running it again. It needs Java 17, the OpenRocket jar fetched by cargo xtask refs fetch,
and a Python environment at refs/venv with JPype. JPype lets the oracle
scripts drive OpenRocket, as for OpenRocket’s mass.
Without the private library, the commands fly the public files alone. The two imported/
directories in the first command are the private library and one design from Debrief’s private
collection, copied into the private flight collection. The scripts walk refs whole, so these
commands assume two things. The collection, if present, is a symbolic link to a sibling checkout,
which the scripts don’t follow. No checkout of the two older repositories sits under refs/. The
comparing commands refuse a record that holds anything else.
The first command flies the originals, and is needed only when refs/ or the flight scripts
change. The second writes each design back out; the third flies those files; the last compares:
refs/venv/bin/python validation/oracles/openrocket/flights.py corpus-out/openrocket-flights.json \
refs refs/hpr-sim-fixtures/imported/loft-fixtures refs/hpr-sim-fixtures/imported/debrief-fixtures --jar
cargo xtask ork --export corpus-out/ork-export
refs/venv/bin/python validation/oracles/openrocket/flights.py corpus-out/openrocket-export-flights.json corpus-out/ork-export
cargo xtask ork-export-flights
The last command stops with an error when the flights are stale, that is, when:
- HPR Sim would now write different files;
- an original has changed since it was flown; or
- the two sets of flights used a different OpenRocket or different scripts.
With --check, it compares its result
with the committed report instead of writing it.
What is not read yet
A parallel stage is kept, not modeled (what HPR Sim keeps), in two cases. One is on a rocket of several stages on the axis. The other is anywhere but inside a body tube. A parallel stage inside a body tube on a rocket of one stage on the axis is read and flown (Parallel stages). So are pods (Pods).
Keeping the whole document pays off when HPR Sim meets a part it does not model. It can say so and
carry the part’s own XML along untouched in x-openrocket. It does not drop the part silently, the
way Loft did with pods and parallel stages. The writer puts that XML back where it
was (writing a .ork back out). The decision on unread parts
confirms that the reduced flag and this preserved content are the current rule for b4, not a hidden
mass estimate.
OpenRocket .orc parts catalogs
Look up a maker’s parts by part number in the OpenRocket .orc catalogs built into HPR Sim, and see
how each value is read.
A .orc file is a parts catalog for OpenRocket, which calls its parts component presets.
It lists nose cones, body tubes, couplers, centering rings, bulkheads, transitions, launch lugs,
parachutes and streamers, as their makers sell them. Each part is under its maker and part number,
with its sizes and its material. OpenRocket 24.12 ships 16 of these files, from the
openrocket-database project: 3,449 parts from Estes, LOC Precision, Giant Leap, Madcow, SEMROC
and others.
HPR Sim has those 16 files built in. A program can look a part up by maker and part number, or search for one. This page is the reference for that reader: what a file holds, how each value is read, and where HPR Sim’s reading differs from OpenRocket’s.
Building with it. The builder makes a rocket’s parts from catalog parts. It weighs each one as OpenRocket does, with the few differences it names (Parts from a catalog, written for M5.5b). A part that states its mass weighs that mass: its density is scaled to give it.
Code: hpr_io::orc (API reference), written for
M5.5a, the parts reader. The decisions are in
ADR-132: OpenRocket’s parts catalogs.
From a program
hpr_io::orc::bundled() is the built-in catalog. find takes a maker and a whole part number;
search finds every part whose number or description holds some text. This program looks up a
LOC Precision nose cone and a Giant Leap parachute, then searches Estes’ parts:
//! Parts from the catalog OpenRocket ships: a nose cone and a parachute found by maker and part
//! number, a search by a piece of a part number, and what the catalog holds.
//!
//! Run it from anywhere in the repository:
//!
//! ```text
//! cargo run --example parts_catalog -p fusionspace-hpr-io
//! ```
//!
//! The guide's page *OpenRocket `.orc` parts catalogs* (`docs/format/orc.md`) quotes it and what
//! it prints, which is kept next to it in `parts_catalog.output.txt`; CI checks that the two still
//! agree (`cargo xtask examples --check`).
#![allow(
clippy::print_stdout,
reason = "the project's lints forbid printing in library code, and this program exists to print"
)]
use hpr_io::orc::{PartKind, bundled};
fn main() {
let catalog = bundled();
println!(
"{} parts from {} makers",
catalog.parts.len(),
catalog.manufacturers().len()
);
// One part, by maker and its whole part number. Its sizes are in meters; print millimeters.
for part in catalog.find("LOC Precision", "PNC-3.00") {
println!(
"\n{} {}: {}",
part.manufacturer, part.part_number, part.description
);
if let PartKind::NoseCone(nose) = &part.kind {
println!(
" {:?}, {:.1} mm long, {:.1} mm across",
nose.shape,
nose.length_m * 1e3,
nose.outer_diameter_m * 1e3,
);
// A nose is hollow with a wall, or filled. The file may give `Filled`, a wall or both;
// the ten built-in parts that give both say `Filled` is false.
match (nose.filled, nose.thickness_m) {
(Some(true), _) => println!(" filled"),
(_, Some(wall_m)) => println!(" wall {:.2} mm", wall_m * 1e3),
_ => println!(" wall not given"),
}
println!(
" shoulder {:.1} mm long, {:.1} mm across",
nose.shoulder_length_m * 1e3,
nose.shoulder_diameter_m * 1e3,
);
match nose.material.density {
Some(density) => println!(" {}, {density} kg/m³", nose.material.name),
None => println!(" {}, density not given", nose.material.name),
}
}
}
// A parachute that states its own mass.
for part in catalog.find("Giant Leap", "TAC-24") {
println!(
"\n{} {}: {}",
part.manufacturer, part.part_number, part.description
);
if let PartKind::Parachute(chute) = &part.kind {
println!(
" {:.0} mm across, {} sides, {} lines of {:.0} mm",
chute.diameter_m * 1e3,
chute.sides,
chute.line_count,
chute.line_length_m * 1e3,
);
}
if let Some(mass_kg) = part.mass_kg {
println!(" stated mass {:.1} g", mass_kg * 1e3);
}
}
// Estes writes two numbers in one, `BT-20, 30316`: a search finds it by either.
println!("\nEstes parts numbered with 30316:");
for part in catalog.search(Some("Estes"), "30316") {
println!(" {}: {}", part.part_number, part.description);
}
}
It prints:
3449 parts from 16 makers
LOC Precision PNC-3.00: Nose cone, polypropylene, PNC-3.00, ogive, 12.5"
Ogive, 285.8 mm long, 78.7 mm across
wall 1.96 mm
shoulder 95.2 mm long, 75.9 mm across
Polypropylene, bulk, 946 kg/m³
Giant Leap TAC-24: Parachute, TAC-1 type, 24 in., 4 shrouds
610 mm across, 4 sides, 4 lines of 914 mm
stated mass 153.1 g
Estes parts numbered with 30316:
BT-20, 30316: Body tube, BT-20, 18 in.
Every size comes back in meters, every mass in kilograms, and every density in kg/m³ (solids),
kg/m² (fabric) or kg/m (cord), all SI units. A file of your own reads
with hpr_io::orc::read(text, name). Here text is the file’s contents, and name is the file’s
name. Each part keeps the name, so you can tell where it came from. The program does the reading from disk;
the reader itself does no I/O.
Two things to know when looking parts up:
- A part number is matched whole. Many makers write several numbers in one. Estes’ BT-20 is
BT-20, 30316, sofind("Estes", "BT-20")finds nothing;searchfinds it by either piece. The maker matches in any case. - A few numbers name two parts. In the built-in files, 21 part numbers name two parts of the
same kind; 3 of those pairs are identical.
findreturns all of them, in file order.
What a file holds
A .orc file is XML with three parts:
<Version>:0.1in 15 of the built-in files,1.0in one.<Materials>: each material’s name, its density, the density’s units and its kind. The kind isBULK(per volume, for solid parts),SURFACE(per area, for canopy and streamer fabric) orLINE(per length, for shroud lines).<Components>: the parts. Each names its maker, part number and description, and its material by name and kind. That material must be defined in the same file.
Each size carries its own Unit attribute, such as <Length Unit="in">10</Length>. There is no
published schema. The fields and units below are the ones the database project documents in its
docs/TechnicalInfo.md, and their meaning is what OpenRocket does with them.
| part | sizes it gives | in the built-in files |
|---|---|---|
BodyTube, TubeCoupler, EngineBlock, CenteringRing, LaunchLug | inside and outside diameter, length | 1,089, 237, 38, 499 and 59 |
BulkHead | outside diameter, length | 115 |
NoseCone | shape, length, base diameter, shoulder diameter and length, filled or a wall thickness | 855 |
Transition | shape, length, each end’s diameter, shoulder diameter and shoulder length, filled or a wall thickness | 360 |
Parachute | diameter, number of sides, number and length of shroud lines, the lines’ material | 151 |
Streamer | length, width, thickness | 46 |
Any part may also state its Mass. 229 of the built-in parts do: 207 solid parts, and 22
parachutes and streamers. A parachute’s or streamer’s stated mass leaves its fabric’s density as
written, in HPR Sim’s reading and in OpenRocket’s. A solid part’s stated mass doesn’t do that in
OpenRocket’s reading (see
Where the simulator’s reader and OpenRocket’s differ).
When the part goes into a rocket, OpenRocket gives a parachute its stated mass as an override and
ignores a streamer’s. The builder scales either one’s density to give it.
A centering ring’s length is its thickness. A coupler with an inside diameter of zero is a solid nose block.
The units read are the ones OpenRocket 24.12 reads:
| quantity | units |
|---|---|
| length | m, cm, mm, in, ft |
| mass | kg, g, oz, lb |
| bulk density | kg/m3, g/cm3, kg/dm3, lb/ft3 |
| surface density | kg/m2, g/m2, g/cm2, oz/in2, oz/ft2, lb/ft2 |
| line density | kg/m, g/m, g/cm, oz/ft |
A value with no unit is in SI, as OpenRocket reads it. Each unit is its exact definition (NIST Handbook 44, Appendix C). The inch is 0.0254 m (0.083 ft), and the foot is 0.3048 m (1.000 ft). The pound is 0.45359237 kg, and the ounce is a sixteenth of that, 0.028349523125 kg.
What a file leaves unsaid
- A shape’s parameter. A nose cone’s or transition’s shape is one of
CONICAL,OGIVE,ELLIPSOID,PARABOLIC,HAACKandPOWER(OGIVEis a tangent ogive). The last four have a parameter (an ogive’s radius, a Haack series’ C), but no.orcfield can give it. OpenRocket uses its own default when the part goes into a design. - A shoulder’s wall. A shoulder has a diameter and a length but no wall thickness, and no end cap. For a hollow part, OpenRocket gives it no wall, so it weighs nothing. The database’s own usage notes say so, and the builder’s test confirms it from OpenRocket’s own output. The builder gives the shoulder the part’s wall instead (What the catalog leaves unsaid). For a filled part, OpenRocket weighs the shoulder as a solid cylinder: the check of stated masses below uses that volume, and it agrees.
- A parachute’s drag. No field gives a drag coefficient.
- A filled part’s walls.
Filledsays a nose cone or transition is solid. Where it is absent, aThicknessgives the wall instead. Eight nose cones and two transitions give both, and all ten sayFilledis false, so they agree: a hollow part with that wall. A file that said filled with a wall would leave which one counts open; HPR Sim keeps both, as OpenRocket’s reading does.
Where the simulator’s reader and OpenRocket’s differ
The test crates/hpr-io/tests/orc_openrocket.rs reads every built-in part and compares it with
OpenRocket 24.12’s reading, value by value. The two agree everywhere except in these places. Each
is counted, and each count is checked:
| what | parts | HPR Sim | OpenRocket |
|---|---|---|---|
| a mass stated in ounces | 185 | the exact ounce, 0.028349523125 kg | 0.0283495231 kg, so 8.8 parts in 10 billion lighter |
| two makers’ names | 252 | as the file writes them | “LOC/Precision” and “Public Missiles, Ltd.” for “LOC Precision” and “Public Missiles” |
| a solid part that states its mass | 207 | the material keeps the file’s density; the part keeps its stated mass | replaces the density with the one that gives the part that mass |
| a material the file names but doesn’t define | 3 | no density | a density of zero |
The third row is the one that matters for a rocket’s weight. For example, an Estes balsa nose cone that states its mass gets, in OpenRocket, a balsa density that makes the cone weigh exactly that. HPR Sim keeps both numbers.
The test shows that a stated mass is the cause on all 207. The oracle also reads each file with
every <Mass> taken out, and then OpenRocket’s density equals HPR Sim’s on every part, these 207
included. On the 54 of them that are simple solids, the test also checks the stated mass. It checks that
OpenRocket’s replaced density times the part’s volume gives it, to 1 part in 10¹⁵. The 54 are 7 body
tubes, 4 bulkheads, and 43 filled conical parts: 34 nose cones and 9 transitions.
The builder (Parts from a catalog) makes a part that
states its mass weigh that mass. It scales the density to do so, as OpenRocket does for rigid parts.
OpenRocket also rounds a few other imperial factors. They are pounds per cubic foot, ounces per square inch or foot, pounds per square foot, and ounces per foot. No built-in file uses them.
Warnings, not failures
Only three things make HPR Sim refuse a whole file. They are text that isn’t XML, a top element
that isn’t <OpenRocketComponent>, and elements nested more than 16 deep. No catalog needs that
depth, and a file that deep is refused before the XML is read. Anything else that can’t be read is
left out with a warning, and reading goes on:
- A part is left out for a missing, unreadable or negative size, or for a unit or shape the format
doesn’t have. It is also left out for a material of the wrong kind or a value with an element
inside it. So is an element that isn’t a kind of part. OpenRocket 24.12 refuses the whole file
for three of these: a missing size, an unknown unit and an unknown shape. It reads an unreadable
size as zero. It reads a material of the wrong kind with a density of zero, and a part number
written
BT<b>-</b>20as20. It skips an element that isn’t a part. What it does with a negative size is not probed. - A material is left out for an unknown unit or kind, no density, or an element inside its name. It is also left out for a density below zero or too large for a 64-bit number. Parts that name it read with no density.
- A field a part’s kind doesn’t have is left out, with a warning. The 37 built-in nose cones that state an inside diameter read this way.
- A field stated twice keeps the last, as OpenRocket does. Three built-in parts state two descriptions.
- A material defined twice with two densities: parts take the first, as in OpenRocket.
- A list stated twice: the last
<Materials>and the last<Components>are read, as OpenRocket reads them. Anything else beside the lists is left out. - A value that is read as written but looks wrong:
- a tube whose inside diameter is not less than its outside diameter;
- a solid lighter than air (under 1 kg/m³);
- a fabric lighter than 1 g/m². The lightest correctly labeled fabric in the built-in files, a
polyethylene film, is 7.05 g/m². Their ripstop nylons are tens of g/m². So this is almost
certainly a kg/m² value labeled
g/m2, 1,000 times too light.
A file with more than 1,000 warnings lists the first 1,000 and then says how many more there were.
The project’s notes list in/64 (sixty-fourths of an inch) as a length unit. HPR Sim refuses it,
because OpenRocket reads it as whole inches: 3 in in/64 would come out as 3 inches.
On the built-in files there are 55 warnings, all of kinds listed above:
| warning | count |
|---|---|
| a nose cone’s inside diameter, ignored | 37 |
| a description stated twice | 3 |
a material not defined (Carpet Thread twice in mpc.orc, and a balsa in semroc.orc) | 3 |
| a tube-like part no narrower inside than out (one Quest, two SEMROC) | 3 |
a solid lighter than air (Paper, bulk at 0.0011 kg/m³ in BMS.ORC and ROCKETARIUM.ORC, an elastic in generic_materials.orc) | 3 |
a fabric under 1 g/m² (five in generic_materials.orc, one in giantleaprocketry.orc) | 6 |
Nothing is changed on account of them: each such part reads as written, as OpenRocket reads it.
The 18 parts made of that paper (centering rings and engine blocks) would weigh about a millionth
of a real one. Paper is roughly 1,000 kg/m³. The six Giant Leap parachutes on the light fabric all
state their mass, so use that. bundled() drops these warnings; read each of BUNDLED_FILES to see them.
Checked against OpenRocket
validation/oracles/openrocket/orc_presets.py runs OpenRocket 24.12’s preset loader, its public
API (run, never read: its source is GPL), on each of the 16 files. It first checks that the jar’s
copy of each file is byte for byte the one built into HPR Sim. It records every value of every
part to
crates/hpr-io/tests/fixtures/orc/openrocket-presets.json,
one part to a line. Each part’s densities are recorded too, as OpenRocket reads the file with its
masses taken out.
It also has OpenRocket read 37 small .orc probe files, each asking
one question. The questions cover every unit above, values with no units, and a part or a file
OpenRocket can’t read. They also cover what it does with a material or a list stated twice. The probe test in the same file reads each
probe:
| probes | result |
|---|---|
| 23 | read as OpenRocket reads them, to the bit |
| 6 | in a unit whose factor OpenRocket rounds: within 2 parts in 10⁹, by HPR Sim’s exact factor |
| 4 | OpenRocket refuses the file; HPR Sim leaves the part out (for oz/in, ounces per inch, a cord density neither reads, HPR Sim leaves the material out and reads the part without the cord’s density) |
| 4 | OpenRocket reads the part (in/64 as inches, a length of ten as zero, a material of the wrong kind with a density of zero, BT<b>-</b>20 as 20); HPR Sim leaves it out |
As a check that the tests can fail, HPR Sim’s inch was changed by hand. It was moved to the next number a 64-bit float can hold above 0.0254. Both the catalog comparison and the probe test failed.
Sources and license
- The files:
openrocket/openrocket-database, https://github.com/openrocket/openrocket-database, at commit1512874a(July 27, 2025), pinned asopenrocket-databasein the reference lock file. Apache License 2.0. Created by Dave Cook and maintained by the OpenRocket team. They are built into HPR Sim unchanged, incrates/hpr-io/data/openrocket-database/with the project’sLICENSE. - The format: the project’s
docs/TechnicalInfo.mdanddocs/Usage.mdat that commit. - The units: NIST Handbook 44 (2024), Appendix C, General Tables of Units of Measurement.
RASP .eng motor files
See how HPR Sim reads and writes RASP .eng motor files, the plain-text thrust curves
ThrustCurve.org serves, including the quirks of real files.
A .eng file is a motor’s thrust curve in plain text. It has a
one-line header with the motor’s name, size, delays and masses, then one time and thrust per line.
The format is named after RASP, the rocket simulation program it comes from. It is the more common of
the two formats ThrustCurve.org serves (the other is
RockSim .rse).
To fly a motor from a .eng file, see
A motor from a file on the Solid motors page. It reads a
file, builds the motor and puts it in a rocket, with a program that CI runs.
This page is the reference for HPR Sim’s reader and writer. It gives what the published spec says, what real files do, and what HPR Sim does with each. All 889 RASP files ThrustCurve.org held on September 17, 2026 read, and write back with every value unchanged (Checked against real files).
Code: hpr_motor::eng (API reference), written for the
solid-motor milestone (M1.3). The rules below are from the spec unless marked
Observed (seen in real files) or Policy (the simulator’s own choice).
Sources
- [R] ThrustCurve.org, “RASP File Format”, https://www.thrustcurve.org/info/raspformat.html,
captured September 17, 2026 and pinned as
thrustcurve-rasp-format(sha25669573e9f…) in the reference lock file. The lock file records each source’s address and checksum. Sections are cited as [R Header], [R Data], [R Problems]. The page names the RASP C source as “the ultimate authority”; its license is not stated, so it was not consulted. - Observed: 734 entries, 721 in the ThrustCurve manufacturer file sets (12
.engsets) and 13 in single-motor API downloads. They were fetched September 17, 2026 into a local cache,refs/samples/formats/, never committed. Counts below are over those entries.
What the spec says
The published format, rule by rule, and the cases it leaves open.
Grammar
Read := as “is made of”, * as “any number of”, + as “one or more”, and | as “or”.
file := entry+
entry := (blank | comment)* header point+ (blank | comment)*
comment := ';' text whole line; [R Header], [R Problems]
header := name dia len delays prop total mfg seven fields "separated by spaces" [R Header]
point := time thrust "usually preceded by a few spaces" [R Data]
- Blank and
;lines are ignored before the header. After the last point an entry “may end or contain comments and blank lines, but nothing else” [R Header], [R Data]. - “All seven must be present for the entry to be read successfully” [R Header].
- Points start “immediately after the header line” [R Data].
- A file may hold several entries; “make sure that each entry is separated by at least one comment
line”. A lone
;after the data is the customary separator [R Data], [R Problems].
Header fields [R Header]
| Field number | Field | Unit | Meaning |
|---|---|---|---|
| 1 | name | n/a | Common name: “just the impulse class and average thrust” (F32) |
| 2 | diameter | mm | Casing diameter |
| 3 | length | mm | Casing length |
| 4 | delays | s | Available delays “separated by dashes”; 0 = ejection charge, no delay; P = plugged, no ejection charge |
| 5 | propellant mass | kg | “Weight of all consumables” (the propellant, for a solid) |
| 6 | total mass | kg | Motor “loaded and ready for flight” |
| 7 | manufacturer | n/a | Abbreviation, per the combined motor list of the NAR (National Association of Rocketry) |
Thrust curve [R Data], [R Problems]
- Each point is a time (s) and a thrust (N), as “floating-point numbers”.
- An implicit first point at (0, 0) “is assumed and should not be specified explicitly”. An explicit (0, 0) is called “a common mistake”.
- “The final point must have a thrust of zero and it indicates the motor’s burn time.” A zero thrust anywhere else is rejected by ThrustCurve. (ThrustCurve’s metadata uses the burn time of the NFPA 1125 5% rule instead. See Loft lesson L39, where Loft took the last point as the burn time.)
- Points “must be in order of time”. ThrustCurve rejects a point “before the previous point” and a first point at negative time. Equal times are not addressed.
- RASP allowed at most 32 points, including the final zero; modern tools don’t enforce this.
Where the spec is silent
Number syntax (exponents, sign; its own example uses .0377). Whether tabs or several spaces
separate fields. Line endings, text encoding, and a BOM (byte-order mark: an invisible character
some editors put at the start of a file). Delay lists that mix numbers with P, or use other
separators. Equal consecutive times. Inline comments. An entry with no comment separator before the
next header.
Reading and writing
What real files do, and what the reader and writer do with each case.
Observed in real files
- Whitespace: tabs separate data fields in 4 of 12 sets. 52 headers use several spaces or
column alignment; one header is indented. Trailing spaces are common. 8 of 25 files use CRLF
(Windows line endings, a carriage return then a line feed; other systems use LF alone).
13 of 13 single downloads lack a final newline. There is no BOM, no non-ASCII byte, no inline
;, no blank or comment line inside the data, and no indented comment. - Entries: always separated by a comment; there are 470 lone
;lines. A reader that stops at the first header loses the rest of the file (Loft lesson L36). - Header: never more than 7 fields; spaces in a manufacturer name become
_(Contrail_Rockets). Manufacturer spellings vary (AT,A,Aerotech,AERO,AT-RMS,AT/RCS;CTI,Ces,CSR,Pro38). The name is often the full designation, not class plus thrust (1266-J760-WT-19A,I216-CL(I),O25,000-VM-P,1/2A3T,C6-0). - Numbers: leading dot (
.0377, 21 headers), trailing dot (2415.), leading zeros (068.8604) and padded decimals (0.000) all occur. So does binary float noise (0.060700000000000004, 72 headers). Numbers have up to 15 significant digits. Diameters and lengths can be fractional (114.3). No exponents or signs were seen. - Delays: 574 dash lists, 143
P, 4 comma lists (5,8,11), 8 lists ending inP(6-10-14-P), 1 lowercasep, and 4 malformed (4-7-10,,-,1-3--4-6-7-9-10). 58 lists are descending (14-12-10-8-6). 27 contain100or1000. Checked against ThrustCurve search metadata,100/1000mean plugged in 14 of 14 cases. Against the same metadata,0means plugged in 120 of 149, against the spec’s “no delay”. Loft read100and1000as seconds (Loft lesson L37). - Curve: 32 entries have an explicit first point at with nonzero thrust. Loft’s bundle also had an explicit (0, 0). 4 entries don’t end at zero thrust. 4 have equal consecutive times (a vertical drop to zero, or rounded times). 69 have more than 32 points. None have decreasing time, negative thrust or an interior zero.
Reader policy (lenient, with diagnostics)
- The reader takes text and strips a UTF-8 BOM. Decoding bytes into text is the caller’s job:
today, read the file into a string yourself, as with
std::fs::read_to_string, which expects UTF-8. That job, and any fallback to Windows-1252 (an older Windows character set), is planned forhpr-io, the crate for other programs’ file formats. It doesn’t do it yet. Lines split on LF, CRLF or a bare CR and are trimmed. - A line whose first non-blank character is
;is a comment. Fields split on runs of spaces and tabs. - Each entry is read in stages (a state machine). Before the header, skip blanks and collect comments. The header is the first other line. In the data, a 2-field numeric line is a point and blank lines are skipped. A comment ends the data. An entry that ends with no points is an error. A line with 7 or more fields starts a new entry, with a warning about the missing separator. Anything else is an error, with its line number.
- The header needs 7 or more fields. With more than 7, join fields 7 onward with single spaces
as the manufacturer, and warn. Dia and len must be finite and , and the masses finite and
; warn if prop ≥ total. Keep file units (mm, kg) in the file model, in fields named for them
(
diameter_mm). Convert to SI only when building the physical motor. The round trip mm → m → mm is not bit-exact (502.1 / 1000 * 1000 != 502.1). With* 1e-3and* 1e3, 30 of 290 distinct header lengths fail. - Numbers: Rust
str::parse::<f64>accepts.5,5.,068.8,+1and1e3, but alsoinf,infinityandNaN. Reject every non-finite value. - Points are kept verbatim; no implicit origin is inserted into the file model. Errors: no points,
negative time, time decreasing, and a last thrust above half the entry’s peak
(
CUT_OFF_SHARE): the file looks cut off, and a G84 curve cut after 13 of its 29 points would read as an F motor. When other entries in the file read, that entry is skipped, with a warning. Of 3,585 curves in the project’s reference checkouts (not in the repository), 11 end above zero, at 10.5% of the peak at most (a test counts them). A lower cut, or one inside a number, reads, with a warning unless it leaves a 0. Warnings, on the header’s line: a lower last thrust , negative thrust, and delay pieces the delay reader leaves out or flags. Equal consecutive times are accepted (a step in the physical curve). The RASP 32-point limit is not enforced. - Delays: keep the raw token verbatim. The derived view splits on
-or,and leaves out empty pieces, with a warning. It mapsP/p→ plugged and100/1000→ plugged. It reads0as its own “zero or plugged” setting, with a warning (spec: no delay; files: usually plugged). It reads other pieces as seconds. A0never becomes an ejection at burnout without a decision: a motor file’s delays aren’t flown, so with no delay chosen a flight fires no motor charge, as if plugged, and the warning says so. A delay of 0 s fires it at burnout:hpr sim --delay 0,Motor::with_delay_s(0.0)in Rust, ordelay_s=0in Python. Physics should prefer catalog metadata for delays. - When other entries in the file can be read, an entry with an error is left out, with the error as a warning. The reader resumes at the next comment line. With no entry read, the first error returns. Every warning carries a kind: skipped (an entry lost), dropped (a value left out) or unusual (read as it stands).
- Comments: store the text after
;verbatim, but drop comments that are empty after trimming. Comments between two entries belong to the next entry; comments after the last entry are file trailer comments. Policy: a comment that names the simulator as the file’s writer is dropped when reading. The reason is that it says who wrote the file, not anything about the motor. Such a comment readsFusionSpace HPR, a version, thenFS-ACHERNAR · SW · TOOL 001(see the writer policy). A comment written by builds from before release 0.1’s rename is dropped too. It has the earlier namehpr-simwith that designation or withFS · SW · TOOL 005. The second is the designation builds wrote before October 2026, when FusionSpace named its products after stars (the new designation; project Eridanus §4). So a file they stamped writes back with one stamp, this build’s. Like any comment, it still ends the entry before it.
Conversion to a physical curve (EngEntry::thrust_curve, not part of the file model): prepend
(0, 0) when the first time is . A leading stays a step at ignition. Negative thrust is
an error there.
Writer policy (strict, round-trip stable)
Round-trip stable: a file the simulator writes reads back to exactly the values it was written from.
- Policy: the first line is a comment naming the program that wrote the file, its version and
its designation in the FusionSpace product system. Every file the simulator writes has this line:
; FusionSpace HPR 0.1.0 · FS-ACHERNAR · SW · TOOL 001. The·is a middle dot, the file’s only non-ASCII character unless its comments hold others; the file is UTF-8. A comment carried over from the source that is itself such a line, from any version, is left out. So is the line written under the earlier name by builds from before release 0.1’s rename. It is left out with either designation (FS-ACHERNAR · SW · TOOL 001orFS · SW · TOOL 005; rule 9 of the reader policy above). A file converted again then holds one such line, not two. Whether other programs (RockSim, OpenRocket, a flight computer’s tools) accept the middle dot in a comment has not been checked. - Each entry: its comments as
;text, then the header with single spaces, then onet Fline per point, then a lone;. Finally the trailer comments. LF endings, a final newline, UTF-8. - The name must be one token that doesn’t start with
;(the line would read as a comment), and the delays one token. The manufacturer may hold spaces if its words are separated by single spaces, since the reader joins extra fields that way. Comment text must be non-empty, on one line, and without trailing whitespace (the reader would trim it). Otherwise return an error, never a silent substitution. - Numbers use Rust
{}(Display). It prints the shortest digits that parse back to the same bits and never uses an exponent (older readers may not accept one). It writes-0.0as-0. - Points are written as stored: no origin is added or removed. The writer rejects negative or decreasing times and a curve whose last thrust is above half its peak, the same rules as the reader.
- Invariant (test it): whenever
write(parse(x))succeeds,parse(write(parse(x))) == parse(x), with f64 compared by bits. Dropping empty comments is what keeps the writer’s;separator stable. A lenient read the writer cannot represent (a manufacturer containing spaces) is a write error, not a changed value. - Leading and trailing whitespace inside comment text: the reader trims only trailing whitespace,
and the writer never adds any, so
; textround-trips astext. - Converting to and from
.rse(hpr_motor::convert,hpr convert, since M4.2c, the command-line conversion) is described with that format’s writer policy. From.rse, a code or maker of several words joins them with_. That is because no real file has more than seven header fields and OpenRocket 24.12 refuses eight (motor_files.pychecks it).hpr convertjoins a maker read from a.engfile the same way. A leading(0, 0)point is dropped when the next is after ignition, and the comment text becomes one comment per non-blank line.
Checked against real files
On September 17, 2026, all 889 RASP files in ThrustCurve.org’s solid-motor survey
(data notes)
and the 721 entries of its manufacturer sets read. For both, write-parse-write reproduces every value bit
for bit. The files are cached under refs/samples/
and never committed; the committed test covers the bundled curves.
RockSim .rse motor files
See how HPR Sim reads and writes RockSim .rse motor files, the XML thrust curves ThrustCurve.org
serves, following real files where the spec disagrees.
A .rse file is a motor database in XML, a text format of nested, named elements, from the RockSim
flight simulator. It holds one or more motors (“engines”). Each has its size, masses and delays
as attributes, and a table of thrust, mass and center of gravity
(CG) over time. ThrustCurve.org serves it beside
RASP .eng.
To fly a motor from a .rse file, see
A motor from a file on the Solid motors page. It reads a
.eng file, and says what changes for a .rse one.
This page is the reference for HPR Sim’s reader and writer. The spec is thin and disagrees with every real file on element and attribute names, so a reader must follow the observed structure. Of the 823 RockSim files ThrustCurve.org held on September 17, 2026: 821 read and write back with every value unchanged. The other two have a time that goes backwards (Checked against real files).
Code: hpr_motor::rse (API reference), written for the
solid-motor milestone (M1.3). The rules below are from the spec unless marked
Observed (seen in real files) or Policy (the simulator’s own choice).
Sources
- [P] “RockSim & EngEdit – Engine File (.rse) Format Guide”, 3 pp., PDF hosted by ThrustCurve.org.
Pinned as
rocksim-rse-spec(sha256c47a04f4…) in the reference lock file. The lock file records each source’s address and checksum. The PDF was fetched torefs/papers/rocksim-rse-spec.pdf, a local folder that is never committed. Cited as [P p.N]. - [S] ThrustCurve.org, “Flight Simulators”, RockSim section,
https://www.thrustcurve.org/info/simulators.html, captured September 17, 2026 and pinned as
thrustcurve-simulators(sha2565bb2bad7…). - [X] W3C, XML 1.0 5th ed., https://www.w3.org/TR/xml/, §2.11 (end of line), §3.3.3 (attributes).
- Observed: 715 engines and 15,149 points in the ThrustCurve manufacturer file sets (9
.rsesets) and 10 single-motor API downloads. They were fetched September 17, 2026 into a local cache,refs/samples/formats/, that is never committed.
What a file holds
The file’s structure, its attributes and its thrust curve, as the spec gives them and as real files write them.
Structure
Spec: the minimal example is a bare <engine …> holding <data> with <point t="…" f="…"/>
children [P p.2]. Observed in 715 of 715 engines:
<engine-database>
<engine-list>
<engine ATTRIBUTES> repeated; one list holds every engine in the file
<comments>free text</comments> optional (415 of 715), before <data>
<data>
<eng-data t="…" f="…" m="…" cg="…"/> one per sample, in file order
</data>
</engine>
</engine-list>
</engine-database> no XML declaration, DTD or namespace
<engine> attributes
“Req” is the spec’s Required column [P p.1]. Units are from [P p.1, p.3] unless noted.
| Attribute | Req | Unit | Meaning |
|---|---|---|---|
mfg | yes | n/a | Manufacturer name |
code | yes | n/a | “Unique engine identifier”, the “primary lookup key” |
Type | yes | n/a | Engine type [P p.1 spells it type; files always use Type]. Seen: reloadable, single-use, hybrid [S], unspecified, Single-Use |
dia | yes | mm | Diameter |
len | yes | mm | Length |
initWt | yes | g (spec: “kg or g”) | Initial (loaded) motor mass |
propWt | yes | g (spec: “kg or g”) | Propellant mass |
delays | yes | s | “Comma-separated delay values” |
Itot | yes | N·s | Total impulse |
avgThrust | yes | N | Average thrust |
peakThrust | yes | N | Peak thrust |
burn-time | yes | s | Burn duration |
auto-calc-mass | no | flag | 1: RockSim computes mass as , with [P p.2] |
auto-calc-cg | no | flag | 1: “CG is fixed at engine center” [P p.2] |
massFrac | n/a | % | Not in spec. Observed: (703 of 710), where is the first point’s m |
Isp | n/a | s | Specific impulse. Not in spec. Observed: , in kg, within ±0.006 in 696 of 710 |
throatDia, exitDia | n/a | mm? | Nozzle throat and exit diameters. Not in spec. Always 0. |
tDiv tStep tFix FDiv FStep FFix mDiv mStep mFix cgDiv cgStep cgFix | no | n/a | “Rendering attributes … control how graphs are drawn” [P p.2]. Always Div 10, Step -1., Fix 1 |
The spec contradicts itself: its summary names initMass and propMass [P p.2], while its
table and example use initWt and propWt [P p.1–2]. Only initWt/propWt occur in real files.
Mass unit (verified). Of 557 .rse engines whose code also appears in the .eng sets,
497 have initWt within 1% of 1,000 × the .eng total mass. None match the kg value; the other 60
are different data (another diameter or mass). massFrac and Isp are consistent with grams.
The smallest initWt is a 1.2 g micro motor.
<eng-data> point attributes
| Attr | Req | Unit | Meaning |
|---|---|---|---|
t | yes | s | Time since ignition [P p.1] |
f | yes | N | Thrust [P p.1] |
m | no | g | “Mass … over time”, needed if auto-calc is off [P p.1]. Observed: propellant mass remaining. = propWt in 696 of 715; last m = 0 in 715 of 715. In 698 of the 700 set engines with , , with the trapezoidal impulse, to 1e-3 relative (median 1.3e-6). That is not the spec’s linear auto-calc formula. |
cg | no | mm | Motor CG over time [P p.1], [S]. Observed: constant = len/2 in 685 of 715. The datum (forward or aft end) is stated nowhere: unverified. |
With every observed file setting both auto-calc flags to 1, RockSim may ignore m and cg
[P p.2]. Policy: the simulator preserves them for round trips but derives mass and CG itself.
Thrust curve
- The spec example lists an explicit
t="0.0" f="0.0"first point and ends withf="0.0"atburn-time[P p.2]. Unlike.eng, the origin is written out. The spec is silent on ordering, duplicates and a nonzero last point. - Observed: the first point is (0, 0) in 715 of 715. The last
fis 0 in 713; 2 put a nonzero point after the zero at the samet. 70 engines have equal consecutivet, and 1 hastdecreasing.burn-timediffers from the lasttin 281 (rounded).Itotmatches the trapezoidal integral within 0.1% in 712, andavgThrust=Itot/(lastt) within 0.1% in 712.peakThrust≠ maxfin 9.
Reading and writing
What else real files do, and what the reader and writer do with each case.
Observed in real files (other)
- Delays: missing in 5. Always comma integers; never
P. Descending lists are common (15,12,10,8,6). Checked against ThrustCurve search metadata,1000means plugged in 126 of 128 single-token cases and0in 24 of 25. Lists can end in1000(10,14,1000). - Strings:
mfghas 20+ spellings, including leading or trailing spaces (Aerotech), commas (Estes Industries, Inc.) and underscores.codecan hold spaces (Micro Maxx II), commas and parentheses. - Numbers: 6 significant digits, like C
%g, with a trailing.on integral values (35.,0.,-0.). One exponent (1.51982e-05); some padded (0.00). - XML text: start tags wrap over several lines; two spaces after the element name. Attribute
order is either RockSim’s (490) or alphabetical (220); XML gives order no meaning. 6 of 19 files
use CRLF, and many lack a final newline.
<comments>spans lines in 197 engines; 2 use CDATA, one holding a raw&. There are no entity references, and everything is ASCII. - Bad values:
propWt10× (a typo), andcg0.1 × len/2. Five engines (four hybrids) have everymandcg= 0, so cannot mean “no propellant”.
Reader policy (lenient, with diagnostics)
- Use a conforming XML parser (
roxmltree): it handles CDATA (raw-text sections), entities (escapes such as&) and end-of-line normalization [X §2.11]. Refuse DTDs and external entities, declarations that can make a parser fetch other files (core crates do no I/O). The reader takes text and strips a BOM. Decoding bytes is the caller’s job, as for.engfiles: planned forhpr-io, which doesn’t do it yet. - Take every
engineelement at any depth, so a bare<engine>root [P p.2] also works, but not one nested inside another engine. An engine with an error is skipped, with the error as a warning, when others in the file read. With repeated<data>or<comments>, the last is read, with a warning.<comments>keeps only text: XML comments and processing instructions inside are not part of it, and nested markup contributes its text. Every warning carries a kind: skipped (an engine left out), dropped (a value left out) or unusual (read as it stands). Points areeng-datachildren ofdata; also acceptpoint[P p.2]. - Match attribute names exactly, then ASCII case-insensitively (
Type/type); acceptinitMass/propMassas aliases [P p.2]. Ignore the rendering attributes silently; warn on and ignore other unknown attributes and elements. - Required:
code,dia,len,initWt,propWt, and at least 2 points withtandf. A missingmfgreads as empty, with a warning. Everything else isOption; a missingdelaysmeans no delay information. If only some points carrym(orcg), treat it as absent for all of them, and warn.auto-calc-*flags read1or0; anything else is left out with a warning. - Numbers: trim XML whitespace, then parse with Rust’s f64 parser. Reject non-finite values:
Rust accepts
inf,infinityandNaN. Warn ifpropWt≥initWt. Keep file units (g, mm) in the file model, in fields named for them (initial_mass_g). Convert to SI only when building the physical motor. The round trip g → kg → g is not bit-exact (4030.comes back as4030.0000000000005). 14 of 1,330 distinct mass and length values in the sets fail. - Keep strings verbatim, including the spaces in
mfg; normalize names in the catalog layer. Delays: keep the raw string; interpret it as in.engfiles (1000/100→ plugged,0ambiguous). - Point checks match
.eng. Error on negative or decreasingt, and on a lastfabove half the curve’s peak, where the file looks cut off. When other engines in the file read, that engine is skipped, with a warning. Warn on a lower lastf≠ 0, on negative thrust, and on anItotorpeakThrustthat disagrees with the curve by more than 1%.burn-timeis not checked: files round it from the last time.
Writer policy (strict, round-trip stable)
Round-trip stable: a file the simulator writes reads back to exactly the values it was written from.
-
Emit
<engine-database>,<engine-list>and one<engine>per motor. Use 2-space indent, LF endings, a final newline, UTF-8, and no XML declaration (none was observed; whether RockSim accepts one is unverified). -
Policy: the first line is an XML comment naming the program that wrote the file, its version and its designation in the FusionSpace product system. Every file the simulator writes has this line:
<!-- FusionSpace HPR 0.1.0 · FS-ACHERNAR · SW · TOOL 001 -->. XML readers skip comments, the simulator’s too, so the file reads back to the same values and writing it again gives the same bytes. Whether RockSim and OpenRocket accept a comment before<engine-database>has not been checked. -
Write attributes in RockSim’s order:
mfg code Type dia len initWt propWt delays auto-calc-mass auto-calc-cg avgThrust peakThrust throatDia exitDia Itot burn-time massFrac Isp tDiv tStep tFix FDiv FStep FFix mDiv mStep mFix cgDiv cgStep cgFix. Write only the ones present in the model. Points are written ast f m cg, verbatim, with no origin added or removed. An engine with fewer than two points, or whose lastfis above half its peak, is refused, as the reader would refuse the curve. -
Numbers use Rust
{}(Display): the shortest digits that round-trip exactly, no exponent, and-0for negative zero. -
Escape attribute values as
& < > ", and tab, LF and CR as	 . A literal one would read back as a space [X §3.3.3]. Escape<comments>text as& < >with CR as , without CDATA, and write it verbatim (no trimming). -
Flags are written
1or0. The rendering attributes are not kept, so they are not written. -
Apart from that comment, the writer adds nothing by itself. Converting from
.engis a separate step,hpr_motor::convertorhpr convert(since M4.2c, the command-line conversion). It fills what.englacks the way the observed files do. The counts are out of the files that give each attribute. Of 715 engines, 710 givemassFracandIsp, and 700 have a propellant mass above zero form’s shape:attribute filled as observed in a (0, 0)first pointadded when the curve’s first point is after ignition 715 of 715 Itotthe trapezoidal integral of the curve within 0.1% in 712 peakThrustthe largest fall but 9 burn-timethe last tthe last t, or in 281 of 715 a rounding of itavgThrustItot/burn-timewithin 0.1% in 712 m, = propWt= propWtin 696 of 715; the shape in 698 of 700cglen/2685 of 715 auto-calc-mass,auto-calc-cg1every file massFrac703 of 710 Isp, in kg 696 of 710 Typeunspecified, as the guide requires one [P p.1]one of the values seen Delays trade
-for,andPfor1000. Masses move from kg to g by moving the decimal point in their shortest digits, not by multiplying. Converting to.engdrops the attributes above, plusthroatDiaandexitDia, each named in a warning. It refuses a hybrid, and a motor with no delays the simulator can read until--delaysgives them. OpenRocket 24.12 opens every file converted from the 32 curves first bundled (motor_files.py); whether RockSim does is unverified. -
Invariant (test it): whenever
write(parse(x))succeeds,parse(write(parse(x))) == parse(x), with f64 compared by bits and strings compared exactly.
Checked against real files
On September 17, 2026, 821 of the 823 RockSim files in ThrustCurve.org’s solid-motor survey read, and
write-parse-write reproduces every value bit for bit. The other two have a time that goes
backwards and are rejected with its line. In the manufacturer sets, 704 engines read; one engine
with a backwards time is skipped with a warning. The files are cached under refs/samples/ and
never committed.
ERA5 weather files
Learn how HPR Sim reads ERA5 weather files to fly a rocket in a real day’s temperature, pressure and wind over the launch site.
ERA5 is a record of the weather over the whole Earth, every hour since 1940, from the European Centre for Medium-Range Weather Forecasts (ECMWF). It is a reanalysis: a weather model run over the past and held to the observations of the time. HPR Sim reads ERA5’s pressure-level files to fly a rocket in the weather of a real day. That means the temperature, pressure and wind over the launch site, from the ground up to a few kilometers or more.
Code: hpr_io::era5 and hpr_io::netcdf
(API reference), written for the ERA5-weather milestone
(M2.3a). The choices are in
ADR-081: ERA5 weather read from netCDF classic.
Using a file
Where to get a file, how to convert one from today’s Data Store, and how to fly a rocket in it.
Getting a file
ERA5 comes from the Copernicus Climate Data Store. An account is free. The data’s license is CC BY 4.0. You may use and share it if you credit it (“Contains modified Copernicus Climate Change Service information”). You accept it once on the dataset’s page before the first download.
- Open the dataset ERA5 hourly data on pressure levels from 1940 to present and its Download tab. For the product type choose Reanalysis.
- Choose these variables: Geopotential, Temperature, U-component of wind and V-component of wind.
- Choose the pressure levels that cover the flight. Air pressure halves about every 5.5 km (3.4 mi), so 1,000 hPa down to 500 hPa covers the lowest 5.5 km (3.4 mi). Include a level below the pad too (ERA5 continues its levels beneath high ground), so the pad lies between two levels. Below the lowest level the simulator continues the standard atmosphere and marks the air as extrapolated.
- Choose the day and every hour around the launch, in UTC, not every third or sixth hour. The simulator blends the two file times on either side of the launch, however far apart they are. So a file with gaps blends weather hours apart.
- Choose a small area around the site, at least a quarter of a degree beyond it on each side. ERA5’s grid points are a quarter of a degree apart, and the simulator needs the four around the site. It doesn’t join a whole-Earth grid’s last longitude to its first, so a site between them is refused. On a grid from 0° to 359.75° east, that is the last quarter degree west of 0°.
- Choose the NetCDF format, then convert the file as below. The simulator does not read GRIB, the other format offered (the weather services’ own binary format).
Converting a current file
Files from today’s Data Store are netCDF-4. Inside, that is HDF5, a general container format
that the simulator doesn’t read. Three lines of Python, with the xarray and netCDF4 packages
(pip install xarray netCDF4), rewrite a file in the older netCDF classic format:
import xarray
xarray.open_dataset("era5.nc").drop_vars(["number", "expver"], errors="ignore").to_netcdf(
"era5-classic.nc", format="NETCDF3_64BIT")
The two dropped variables are labels the classic format can’t hold: a 64-bit whole number and a text value. Older files, like most of the ones RocketPy ships, are classic already. If the simulator can’t read a file, its error says which kind the file is and gives this conversion.
This conversion is checked. The test takes NDRT 2020’s launch day. It was downloaded from the Data Store in 2021 as a classic file, and in 2024 as netCDF-4 and converted as above. NDRT 2020 is the University of Notre Dame’s rocket for NASA’s 2020 Student Launch. At every level, the two files’ geopotential agrees to 0.23 m²/s² (about 2 cm (0.79 in) of height). At every level too, their temperature agrees to 0.35 thousandths of a kelvin, and their wind to 0.11 mm/s. The older file stores its values as 16-bit whole numbers. The newer one carries the rounding of ECMWF’s own archive. So the gaps are consistent with each file’s rounding. The test pins these largest gaps.
A second check runs on a whole file. Three public flights of EuRoC 2022 fly in one netCDF-4 file
that RocketPy ships (predicted before compared).
The script
euroc_2022.py
converts it as above. It fails unless all 148,000 values of the four fields are the same bit for
bit, and RocketPy reads the same 37 levels from both files at each flight’s site and hour. Its
record
keeps both files’ SHA-256 and those levels. Each time a prediction is flown, HPR Sim’s own reading
of the converted file is held to them: the same pressures, and the temperature, wind and
geopotential height within 1e-12 of each value’s size (1e-12 outright for a value under 1).
To run it, from the repository’s root and in this order:
cargo xtask refs fetch rocketpy pythonfetches RocketPy’s files and the oracle environment.refs/venv/bin/python validation/oracles/netcdf/euroc_2022.py > /dev/nullis the conversion. It writes the converted file underrefs/and prints the record, which is already committed.- The same command ending in
--check, not> /dev/null, converts again into a scratch file. It fails unless it finds the recorded hashes and levels, and unless the converted file already inrefs/has the recorded SHA-256. cargo xtask public-predictions --checkflies the predictions in that file.
Neither check runs in CI, which has no RocketPy files.
Reading it
The example program
era5_weather
reads a small cut of the file RocketPy ships for Bella Lui’s flight. The Swiss student team EPFL
Rocket Team flew Bella Lui at Kaltbrunn on 22 February 2020. The pad was 407 m (1,335 ft) above
sea level. The file covers the pad at 13:00 UTC. The program prints the levels, then the air at the pad
and 500 m (1,640 ft) above it next to the standard atmosphere. Last, it flies the rocket in both, without its
parachute. Run it from a copy of the repository with cargo run --example era5_weather -p fusionspace-hpr.
On the command line, hpr weather era5 writes the same levels as a
profile file. The program prints:
ERA5 over 47.213476° N, 9.003336° E at 2020-02-22 13:00 UTC
level (hPa) height (m) temperature (°C) wind (m/s) from (°)
1000 240 14.6 1.3 212
975 453 13.2 1.3 213
950 670 12.1 1.1 213
925 892 10.3 1.7 207
900 1119 8.5 3.2 217
875 1351 7.6 5.6 232
850 1590 6.6 7.2 243
825 1834 6.0 8.7 253
800 2085 4.8 10.1 258
775 2344 3.5 10.7 261
height above the pad (m) pressure (hPa) temperature (°C) density (kg/m³)
0 ERA5 980.4 13.5 1.1916
0 standard 965.3 12.4 1.1778
500 ERA5 923.4 10.2 1.1354
500 standard 908.9 9.1 1.1218
Bella Lui to apogee apogee (m above the pad) drift at apogee (m)
ERA5 555.1 40.9
standard, calm 556.9 0.4
This design flies a stand-in motor; Bella Lui's real flight, on its own K828FJ, is
compared on the accuracy page.
The 1,000 hPa level lies at 240 m (787 ft), below the pad. ERA5 continues its levels beneath the ground, so the pad sits between two of them. That day was warm for February, and the pressure was high: the air at the pad was 1.2% denser than the standard’s. The wind was light at the pad and grew to 10 m/s (33 ft/s) by 2 km (1.2 mi).
Reading your own file. On the command line, give hpr weather era5
your file, your site’s latitude and longitude, and your launch time in UTC. From Rust, copy the
example and change three things:
- Read your file from disk (
let bytes = std::fs::read("my-file.nc")?;thenNetCdf::parse(&bytes)) instead of the bundled one. - Give your site’s latitude, longitude and height.
- Give your launch time in UTC. The printed heading has the date written in, so change it too.
The copy still flies the example’s rocket, Bella Lui.
Your own rocket shows how to describe yours. The steps are the example’s
own: NetCdf::parse on the file’s bytes, then Era5Profile::read with the site and time. Then
Era5Profile::sounding gives the atmosphere and the wind for the flight’s Environment.
How the simulator reads it
At each pressure level the file gives the geopotential, the
temperature and the wind’s east and north parts (u and v). It gives them at every grid point
and hour.
- At the site, each value is interpolated between the four grid points around it. That is “bilinear” interpolation, in degrees: first along one side, then the other. This is how RocketPy 1.13 does it, and HPR Sim follows its formula (RocketPy is MIT-licensed).
- At the launch time, HPR Sim weighs the two hours on either side by how close each is. At 13:12 it takes 80% of 13:00 and 20% of 14:00; on the hour it takes that hour alone.
- For heights, geopotential divided by is geopotential height. HPR Sim turns that into height above sea level with the World Meteorological Organization’s formula for the site’s latitude, as for any sounding. ERA5 itself stores no height in meters; the next section compares the two ways to get one.
- Between and above the levels, the atmosphere is the
sounding profile:
- Pressure falls with height as the weight of the air above requires (“hydrostatic”). RocketPy draws a straight line in height between the levels’ pressures instead.
- Above the top level, the 1976 standard atmosphere continues from that level.
- The wind’s east and north parts are interpolated in height, as RocketPy does. With
WindInterpolation::SpeedDirectionHPR Sim interpolates speed and direction instead.
Against RocketPy
The tests read RocketPy’s two ERA5 files for Bella Lui (47.2° N) and NDRT 2020 (41.8° N), plus NDRT’s day from today’s Data Store. RocketPy 1.13 reads the same files.
| HPR Sim | RocketPy 1.13 | measured difference | |
|---|---|---|---|
| Temperature, wind and geopotential at each level, on the hour | bilinear | bilinear | the same to 12 digits (5 readings, 14 or 37 levels each) |
| Height of a level | WMO’s formula, with gravity at the site’s latitude | ECMWF’s formula, with at every latitude | −0.0158% at Bella Lui, 47.21° N (−0.69 m (−2.3 ft) at 4.4 km (2.7 mi)); +0.0343% at NDRT, 41.78° N (+1.45 m (4.8 ft) at 4.2 km (2.6 mi)) |
| Launch between two of the file’s hours | both hours, weighted by time | the nearer hour | HPR Sim’s value is the weighted mean of RocketPy’s two readings, to 12 digits |
| Pressure between levels | hydrostatic | straight line in height | not measured yet |
| Above the top level | the standard atmosphere, continued | the top level’s values, held | not measured yet; Bella Lui’s file stops at 4.4 km (2.7 mi) |
Both height readings are approximations, and neither is exact. Geopotential measures the work of lifting air against gravity, so turning it into meters needs gravity on the way up. ECMWF’s knowledge base gives , with the Earth’s radius and the geopotential height, and says it neglects gravity’s change across the Earth. RocketPy uses it. HPR Sim uses the World Meteorological Organization’s formula, which takes gravity at the site’s latitude. At sea level it is 9.780 m/s² at the equator and 9.832 m/s² at the poles.
How far off each is depends on how ERA5’s model builds the geopotential of its own ground, which ECMWF doesn’t say. Taking it as times the ground’s height, HPR Sim’s reading is off by a fixed amount at every height. Taken that way, ECMWF’s is off by an amount that grows with height above the ground. With RocketPy’s Earth radius in ECMWF’s formula (the WGS 84 ellipsoid’s distance from the Earth’s center at the site), neither is always the smaller:
| model ground | HPR Sim’s error | ECMWF’s error, at the ground | ECMWF’s, 3 km (1.9 mi) above it |
|---|---|---|---|
| 407 m (1,335 ft) at 47.2° N | −0.04 m (−0.13 ft) | +0.03 m (0.098 ft) | +0.49 m (1.6 ft) |
| 1,400 m (4,593 ft) at 33° N (like Spaceport America’s) | +1.88 m (6.2 ft) | +0.31 m (1.0 ft) | −3.07 m (−10.1 ft) |
At the second site ECMWF’s reading is the closer one up to 1.95 km (1.2 mi) above the ground, and HPR
Sim’s above that. HPR Sim keeps WMO’s formula because it is the one it uses for every sounding. The
derivation is in the hpr_io::era5 module’s documentation
(API reference), and a test pins these numbers.
The netCDF reader
netCDF is a file format for gridded data, widely used for weather and climate. The simulator reads
the two classic kinds from Unidata’s published specification. They are the original format and the
64-bit offset format. Their files begin with the bytes CDF and then 1 or 2.
- It reads every value exactly as stored, all six types, and the tests check each one against Unidata’s own library on files that library wrote.
- Many files store small whole numbers plus a scale and an offset. The simulator unpacks them as the netCDF Users Guide says.
- A value can mean “missing”: the fill value, or a listed missing value. Where the Guide and the netCDF4 Python library disagree about which values are missing, the simulator follows the Guide:
| stored value | the Guide, and HPR Sim | netCDF4-python 1.7.4 |
|---|---|---|
beyond the fill value, on the side away from zero (for example -32768 when the fill is -32767) | missing | a value |
| −127 in bytes with no fill value given | a value | missing |
The first row matters for ERA5. Many ERA5 files store each value as a 16-bit whole number with a
fill of -32767, and a few values sit at -32768. Two of RocketPy’s other ERA5 files (both netCDF-4)
have them. One has 102 of 5,241,600 geopotential values and 4 temperatures. The other has 298 of
5,184,000 geopotential values and 2 temperatures. HPR Sim reads those as missing, where
netCDF4-python returns a number (198.66 K, for example, among neighbors near 301 K). Such
values look like damaged data, so reading them as missing is the safer choice. Era5Profile::read
then refuses the whole reading, naming the level, rather than print a wrong number. None of the
files the tests read has such values.
netCDF-4 files, and the rarer 64-bit data format (files beginning CDF and 5), are refused with
the conversion above.
What it leaves out
- Humidity. The simulator doesn’t read the humidity yet, so it flies in dry air. At 20 °C and 50% relative humidity, dry air is about 0.4% denser than the real air.
- Surface files. ERA5’s single-level files, with the 10 m (33 ft) wind and 2 m (6.6 ft) temperature, are not read.
- GRIB and netCDF-4. Convert them first, as above.
- The longitude seam. On a whole-Earth grid, a site between the grid’s last longitude and its first is refused. On a 0° to 359.75° grid, that is the last quarter degree west of 0°. Download a regional area around the site instead.
- Geoid. ERA5’s heights are above sea level. The simulator has no geoid model, so a flight takes them as heights above the WGS 84 ellipsoid. The exception is when you give the site’s geoid height. That is the height of sea level above the ellipsoid, up to about 100 m (328 ft, Geodesy).
Sources and tests
The documents the reader follows, and the tests that hold it to them.
Sources
- [U] Unidata, NetCDF File Format Specifications, “The Classic Format” and “The 64-bit Offset
Format”, and the netCDF Users Guide’s “Attribute Conventions”, netCDF-C documentation. Captured
September 26, 2026 and pinned as
unidata-netcdf-file-formatandunidata-netcdf-attribute-conventionsin the reference lock file. - [H] H. Hersbach et al., “The ERA5 global reanalysis”, Quarterly Journal of the Royal Meteorological Society 146 (2020), pp. 1999–2049.
- [ECMWF] ECMWF Knowledge Base, “ERA5: compute pressure and geopotential on model levels,
geopotential height and geometric height”, captured September 26, 2026 and pinned as
ecmwf-era5-geometric-height. - [WMO] WMO-No. 8, Guide to Instruments and Methods of Observation, Vol. I (2023), eqs.
12.15–12.16,
wmo-no8-vol1-2023. - RocketPy 1.13.0 (MIT): its reading of the same files is the reference in the tests.
Tests that pin this
hpr_io::netcdf::tests::every_file_reads_as_the_unidata_library_reads_it: every type, record variables, the padding cases and the packing conventions. It runs on 12 files the Unidata library wrote (validation/oracles/netcdf/write_cases.py), with each difference from netCDF4-python listed.hpr_io::netcdf::tests::each_break_of_the_grammar_is_refused_for_its_reason,variables_that_claim_more_bytes_than_the_file_holds_are_refusedanda_slab_too_large_to_pad_is_refused, with two fuzz tests: damaged or hostile files are refused, never a crash.hpr_io::era5::tests::on_the_hour_it_reads_the_levels_rocketpy_reads, and the height difference’s cause, level by level (the_two_height_readings_differ_as_the_guide_says).hpr_io::era5::tests::each_height_reading_errs_as_the_module_documentation_says: the table of height errors above.hpr_io::era5::tests::between_hours_it_weights_the_two_hours_in_time.hpr_io::era5::tests::the_current_data_store_file_converted_as_the_guide_says_reads_like_the_older_file.- The extracts and RocketPy’s reading come from
validation/oracles/netcdf/era5.py. validation/oracles/netcdf/euroc_2022.py --check: the whole EuRoC 2022 file’s conversion.cargo xtask public-predictions --check: HPR Sim’s reading of the converted file against RocketPy’s levels. Both need RocketPy’s files, so neither check runs in CI.
Flight logs: the record and the layouts read
See which altimeters’ flight logs HPR Sim reads, what it keeps from each, and how that was checked.
An altimeter or flight computer saves its flight as a file. The file holds a clock and the readings of its sensors. Examples are a barometer’s altitude, an accelerometer, a battery’s voltage and, on some, a GNSS receiver’s position. Each maker writes its own layout. HPR Sim reads each layout into one record, the same for every logger. That way, what comes after (the readings, and later the comparison with a simulation) doesn’t depend on which altimeter flew.
What is checked, and what is not. One damaged file is an AltOS export whose header
line is damaged. Another is an Eggtimer download whose decimal points were taken out. The third
is an RRC3 export whose rows were sorted out of order. Where a header names no unit, the reader
decides it from the file and says how in a note (units the file decides).
In the four layouts read since
M7.1c4, a unit two checks don’t settle is kept as written.
The file’s number is stored unchanged, with no SI value made from it. So many of their columns
keep the file’s own numbers, and their readings come only from a height or pressure whose unit
was read. The Raven’s .FIPa and the RRC3’s .rff raw downloads match their makers’ exports of the same flights wherever an export sits
beside them. Of their 63 sample files, 7 have no export beside them, and those 7 are unchecked
(raw downloads) (evidence row G6). The Featherweight
app’s flight summaries hold the logger’s own figures and no samples. Only their maximum and pad
altitudes are checked, against the files of samples beside them
(Featherweight’s summaries) (evidence row G7).
No document describes the bytes of the AltiMAX’s .ALS or the AIM’s .xtra, so each of those
layouts rests on one sample flight. The layouts the roadmap names with no sample
are listed, with what a reader would need
(evidence row G9).
To read a flight from these layouts today, use the Rust library: give the file’s bytes to
hpr_flightdata::import::read (API reference). It
recognizes the layout from the file’s content, never its name, and reads it or refuses it, naming
the layouts it knows. A file of binary records has no layout to recognize. Read it with
records::read, or a console capture of them with capture::read, by the layout you state
(below):
let bytes = std::fs::read("flight.csv")?;
let log = hpr_flightdata::import::read(&bytes)?;
for channel in &log.channels {
println!("{} ({:?}): {} samples", channel.column, channel.quantity, channel.values.len());
}
hpr analyze, the command line, and Python read each layout import::read
recognizes by its own reader. The same tools read a table or binary records by a column mapping or a
record layout (Reading your own logger). Since M7.2b, readings on every
logger, the readings (liftoff, apogee, the top speed and
landing) come from any record’s height track. A height track is the logger’s own barometric
altitude, a pressure turned into a height by the 1976 standard atmosphere, or an altitude channel.
Each reading is within a stated bound or withheld with its reason. A GNSS height gives none
(Flight-log readings). Since M7.2c, the rest of the
readings, the same track gives the flight time and each canopy’s
descent. Since the same milestone, an accelerometer column the reader names as the rocket’s axis gives the top acceleration
and burnout. These columns are AltOS’s acceleration, the Raven’s and Blue Raven’s
Axial Accel (Gs), the Eggtimer’s Accel, the ARTS2’s Acc, among others. AltOS’s acceleration
doesn’t count when it comes from an EasyMini or a TeleMini, which have no accelerometer. On those
boards the column is then the barometer’s estimate. The file shows this by having neither an
inertial unit’s columns nor a GPS receiver’s. A board’s three axes don’t say which lies along the
rocket, so they give neither. Nor does an axial column whose pad, coast and thrust don’t settle
which way up it reads. Nor does one that shows no thrust (direction_unstated). Six records of the
sample logs have such an axial column: three AltOS CSV, two Entacore AIM CSV and a Raven CSV (the
accelerometer). The survey’s report counts the
readings each family gives and withholds (how it was checked).
The readers were written for these milestones, each as the decision record beside it decided:
- M7.1a (the record, the survey of the sample logs, and the PerfectFlite, AltOS and Raven readers), as ADR-251 decided.
- M7.1b (the Blue Raven, RRC3 and Eggtimer readers), as ADR-253 decided.
- M7.1c1 (the GPS logs), as ADR-254 decided.
- M7.1c2 (AltimeterCloud, Entacore AIM, PerfectFlite’s
.pfaand an Eggtimer TRS’s terminal text), as ADR-255 decided. - M7.1c3 (the SillyGoose, Fluctus and ARTS2 readers), as ADR-256 decided.
- M7.1c4 (AerospaceNU’s flight computer board and ground
station, a phone app’s
launchCSV and an Eggtimer’s RTF), as ADR-258 decided. - M7.1c5 (the Raven’s
.FIPaand the RRC3’s.rffraw downloads), as ADR-259 decided. - M7.1c6 (Featherweight’s summaries, and the files filed as not logs), as ADR-260 decided.
- M7.1c7 (zip archives, PerfectFlite’s exports with no header row and Blue Raven files with no date), as ADR-261 decided.
- M7.1c8 (the R-DAS’s raw text), as ADR-262 decided.
- M7.1c9 (AltOS’s radio telemetry), as ADR-263 decided.
- M7.1c10 (AltOS’s
.eepromdownloads), as ADR-265 decided. - M7.1c11 (the ARTS2’s
.odfand raw CSV), as ADR-266 decided. - M7.1c12 (Missile Works’ RTx), as ADR-267 decided.
- M7.1c13 (tables read by their headers), as ADR-268 decided.
- M7.1c14 (Excel workbooks), as ADR-269 decided.
- M7.1c15 (European-locale exports and mappings a publisher states), as ADR-270 decided.
- M7.1c16 (binary records by a stated layout), as ADR-271 decided.
- M7.1c17 (the Blue Raven’s USB download), as ADR-272 decided.
- M7.1c18 (a course’s Teensy data logger), as ADR-274 decided.
- M7.1c19 (one team’s radio telemetry packets), as ADR-274 decided.
- M7.1c20 (the FIP export pasted below no header, and the AltiMAX’s Excel export), as ADR-274 decided.
- M7.1c21 (a MARSA download, AltOS’s telemetry as a table, and its CSV after a spreadsheet), as ADR-274 decided.
- M7.1c22 (tables a mapping holds to physics), as ADR-274 decided.
- M7.1c23 (the AltiMAX’s
.ALSand the AIM’s.xtraand raw dump), as ADR-274 decided.
The layouts read
| Layout | Loggers | Recognized by | Reader |
|---|---|---|---|
PerfectFlite .pf2 | Pnut, StratoLogger, StratoLoggerCF | names PerfectFlite | .pf2 files |
| PerfectFlite CSV export | the same, through PerfectFlite’s software | Time,Altitude, and more of the export’s own column names | below |
| PerfectFlite text export | the same | Time, Altitude, Temp. and Voltage, separated by tabs; or, with no header row, rows of four tab-separated numbers, the third a temperature followed by its unit’s letter, F or C, such as 71.5F | below |
PerfectFlite .pfa | Alt15K/WD, an older PerfectFlite altimeter, through PerfectFlite’s DataCap program (AltCapWD on the Mac) | names PerfectFlite and has a **!!Data: line | below |
| AltOS CSV | Altus Metrum’s TeleMetrum, TeleMega, EasyMega, EasyMini, through AltosUI (Altus Metrum’s ground software) | a full export: #version,serial,flight,, or # comment lines and then that header or version,serial,flight,. A table cut from an export: a header of AltOS’s own names that includes time, state and state_name, where at least one of the first 100 rows pairs a state number with its AltOS name | hpr_flightdata::altos (below) |
| Raven FIP CSV | Featherweight Raven, through the Featherweight Interface Program | opens with a time column and holds the Raven’s Axial Accel (Gs) channel | hpr_flightdata::raven |
Raven .FIPa | Featherweight Raven, its memory as the Featherweight Interface Program downloads it, before any export | opens #Component=Raven, and its text lines end, within the first 4,096 bytes, in a #den line followed by a frame’s : | hpr_flightdata::raven_fipa (below) |
| Blue Raven CSV | Featherweight Blue Raven, through its phone app: a low-rate file (barometer, inertial figures, flags) and a high-rate file (gyroscopes, accelerometers, attitude) | Year,Month,Day,Time,Flight_Time_(s),Sync,, or Flight_Time_(s),Sync, in a file with no date | hpr_flightdata::blueraven |
| Blue Raven USB download | Featherweight Blue Raven, its low-rate or high-rate set as its USB port sends it to a serial terminal, one line a sample | a line among the first 1,000 that opens @ LOG_HIR or @ LOG_LOW and closes with a CRC that checks | hpr_flightdata::blueraven_usb (below) |
| Teensy data logger, tab-separated | a university course’s own logger, built around a Teensy board, its older layout: one sensor’s reading a line | its first line is a tag, a whole-number clock and values, by tabs, and one of its first 100 is an Alt line with P and MSL | hpr_flightdata::teensy (below) |
| Radio packets | one university team’s flight computer’s radio packets, 255:…:254: its own log, or the text a receiver wrote of what it heard | its first line is a packet, a whole number or a Gain[…] line, and one of its first 100 is a packet | hpr_flightdata::packets (below) |
| Radio packets in RTF | the same packets in an RTF document a spreadsheet saved as CSV, 255,…,254 | an RTF document, one of whose first 100 lines, its markup taken off, is a packet | hpr_flightdata::packets (below) |
| Teensy data logger, named fields | the same course’s logger, its newer layout | its first line states a sensor’s units, such as ICM data in us, milli-g, …, and one of its first 100 is a tag, t, a clock and name-value pairs, by commas | hpr_flightdata::teensy (below) |
| RRC3 CSV | Missile Works RRC3, through mDACS, Missile Works’ program that downloads its flights | Time, Altitude, Pressure, Velocity, then any of Temperature, Events, Voltages, perhaps with units in brackets; separated by commas, or by semicolons, a European locale’s, perhaps ending each line | hpr_flightdata::rrc3 |
RRC3 .rff | Missile Works RRC3, its memory as mDACS downloads it, before any export | a .NET serialization header (MS-NRBF, version 1.0) and, within the first 4,096 bytes, mDACS’s class name mDACS.AnalysisSupport+FlightRecord | hpr_flightdata::rrc3_rff (below) |
| Eggtimer CSV | Eggtimer Classic, TRS, Quantum and Proton, through Eggtimer’s download | T,Alt, and more of Eggtimer’s column names, or the same separated by semicolons, as a European locale’s spreadsheet saves it | hpr_flightdata::eggtimer (below) |
| Eggtimer text | Eggtimer TRS, its download captured by a terminal program | a title Eggtimer <model> <firmware> … Flight Settings, then Eggtimer’s header row T,Alt,… | hpr_flightdata::eggtimer (below) |
| Eggtimer RTF | the same terminal download, saved by a text editor as an RTF document | opens with {\rtf, and its text holds the terminal download’s title and header row | hpr_flightdata::eggtimer (below) |
| AltimeterCloud CSV | Rocketry Ltd Nano V1 and Mercury, as a flight page on altimetercloud.com hands the log back | a header within the first 65 lines whose first name is Time(ms) (in any case) and which also names acceleration_total(mG) and tilt | hpr_flightdata::altimetercloud (below) |
| Entacore AIM CSV | Entacore AIM XTRA (the flight computer’s own log) and AIM BASE (the telemetry its ground station received), as the AIM software’s Export to Excel… writes them | the first line starts with a time column, names at least two, and names one of the AIM’s own channels, such as Pressure AGL, lat. X accel. or eject. bat. voltage | hpr_flightdata::entacore (below) |
| SillyGoose text | AerospaceNU’s SillyGoose flight computer: its own log, tab- or space-separated, with or without a CONFIG settings line | a first line, or the one after CONFIG, starting timestampMs and naming pressurePa and altitudeM | hpr_flightdata::sillygoose (below) |
| Silicdyne Fluctus CSV | Silicdyne Fluctus, as its Fluctus Control Center exports a flight | a sep= line (such as sep=;) within the first 16 lines, or none, then a header starting time that names deltaTime and baro-altitude | hpr_flightdata::fluctus (below) |
| ARTS2 CSV | Ozark Aerospace ARTS2, its interpreted data as its software exports a flight | a first line of # and the names MET Acc Vel iAlt pAlt, by spaces, tabs or commas, in any case | hpr_flightdata::arts2 (below) |
ARTS2 .odf | Ozark Aerospace ARTS2, a flight as its software, DataAnalyzer, saves it: the board’s settings and calibration, then the sensors’ counts | its bytes open with the length 9, then Ozark.odf | hpr_flightdata::arts2_raw (below) |
| ARTS2 raw CSV | the same, the sensors’ counts as DataAnalyzer exports them, with no calibration | a first line that isn’t blank reading MET,Acc(HI),Acc/Baro(LO),Baro(HI),State, the names as written | hpr_flightdata::arts2_raw (below) |
| AerospaceNU board CSV | AerospaceNU’s flight computer board (FCB), its binary log as the club’s tools turn it into a CSV | a first line whose first name is empty (the club’s row number) and which names packetType, timestamp_ms or timestamp_s | hpr_flightdata::aerospacenu_fcb (below) |
| AerospaceNU ground station text | the same board’s radio downlink, one packet a line, as the club’s ground station logged it | a first line that isn’t blank starting RUN START | hpr_flightdata::aerospacenu_gs (below) |
Phone app launch CSV | an app, named in none of its files, that logs a phone’s own sensors in flight | a first line that isn’t blank starting Seconds,Timestamp,AltitudeMSLGPS, the only mark the files carry: any file whose header opens so is read as this app’s, as the app’s name is unknown | hpr_flightdata::phone_launch (below) |
| Featherweight summary CSV | Featherweight Blue Raven and GPS tracker: the flight’s summary, as the Featherweight app exports it beside the samples | a first line that isn’t blank naming Rocket Name, and Max Altitude or Launch time UTC among the first 200 lines | hpr_flightdata::fwsummary (below) |
| Featherweight GPS CSV | Featherweight’s GPS tracker: its own log, and its ground station’s log of every tracker it hears | a first line opening UTCTIME,UNIXTIME, or TRACKER,DATE,TIME, that names the latitude and longitude (LAT and LON, or TRACKER Lat and TRACKER Lon) | below |
| KML | GPS tracks as AltOS, Missile Works’ RTx, Big Red Bee’s BeeLine, fw2kml (a converter of Featherweight’s logs), GPS Visualizer and others write them for Google Earth | the document’s root element is kml | below |
| GPX | GPS tracks in the GPS Exchange Format, version 1.0 or 1.1; no sample log is one, so the reader is checked on invented files only (evidence row G1) | the document’s root element is gpx | below |
| NMEA 0183 | a GPS receiver’s own sentences, written to a file as it sends them | at least 3 of the first 50 lines open with a sentence whose checksum checks out, such as $GPGGA,…*hh, or, in a shorter file, every line does | below |
| R-DAS raw text | AED Electronics R-DAS, its raw data as its Windows software exports a flight | a first line that isn’t blank reading *** Configuration ***, and a *** Raw data *** line within the first 200 | hpr_flightdata::rdas (below) |
| MARSA download | MARSA Systems’ MARSA4 and MARSA54, a flight as their software, MARSA_Connect, saves it to a .dat file, or a spreadsheet re-saves it | a first line that isn’t blank that is a setting or a heading, <NAME> value or <NAME>, and a <MARSA VERSION> setting with a value within the first 200 lines that aren’t blank | hpr_flightdata::marsa (below) |
| AltOS telemetry | Altus Metrum’s TeleMetrum v2 and newer, the packets a TeleDongle receiver hears, as AltosUI saves them to a .telem file | a first line that isn’t blank reading TELEM, a space and an even number of hexadecimal digits | hpr_flightdata::altos_telem (below) |
| AltOS telemetry CSV | the same packets decoded to a table, a TeleMega’s 0x09 packets one a row | a first line that isn’t blank opening serial,tick,ptype, | hpr_flightdata::altos_telem_csv (below) |
AltOS .eeprom | Altus Metrum’s TeleMetrum, TeleMega, EasyMega and EasyMini, the board’s own log as AltosUI downloads it | a JSON object naming log_format and product; or, within the first 1,000 lines, a Config version: line and a manufacturer altusmetrum.org line | hpr_flightdata::altos_eeprom (below) |
RTx .rtx | Missile Works’ RTx GPS tracker, its fixes as mDACS (Missile Works’ program) saves a download | a .NET serialization header (MS-NRBF, version 1.0), then the class record of a list of 32-bit integers | hpr_flightdata::rtx (below) |
| RTx CSV and text | the same fixes, as mDACS exports them | a first line that isn’t blank reading UTC Time,Latitude,Longitude,Altitude,Velocity,VDOP,NavStatus,Sats,SOG,COG, or the text file’s tab-separated UTC, Lat, an empty name, Lon, an empty name, Alt, Vel, VDOP, Nav, Sats, SOG, COG | hpr_flightdata::rtx (below) |
AltiMAX .ALS | Rocketronics AltiMAX, a flight as the altimeter writes it to its memory card | a header stating at least one record, then records of 22 bytes, the first up to 1,000 each holding a first byte with bit 0 set and bit 1 clear and its voltage channel the one after the record before’s | hpr_flightdata::altimax_als (below) |
Entacore AIM .xtra | Entacore AIM XTRA, a flight as the AIM software saves it | a Boost serialization archive’s signature, serialization::archive, the top object’s header the sample has, and a first record whose class is an AIM kind’s | hpr_flightdata::entacore_raw (below) |
| Entacore AIM raw dump | the same flight computer’s memory, as the AIM software downloads it before any conversion | a first byte 0x13, a recording’s opening, then the AIM’s records, up to 1,000, or erased memory | hpr_flightdata::entacore_raw (below); import::read takes a dump of one recording, and entacore_raw::read_dump each recording of several; import::read_one, as hpr analyze --recording does, reads the one chosen |
| Table read by its header | a logger no other reader knows: a team’s flight computer, a logging script, a spreadsheet saved as CSV | tried after every other layout: a header row naming a clock with a unit of time, such as Time (s) or time__us, then a row with a number there | hpr_flightdata::generic (below) |
Excel workbook, .xlsx | a flyer saving a log, or several, as a spreadsheet | not by import::read, which refuses an archive: workbook::read opens it, then each sheet is recognized as a file of its own; import::read_one, as hpr analyze --sheet does, reads the sheet chosen, or with none the one sheet that reads | hpr_flightdata::workbook (below) |
| Raven FIP rows below no header | a Raven FIP CSV pasted into a workbook with its header line missing | not recognized: read under the header line you state | hpr_flightdata::raven::read_rows, and custom::read_by_fip_header from a workbook’s sheet, as hpr analyze --fip-header does (below) |
AltiMAX Excel export, .xls | Rocketronics AltiMAX, a flight as its PC software exports it to Excel | not by import::read, which refuses the .xls bytes: xls::read writes the worksheet out as text, whose header’s first five names are TIME,PRESS FILTER [hpa],HEIGHT FILTER [m],PRESS RAW [hpa],HEIGHT RAW [m]; import::read_one, as hpr analyze does, reads it | hpr_flightdata::xls and hpr_flightdata::altimax (below) |
| Zip archive | not a log: a flight’s files, zipped to share them | its bytes open PK then 3, 4 | hpr_flightdata::archive (below) |
| Binary records | a team’s flight computer saving each sample as a fixed run of bytes, with no header | not recognized: read by the record layout you state | hpr_flightdata::records (below) |
| Console capture | the same records, dumped as base64 by the flight computer’s shell and saved by a terminal program | a start marker line, ----++++//[[( name start )]]\\++++----, in its first 1,000 lines; import::read refuses it as stating no layout | hpr_flightdata::capture (below) |
The Blue Raven app writes each flight as two files. The low-rate file is logged 50 times a second, and the high-rate file 500 times a second (Blue Raven User’s Guide, May 12, 2026, p18). Each is read on its own, as a record of its own, not joined to the other. The high-rate file holds no altitude. So its record’s primary track is empty and its channels hold everything. The low-rate file of the same flight holds the altitude. The app’s summary of the flight is read too, as a record of figures with no samples (below).
Some files among the sample logs aren’t flight logs, and are counted apart as such. They are:
- Debrief’s made-up sample flights, which say so in their first row;
- a team’s checklists for preparing a flight;
- a Blue Raven’s deployment settings saved as spreadsheets or CSV;
- a flyer’s summaries of flights in spreadsheets;
- the events files a flyer’s own program wrote from a Blue Raven’s low-rate file;
- that program’s copy of a Blue Raven’s summary;
- the descriptions of a rocket such programs read;
- a team flight computer’s saved state, one row;
- an OpenRocket simulation’s export;
- a wind profile;
- a flight computer’s and a battery’s housekeeping;
- two GPS tracks’ coordinates copied from their maps, with no clock;
- three tables a program worked out from a log.
Every other file in the sample logs is in a layout read here, except 3 damaged files. The survey’s report counts each kind.
Zip archives
Flyers often share a flight as one zip archive. It may hold a Blue Raven’s high-rate and low-rate
files with the app’s summary, or a folder of everything the flight left behind. An archive isn’t a
log, so hpr_flightdata::import::read refuses one with a reason that says so. Instead,
hpr_flightdata::archive::unpack takes its files out, in memory, each a name and its bytes. Each
file is read as it would be on its own. Nothing is written to disk, so a file’s name, folders and
all, is only a label. An archive inside an archive is one of its files, and isn’t opened.
let bytes = std::fs::read("flight.zip")?;
for member in hpr_flightdata::archive::unpack(&bytes)? {
match hpr_flightdata::import::read(&member.bytes) {
Ok(log) => println!("{}: {} ({} channels)", member.name, log.format.name(), log.channels.len()),
Err(error) => println!("{}: not read, {error}", member.name),
}
}
An archive comes from someone else. A small one can be built to unpack to far more than memory holds (a zip bomb). So at most 256 MiB (268 MB) come out of one archive. That is about eight times the largest sample archive, which unpacks to 32 MB. The limit counts the bytes as they decompress, never from the sizes the archive states. An archive is refused whole, with its reason, and none of its files is read, when:
- two of its files share a name (the
ziplibrary HPR Sim uses would silently keep only one); - a file is a symbolic link, or a folder’s entry holds bytes;
- a file is encrypted;
- a file is compressed by a method other than the two that archives of logs use, stored (not compressed) and deflated (zip’s usual compression);
- a file fails its CRC-32, the checksum every zip file carries to catch damage.
The crate’s tests build an archive of each kind and check its refusal. Two property tests feed
random and damaged archives to the reader. They show the reader refuses them or stays within the
bound, and never crashes. Only the Rust library opens archives so far: hpr analyze and the Python
package refuse one, and the command line asks for the log inside it. A workbook, though built on
a zip archive, they read one sheet at a time (Excel workbooks).
The 8 archives among the sample logs hold 29 files. 10 are byte-for-byte copies of files already among the samples. The other 19 files are 8 Blue Raven high-rate and low-rate files, 3 of the app’s summaries and a GPS tracker’s KML track. The remaining 7 aren’t logs. Every one of the 12 logs reads. The 3 summaries are checked against the Blue Raven files in their archive, as the others are (checked against the files beside). All 3 agree. Two CSV files in one archive name other altimeters’ formats in their file names. They use the Blue Raven’s column names, but their values aren’t the Blue Raven’s. At the same moments, their altitudes differ from its low-rate file’s by up to several hundred feet. Which logger wrote them isn’t known, so they aren’t read as a Blue Raven’s. They are read as tables by their headers since M7.1c13. Their altitude is in the feet the header states, and the rest of their columns are as written.
Excel workbooks
Some flyers keep a flight’s log in an Excel workbook (.xlsx). It may be the Blue Raven app’s
files pasted side by side as sheets, or a table whose header names its units. hpr analyze and
the Python package read one sheet at a time, in one of two ways. The first is by the sheet’s own
reader. The sheet is chosen with --sheet N (sheet= in Python), counting from 0. With none
chosen, it is the workbook’s one sheet that reads as a log. The second is by a column mapping and
the sheet’s number
(A file of several records). In Rust,
hpr_flightdata::import::read_one reads one sheet as they do. A workbook is a zip
archive of XML parts (ECMA-376, Office Open XML, Part 1, §18), so
hpr_flightdata::import::read refuses one, as it does any archive. Instead,
hpr_flightdata::workbook::read writes each worksheet’s cells out as comma-separated text, one
line a row. It then reads each sheet as the file it came from. The file is a Blue Raven’s CSV or
its app’s summary, an Eggtimer’s CSV, a Featherweight tracker’s, or a
table read by its header. One workbook can give several logs.
A sheet that doesn’t read is reported with its reason, and the other sheets are still read.
let bytes = std::fs::read("flight.xlsx")?;
for sheet in hpr_flightdata::workbook::read(&bytes)? {
match &sheet.log {
Ok(log) => println!("{}: {}", sheet.name, log.format.name()),
Err(error) => println!("{}: not read, {error}", sheet.name),
}
}
What a cell becomes. A cell is written as the workbook stores it, never as a spreadsheet
displays it, so no digit is lost or invented. A number is written as its stored digits
(0.10000000000000001 stays so, though Excel shows 0.1). A string is written as its text, a
formula as the value saved with it, and a truth value as TRUE or FALSE. An error such as
#DIV/0!, or a formula with no value saved, is left empty, and the log’s notes count them. A line
break inside a cell, as in a header wrapped onto two lines, becomes a space. Every row is written
as wide as the sheet’s widest, so short rows get empty cells. A row with no value is left out.
Dates. A spreadsheet stores a date as a count of days, a serial number. It shows the number
as a date only through the cell’s number format, the display pattern attached to it, such as
m/d/yy h:mm. A number under a format that shows a date is written as one. Serial 45,000.75
under m/d/yy h:mm is 2023-03-15 18:00:00, 45,000 days after December 30, 1899 and then three
quarters of a day. Under a format that shows only a time, a number under 1 is written as a time of
day, 18:00:00. Under that format, a number that also holds a day is written as a date and a time. An elapsed time,
such as [h]:mm:ss, counts its hours past 24 (36:00:00). Seconds are rounded to the
millisecond. A workbook that counts from 1904, as old Mac workbooks may, is read from 1904. No
sample workbook does, so that path is checked by the crate’s tests alone
(evidence row G2). A date before March 1, 1900 is kept as the number stored, and
the notes count it. That is the range where Excel’s calendar holds a 29 February 1900 that never
was. A date after December 31, 9999 is kept and counted the same way. Every other number is kept as
stored, so a clock a logger wrote in seconds stays a number.
Bounds. A workbook comes from someone else. Its parts come out within the archive bound. At most 256 MiB of text is kept from one workbook. That text is its list of shared strings (the text cells share, stored once) and the text written. Each byte is counted before it is kept. So a small file of one long string repeated in every cell is refused, not written out. The sheets are read as a stream: the largest sample sheet is 60 MB of XML. A workbook is refused, with its reason, when:
- a part it names is missing or isn’t well-formed XML;
- a part declares a document type or names an entity of its own (a way to make a small file expand);
- cells or rows come out of order, past Excel’s last cell,
XFD1048576, or a cell holds two values; - a cell holds what its type says it can’t, such as a number that isn’t one;
- two sheets share one part.
The crate’s tests check each refusal and the bound, and a property test writes random cells and reads them back.
How it was checked. The 16 sample workbooks of flights’ logs hold 28 sheets:
| Outcome | Sheets |
|---|---|
| read as a Blue Raven’s CSV | 6 |
| read as the Featherweight app’s summary of a Blue Raven’s flight | 2 |
| read as a Featherweight tracker’s CSV | 2 |
| read as an Eggtimer’s CSV | 1 |
| read as a table by its header | 10 |
| no value, only a chart | 3 |
| refused: an Eggtimer table a person added a column with no name to, and three layouts no reader knows yet (a sheet of the flight’s peak figures, an OpenRocket simulation’s export, a simulation set beside the flight) | 4 |
The workbook reader’s text was checked against openpyxl 3.1.5, an independent Python reader of
workbooks (validation/oracles/xlsx/cells.py). Every one of the 5,743,747 cells of the 16 that
hold a value agrees, 147,958 of them dates and times. That checks the copying, not the layouts:
each sheet’s columns and units are only as right as the reader it goes to. A probe run when the
check was built, not committed, moved the reader’s calendar by one day, and 27,103 cells
disagreed. Two more workbooks, Raven FIP exports pasted below no header, are read by the header
stated for each (below). The older .xls file, a
different binary format, is read by its own reader (below). Each of
these is checked the same way. Since M7.1c22, a PerfectFlite
export pasted into a workbook with a person’s notes beside it is read by a column mapping. The
notes are left out
(tables a mapping holds to physics). A state estimator’s
output in a workbook is a filter’s, not a log. Three more workbooks are flyers’ summaries of
flights, not logs.
R-DAS raw text
HPR Sim reads the R-DAS’s raw export but converts nothing in it. The record holds the file’s counts, no altitude and no events. The R-DAS is a flight computer AED Electronics sold in the early 2000s. It reads its accelerometer, its barometer and, as its owner chooses, four digital and six analog inputs, up to 200 times a second. It keeps the 2 s before liftoff (R-DAS User Manual, V1.5, 2001, p. 6, p. 7, p. 14). Its Windows software exports a flight as text, raw or converted with calibration values held in the software. The sample logs hold the raw export only: 54 files from a college course’s flights in 2008. Of these, 28 were recorded on board at 200 Hz and 26 at 10 Hz. By their names, the 26 are the course’s telemetry records.
The raw file opens with a summary of the configuration, then a table of counts. Each count is a 10-bit converter’s whole-number reading of 0 to 5 V, 0 to 1,023, a step 4.883 mV. The counts are to be converted “with the calibration values” (p. 14). The file holds none:
Timecounts seconds from liftoff (the manual’s figure 2.2, p. 10); every sample file starts at −2.000. The seconds rest on the configuration’sData is sampled at N Hz.: the clock’s average step must be that interval within 1%, or the file is refused. In every sample file it is exact.Acc,PrsandADC0toADC5are kept as written, in no unit HPR Sim knows. A value that isn’t a whole count refuses the file, as a converted export would. The manual’s R-DAS has an ADXL150 accelerometer (±50 g) and an MPXS4100A barometer, resolved to 0.09 kPa (p. 7). But the file doesn’t say which board or sensors wrote it, and others have been fitted (a college course’s pressure lab names an MPXH6115A). So no data sheet is applied.Digis read as a hexadecimal word, such as00B0(176), and kept as its number. The manual says it holds the digital inputs and the flight’s phase. The manual also says that “bit 3 is set when timed recovery was used” (p. 14, p. 22). But the files write a 16-bit word that never sets bit 3 of either byte. In 27 of the 28 on-board sample files the word reads0000, then0010within 0.25 s after the zero. After that it reads0020,0030and, near the end,8030. The 28th has00B0and80B0for the last two. Those values are unconfirmed as the phases, so no event is taken from the word.
The configuration must state the rate and list the inputs once each. The table’s header must
name them in order (Acceleration as Acc, Pressure as Prs, the digital inputs as Dig).
A file that fails either is refused. Its lines are kept in a note, and its firmware version is the
record’s. The record’s primary track is empty, as for the Raven’s .FIPa, and every
column is a channel. For example, the file the crate’s tests read, invented, eleven rows at 10 Hz
from −0.3 s, one of them shown:
Data is sampled at 10 Hz.
Inputs that were sampled: Acceleration, Pressure, the digital inputs, ADC0, ADC1.
*** Raw data ***
Time Acc Prs Dig ADC0 ADC1
0.100 700 799 0010 505 252
That row is Acc 700 and Prs 799 counts and Dig 16, at 0.1 s. The note says Time is in
seconds. That is because its average step, from −0.3 s to 0.7 s over ten steps, is 0.1, the 10 Hz
interval.
Checked: all 54 sample files read, pinned by the survey. Left out:
converting the counts, which needs the software’s calibration values, and events from Dig. With
no altitude or pressure in a unit, the record gives no reading (no_height_track,
Flight-log readings).
AltOS telemetry
HPR Sim reads the telemetry an Altus Metrum flight computer sends by radio, as AltosUI, Altus Metrum’s ground software, saves it. It is checked on two sample files, two flights of one team’s TeleMetrum. One of them has AltosUI’s export (its CSV) of the board’s own log of the same flight beside it. The reader follows the maker’s published description of the packets (AltOS Telemetry, Bdale Garbee and Keith Packard, v1.9.22.2, 2025, §2–4). But one unit, the pressure’s, is the exception: the files contradict it. The same packets decoded to a table are read too (AltOS’s telemetry as a table).
The board sends a 32-byte packet several times a second, each of a type: sensors, GPS fix,
satellites, configuration, calibration. A TeleDongle,
the ground station’s receiver, writes each packet it hears as a text line, TELEM and the bytes
in hexadecimal. AltosUI keeps all such lines in a .telem file (The Altus Metrum System,
§12.1). Each line holds a length byte, the packet, two bytes the radio adds, and last a checksum.
The radio’s two bytes are the signal strength (RSSI, in dBm as ) and a
link-quality byte. The link-quality byte’s top bit says whether the packet passed the radio’s CRC,
its error check. The checksum is 0x5A plus every byte after the length byte up to, not including,
the checksum, modulo 256. The document’s table places the bytes one position early. Its formula as
written fails its own example. This reading, by contrast, passes that example (a test reads the
document’s example line) and every line of both files. A line that isn’t such a
packet, or fails its checksum, refuses the file, as damage to it. A packet that failed the radio’s
CRC is noise and is left out, counted: 13.6% and 4.1% of the two files’ packets
(the survey’s report).
- The clock is the board’s tick, a hundredth of a second, which turns over every 655.36 s. Each packet’s tick goes on the turn nearest the latest so far. So a GPS packet, which carries the earlier tick of its fix, falls behind instead of a turn ahead. The clock counts from the first packet heard, not from liftoff.
- A board switched off and on starts its tick again. Each switching on is a power-on, and one
sample file holds three. The record keeps the power-on that leaves the pad, a state from
boosttomain(or the last, if none does). It counts the others’ packets in a note, and refuses a file in which two leave it. The tick alone can’t tell every case. A radio silence of 327.68 s to 655.36 s reads as a power-on. A longer silence reads as a turn shorter than it was. A power-on whose new tick lands ahead of the old one reads as a silence. - Pressure is in pascals, not the document’s tenths. That is because a launch site’s pressure in pascals is at most 12 kPa in tenths, more than 15 km (9.3 mi) up. Of the 138 sensor packets at a tick the export also holds, 123 equal its pressure. At the other 15 the export’s row repeats the row before it, counted apart. Pascals are taken only where the pad’s pressure lies from 10 to 120 kPa so read. Otherwise the field is kept as written. One file, from one firmware, has an export to hold it to.
- The board’s own estimates are acceleration, speed and height. Acceleration and speed are in sixteenths of a m/s² and of a m/s, and height is in meters above the pad. The estimates are checked against each other. The median ratio of the height’s climb to the speed after burnout is 0.966 to 1.001. The median ratio of the speed’s change to the acceleration in the climb is 0.939 to 1.021. A wrong unit would be 3.28 or 16 times off. The survey fails a file outside 0.8 to 1.25. The highest height is 0.996 of the export’s.
- The temperature, in hundredths of a °C, agrees with the export within 0.05 K, half its print step. GPS positions, in ten-millionths of a degree, agree within 0.000 06° at the 39 values compared, and altitudes within 3 m (9.8 ft). The survey fails a file past 0.01° or 100 m (328 ft). A GPS packet without its valid bit holds no fix, and its position is a gap.
- Kept as written: the converters’ counts (raw accelerometer, battery, continuity, calibration), which the document gives no conversion for, and the GPS fields nothing checks.
- States become events. They are named as AltosUI’s exports name the numbers (2 is
pad, 3boost, 4fast, 5coast, 6drogue, 7main, 8landed). The document doesn’t give these names.
Only the five packet types the sample files hold are decoded. They are the sensors and calibration of the TeleMetrum v2 and newer, the configuration, and the two GPS packets. The document lays out eleven more, for the TeleMega, the TeleMini and older boards. Its pressure unit is wrong where the files can check it. So those eleven aren’t decoded until a sample holds one. A packet of one of those types is counted in a note. The record’s primary track is the board’s height, its own estimate, which may lean on its accelerometer. It is not a conversion of the pressure alone. Every other field is a channel on its own packets’ clock. The crate’s tests read an invented file in which:
- a board is switched on twice;
- a packet fails the radio’s CRC;
- a GPS packet’s tick falls behind the sensor packet sent before it.
One of that file’s lines is a configuration packet:
TELEM 22d2040001040b0300011b0000fa0000084e3043414c4c0000312e392e32320000f4a8c1
| Bytes | Field | Value |
|---|---|---|
22 | length | 34: the packet and the radio’s two bytes |
d204 | serial number, low byte first | 1234 |
0001 | tick | 256, so 2.56 s |
04 | packet type | configuration |
0b | device type | 11 |
0300 | flight | 3 |
01 1b | configuration version | 1.27 |
0000 | apogee delay | 0 s |
fa00 | main deployment altitude | 250 m (820 ft) |
0008 | flight log’s size | 2,048 kB |
| the next 8 bytes | call sign, in ASCII | N0CALL |
| the 8 after them | firmware, in ASCII | 1.9.22 |
f4 | RSSI | −12, so −12 / 2 − 74 = −80 dBm |
a8 | link quality | top bit set, the packet passed the CRC; 40 |
c1 | checksum | 0x5A plus the 34 bytes from d2 to a8, modulo 256 |
Left out: the eleven packet types no sample holds
(evidence row G3); and the GPS fields nothing checks. The
board’s own log, which the document doesn’t describe, is read from AltosUI’s .eeprom files
(AltOS’s .eeprom).
Tables read by their headers
Teams’ own flight computers, logging scripts and spreadsheets saved as CSV write tables no maker
documents. Such a table is a header row naming the columns, then one row a sample.
hpr_flightdata::generic reads such a table by what its header states and no more. It does so
after every other layout has passed on it
(ADR-268, tables read by their headers).
The table that writes its altitude and
speed in both feet and meters agrees with itself to 4.5 × 10⁻¹³ m. The readings come from a
pressure, or from an altitude whose header says it is above the ground or above sea level.
An altitude headed only Altitude says nothing of its sensor. So it gives none
(unstated_sensor), unless a column mapping marks it as the barometer’s
(Flight-log readings).
The header is the first line within 64 that isn’t blank, a # comment or sep=. It is split
at ,, ;, a tab or |, whichever gives the most cells. One column must be the clock: a time
word such as time or t with a unit of time. A unit is read from brackets at a name’s end,
Alt AGL (ft), or from an underscored ending, acc_y__m_s2. The
API reference lists every spelling. A decimal comma
is read only where the separator isn’t a comma and no number has a point. It is read only where
some comma also stands before other than three digits (0,05). A cell in the other mark, as
1,250 among points, is a gap, never a number a thousand times too small.
What a column is. A column is kept as written, with a note saying why, when its name says one of three things:
- another quantity than its unit does (
vz_filtered_ms: a speed’s name, a time’s unit); - an error or a difference (
Alt error (m),Diff press (Pa)); - nothing at all over a length, a time or a unit that may stand for another (
gis also grams and gauss; single letters).z (m)may be a height or a distance.
A length is a GNSS, barometric (AGL or MSL) or inertial altitude where the name says which. Otherwise it is an altitude of unstated sensor and zero. A column of words whose name says a state, phase, status, event or mode gives an event at each change.
The values’ check. A column is also kept as written if any value, converted, lies outside what a flight logger can read:
| Quantity | Allowed | Why |
|---|---|---|
| pressure | 0 to 110 kPa | a little over the highest sea-level pressure on record, 108.38 kPa (Agata, 1968, WMO’s archive of weather extremes) |
| temperature | −100 °C to 150 °C | past −40 °C to 125 °C, the automotive grade 1 range (AEC-Q100) |
| length | within 150 km (93 mi) | above any hobby rocket’s flight |
| speed | within 3,000 m/s (9,843 ft/s) | more than twice Mach 3.5, the simulator’s limit |
| acceleration | within 1,000 g | a generous bound, no source |
| rate of turn | within 50,000 °/s | a generous bound, no source |
| voltage, current | within 100 V, 100 A | a generous bound, no source |
| latitude, longitude | within 90°, 180° | the globe’s |
Five sample columns failed it. Two headed in pascals read above 110 kPa on the pad. Three headed in amperes read above 100 A, milliamperes by their size. The clock’s median step must lie from 0.1 ms to 60 s, and it must step forward, or the file is refused.
A worked example. An invented table:
Time (s),Alt AGL (ft),Pressure (hPa),Velocity,Phase
0.00,0,1001.2,0,PAD
0.05,12,1000.8,45,BOOST
Time (s) is the clock. Alt AGL (ft) is an altitude (above ground, but no sensor named):
12 ft is . 1,000.8 hPa is 100,080 Pa, inside the bounds. Velocity
states no unit, so its 45 stays as written. Phase gives two events, PAD at 0 s and BOOST at
0.05 s.
A column mapping. generic::mapping returns the header’s reading as a Mapping, which
serializes to JSON. generic::read_with reads a file by a mapping, with the same checks. So a
person can state a unit the header leaves out or name the columns of a file with no header row. A
unit that doesn’t measure its column’s quantity is refused. The command line and Python read a
table by a mapping too, from a JSON file (hpr_flightdata::custom). hpr analyze --print-mapping
prints the header’s reading, and --mapping reads the table by an edited mapping
(Reading your own logger).
What is left out. These tables have no primary track: which column is a
barometric altitude above the pad isn’t stated, unless a mapping marks it. The mark is its
primary, a column mapped to altitude_above_ground, whose clock must go forward. Tables whose
clock has no unit, or that have no header row, are read by a mapping. Either their publisher
states it (below) or it is held to physics
(below). A table saved in an Excel workbook is read
the same way, once its cells are written out (Excel workbooks).
Mappings a publisher states
Some tables name their clock t, ts or time with no unit, and their columns with no unit
either. So the header reader can’t take them, and import::read refuses them. When whoever
publishes such a file states what each column holds and its unit, the survey of the sample
logs reads it by that statement. validation/log-mappings.json holds, for each file by its
id, the Mapping as generic::read_with takes it and where it is stated. To read such a file
yourself, write a Mapping the same way and pass it to generic::read_with. generic::mapping
gives one to start from, for a file whose header names its clock’s unit. Or save the mapping as a
JSON file for hpr analyze --mapping and Python (Reading your own logger)
(ADR-270, which decided it).
Six of the sample logs are teams’ flights that RocketPy, the open-source simulator, keeps in its
repository. RocketPy’s example notebook for each flight reads the file with its
FlightDataImporter. It names the columns ("ts": "time", "filtered_altitude_AGL": "altitude", "filtered_acceleration": "az") and passes units=None, which the importer’s own
documentation defines as every column in SI. That is RocketPy’s use of the file, the only
statement of its units there is, not the logging team’s own word. So each file’s clock is read in
seconds. Its altitude above the ground is read in meters, as an altitude whose sensor isn’t
stated (barometer or GPS). A vertical speed is read in m/s, and a vertical acceleration in m/s².
That acceleration is the acceleration of the rocket’s motion, not an accelerometer’s reading. It
is about 0 at rest on the pad and −9.8 m/s² (−32.2 ft/s²) in free fall. Two of the files write
that acceleration as 0 from about apogee on, and it is kept as written. A column the notebook
doesn’t map, such as a latitude, is kept as written. Each unit still goes through the values’
check above, and none of the six files’ columns fails it.
The survey refuses a mapping on a file whose header doesn’t name the mapping’s columns in order. It refuses one on a file a reader reads on its own. A mapping can’t stand in for a reader that takes the file. The survey also refuses a file of this family with none stated. A mapping is only as right as its publisher’s statement. The values’ check catches a unit far off, a pressure over 110 kPa or a length beyond 150 km (93 mi). It doesn’t catch feet read as meters. A seventh RocketPy table, a GPS log, is loaded by no notebook. Since M7.1c22 that table is read by a mapping held to physics (below). Its clock is held to the table it was logged beside.
Tables a mapping holds to physics
This section covers the 20 sample tables the survey reads by a mapping it states itself. It also
covers the options a mapping now has for files the header reader can’t take. The physical checks
below run in the survey only, on its own mappings. A mapping you write and pass to read_with is
held only by the values’ check. Each check tells a unit from the
ones it could be mistaken for. It says nothing of the logger’s accuracy.
The 20 are tables whose headers state too little, or that have none, and whose publishers state no mapping. They are:
- a university team’s flight computer and its radio telemetry;
- student avionics;
- a club’s GPS fixes;
- a payload’s text;
- small flight computers of hobbyists and teams;
- a flyer’s workbook.
The survey reads each by a column mapping in validation/log-held-mappings.json. Since no one’s
word backs those mappings, every unit a mapping states is held to the flight’s physics. A wrong
unit fails a check instead of reading as a number
(ADR-274
decided it, in its amendment for M7.1c22).
What a check tells:
- a clock’s unit from one a power of ten away;
- a height’s, a speed’s and an accelerometer’s from one a factor of 3.28 (feet for meters) or more away;
- a pressure’s in pascals from hectopascals;
- and degrees from radians.
A check doesn’t tell torr or mmHg stated as hectopascals. Read as hPa, 760 torr is 76 kPa, inside the pad’s band.
Sixteen of the tables are in the private collection. So the mapping file names their columns by
its own labels, such as pressure 1, or reads each name from the file’s header at each run. The
mapping file gives one name from a private header, a sensor’s. That header’s last name runs onto
its first row, so the file can’t give it.
What else a mapping can say. Besides each column’s quantity and unit, a
Mapping can say how the rows are written,
for files the header reader can’t take:
- A clock that turns over,
"clock_wrap": the count the clock turns over at, in the clock’s own unit. A 32-bit count of microseconds uses4294967296(2³²); it turns over every 71.6 minutes. Each value is taken modulo the turn, and each step back of more than half a turn adds one turn, so the clock runs on. One team’s board writes values 9 × 2³² too large in the upper half of each turn. Modulo the turn, the four turns in each of its files read as one clock. - Rows written as lists,
"rows": "list":[1000, 101325, True], as a program printing its lists writes them. A row without its brackets is refused on its line. A word such asTrueis text: a column of words is left out, with a note. - Stamped rows,
"rows": "stamped":2024-06-01 14:05:09.125: 1005.71, or a tuple,2024-06-01 14:05:09.125: (0.1, -0.2, 9.8). The stamp is the clock, in seconds from January 1, 1970 in the stamp’s own zone. The file doesn’t state that zone, so only differences of times mean anything. As a 64-bit float, such a time resolves to about 0.25 µs. A line with no stamp, such as=== MOTION DETECTED ===, is an event at the next row’s time. A line shaped like a stamp with no valid date and time in it, a leap second’s23:59:60among them, is refused on its line. - A column left out,
"skip": true: cells beside a table that aren’t part of it. One case is a flyer’s notes typed beside an altimeter’s table in a workbook. The column still has its entry incolumns, as every column does, and counts in a row’s width.
A mapping is JSON. This one reads a payload’s stamped text, its second cell a note left out:
{"header_line": null, "separator": ",", "decimal_comma": false, "clock": 0,
"rows": "stamped",
"columns": [
{"name": "stamp", "quantity": null, "unit": "s"},
{"name": "pressure", "quantity": "pressure", "unit": "hPa"},
{"name": "note", "quantity": null, "unit": null, "skip": true}]}
Stamped rows need the stamp’s entry first, as the clock, in s and with no turn. The clock can’t
be left out. A turn must be a number above 0. A mapping that breaks one of these is refused,
naming the rule. The API documentation runs this
example and a turning clock in rows written as lists.
The pad, apogee and liftoff, as the checks read them from the data, not the glossary’s liftoff, the first motion on the rail. The file’s height is its altitude, or the standard atmosphere’s height of its pressure, smoothed by a running median of 5 readings. Apogee is the last of the highest smoothed heights. The pad height is the lowest smoothed height in the 300 s before apogee. A rocket at Mach 3.5, about 1.2 km/s (3,900 ft/s), takes 122 s to coast to apogee against gravity alone. The 300 s window is more than twice that. The window keeps out the hours before launch. Over a whole recording, one board’s barometer read lower heights in those hours than on the pad. That put liftoff hours early (found while the checks were built). Liftoff is the last reading before apogee whose height above the pad is within 5% of the climb, apogee less the pad height.
The checks. Each row below is one kind of check. A file that fails any of them fails the survey, listed among the files left unread. The bands are the earlier increments’:
- the clock’s from M7.1c18 (a course’s Teensy logger);
- the altitude’s from M7.1c21 (altimeters’ other text);
- the accelerometer’s from M7.1c20 (FIP sheets).
The overlap, the clock rate and the track’s own speed are new checks here. The pad’s 50 kPa is the standard atmosphere’s pressure 5.6 km (18,300 ft) up, above any launch site. Here a band is the range of values a check accepts, and a fix is one position a GPS receiver reports.
| Reading | Check | Band | A unit it refuses |
|---|---|---|---|
| The clock | the time from liftoff to apogee of the file’s height, over √(2h/g) | 0.5 to 2 | a power of ten: 10 times off or more |
| The clock, with no height in the file | its span of times overlapping another file’s of the same logger, over the longer span | 0.5 or more | the same |
| The clock, on the pad with no flight | its median step over the same logger’s, in a file with a flight | 0.9 to 1.1 | the same |
| A pressure | its reading on the pad | 50 to 110 kPa | hectopascals for pascals, 100 times off |
| An altitude | its rise over the standard atmosphere’s height of the file’s pressure, another logger’s rise, or the apogee the flyer states | 0.6 to 5/3 | feet for meters, 3.28 times off |
| A vertical speed | the altitude’s change between two readings over the time between them, against the logged speed, from liftoff to apogee where the speed tops 10 m/s (33 ft/s); their median | 0.6 to 5/3 | ft/s for m/s |
| A GPS track’s altitude | how fast the track’s own vertical speed falls over the 5 s before its highest fix, in g, from a parabola fitted to those fixes (below) | 0.6 to 5/3 | feet for meters, 3.28 times off |
| An accelerometer | its median magnitude over the recording, mostly at rest on the pad or under a parachute | 0.85 to 1.15 g | g for m/s², 9.8 times off; ft/s², 3.28 |
| A latitude and a longitude | each on its own: the median size of its readings other than 0, past ±π/2 for a latitude and ±π for a longitude | radians stated as degrees, which can’t lie past them |
A worked example, with invented numbers: a table with no header logs a pressure in pascals and an altitude above the pad in feet. On the pad the pressure reads 97,000 Pa, inside 50 to 110 kPa. Had the file written 970 hPa and the mapping stated Pa, the pad would read 970 Pa, below 50 kPa, and fail. At apogee the altitude reads 3,281 ft and the pressure 85,951 Pa. The standard atmosphere puts 97,000 Pa at 366.4 m (1,202 ft) and 85,951 Pa at 1,366.4 m (4,483 ft). That is a rise of 1,000.0 m (3,281 ft), so the altitude’s 3,281 ft over that rise is 1.000. Mapped in meters, the altitude would rise 3,281 m (10,764 ft), a ratio of 3.28, and fail. The climb takes 15 s, and √(2 × 1,000 m / 9.807 m/s²) is 14.28 s, a ratio of 1.05. A clock in seconds mapped as milliseconds would give 0.001.
What is kept as written. No check here tells °C from °F at a launch’s temperatures. That is because 24 °C read as °F would be −4 °C, a launch’s temperature too. So every temperature is kept as written. So is every rate of turn. So is every other column no check holds, such as a battery’s voltage, humidity, a magnetometer and an orientation’s quaternion. One board’s accelerometer reads 0 at rest, with gravity taken out, and is kept too, as are words, packed fields and counts.
What the 20 show. Their mappings read 64 columns in a unit, keep 102 as written and leave 7 out, and all 62 checks pass. The 12 times to apogee lie 0.8627 to 1.7105 times √(2h/g). The 6 altitudes held to their pressure rise 0.9559 to 1.0005 times the rise of its standard-atmosphere height. The 3 held to another logger read 0.9008 to 0.9552 times that logger’s rise. All three are a GPS receiver’s altitude, two of them the same fixes with and without a header. The 1 held to the flyer’s stated apogee reads 1.0025 times that apogee. The 1 vertical speed gives 0.9709, and the 2 checks of a track’s own speed 0.9925 g, one track in two files. The 10 accelerometer checks read 0.9600 to 1.0531 g. The other 27 are:
- 13 pad pressures and 6 places, whose values would give a site away;
- 6 clocks beside another file’s, overlapping 0.998 to 1.000 of the longer span;
- 1 clock rate of 1.000 times its logger’s;
- and 1 cut of a file, its rows all the whole file’s.
The survey’s report,
validation/reports/log-import.md,
lists each file’s checks, each to 4 decimals.
A track’s own speed
A GPS receiver gives an altitude and a time but no speed this check could trust, and the check needs none: gravity is its ruler. In the last seconds before apogee a coasting rocket slows at g, 9.807 m/s² (32.2 ft/s²), plus a little drag. So a track’s altitudes there, fitted with a parabola, must slow at about 1 g. In a wrong unit they slow 3.28 times too fast (feet stated as meters) or too slowly (meters stated as feet). The check holds a unit within a wide band. It doesn’t measure drag, which a receiver’s noise can hide. (ADR-277, a track’s own speed decided it.)
- The fit. The check takes the track’s highest fix as apogee. It fits h = a + bτ + cτ² to the fixes in the 5 s before apogee, by least squares. The highest fix is included. τ is the time from the fixes’ mean. Then −2c is how fast the vertical speed falls, and the check divides it by g. An altitude repeated over consecutive rows, as a logger writes rows faster than its receiver updates, counts once, at its first row. So do two fixes at one altitude, which near apogee moves the top a step early. Of several equal highest altitudes that aren’t consecutive, the last is the highest.
- Enough fixes, spread enough. The check needs at least 4 fixes, one more than the parabola’s three terms. They must set its curvature c about as well as 5 fixes 1 s apart. The measure is [(XᵀX)⁻¹]_cc, the variance of c for each square meter of independent noise on a fix. It must be at most 1/12 s⁻⁴. A set of 5 fixes 1 s apart gives 1/14, and 1/12 lets them come 3.8% closer together. The reading’s standard error is then at most 0.0589 g per meter of noise. With 3 m (9.8 ft) of noise on each fix, a right unit reading 1.03 g lies 2.4 standard errors above the band’s foot. The same fixes in feet stated as meters read 3.0 standard errors past its top. Four fixes over the last 3 s, as a receiver that lost its fix on the way up leaves, give 1/4 s⁻⁴. There noise would decide, so such a track doesn’t take the check.
- Why 5 s, and the band. Drag’s vertical share is ½ρC_DA/m · v · v_z. Here ρ is the air’s
density, C_D the drag coefficient and A the frontal area. The mass is m, the speed v and its
vertical part v_z. That share falls to 0 at apogee as v_z does. Take a 54 mm (2.1 in) rocket of
1.5 kg (3.3 lb), C_D 0.5, in air of 1.1 kg/m³. Coasting straight up, it climbs at 50.8 m/s
(167 ft/s) 5 s before apogee, a little more than g × 5 s. Its drag adds 0.11 g there. Carrying
100 m/s (328 ft/s) across at apogee, its drag adds 0.33 g. Fitted to its fixes once a second,
the parabola reads 1.031 g straight up and 1.135 g carrying that speed across. The test
a_coast_with_drag_reads_inside_the_bandpins both. Leaving the band’s top takes 1.667 g. A longer window would let drag grow; a shorter one holds too few fixes once a second. Drag only adds. So a right unit reads low only by noise or a receiver’s lagging filter, which fail the check rather than pass a wrong unit. - What it assumes. A coast of at least 5 s, which a rocket has if it climbs 123 m (402 ft) or more after burnout, ½g × (5 s)². A motor still burning in the window would make the fit read anything. The club’s track climbs far past that.
- It doesn’t hold the clock. The window is read on the file’s own clock, so a misread clock changes which fixes it takes. Read 10 times too short, it would take 50 s of fixes, the pad and the boost among them. Then the fit could land anywhere. The clock checks hold every held file’s clock, so the window is the right one.
- A worked example, with invented numbers. A receiver reports once a second. Its fixes 5, 4, 3, 2 and 1 s before its highest lie ½gτ² below it. That is from 122.58 m (402.2 ft) at 5 s to 4.90 m (16.1 ft) at 1 s. The least-squares parabola through the six fixes, the highest and the five before it, has c = −4.903 m/s², so −2c is 9.807 m/s², 1.000 g. Written in feet and mapped in meters, the same fixes read 3.281 g; written in meters and mapped in feet, 0.305 g. Both fail.
- Where it runs. The check runs on the club’s GPS track (2 files, the same fixes with and without a header), which slows at 0.9925 g. That is a little under the 1 g a coast can’t go below, within the fit’s noise. Another logger’s rise holds the same altitude too. A track that the latitude-and-longitude check holds, and whose GPS altitude could take this check, must take it, or the survey fails. Of the other 3 of the 4 tracks, the radio telemetry’s receiver lost its fix on the way up. That left 1 fix in the window, the highest itself. So another logger’s rise alone holds its GPS altitude. The other 2 have no altitude.
A track’s ground speed holds no unit
The survey also measures each track’s ground speed from each fix to the next. That is the distance along the Earth’s surface between them (the great-circle distance) over the step of the track’s own clock. A fix the logger repeats over several rows counts once.
- What was measured. The 4 tracks held by a latitude-and-longitude check are 5 files, two of them the same fixes. Over them, each track’s median lies 0.3460 to 7.3836 m/s (1.1352 to 24.2244 ft/s), a spread of 21.34 times. Each track’s fastest step lies 24.8509 to 400.0430 m/s (81.5318 to 1,312.4770 ft/s), a spread of 16.10 times. The medians span the whole recording, the pad’s hours included, so a median can be a receiver’s jitter as much as the wind’s drift.
- Why no band holds a unit. A clock misread by a factor of 10 (the checks table’s power of ten) moves every speed 10 times, less than either spread. So no band on these tracks refuses that misread on every one of them. Taking the flight alone wouldn’t help. A track drifts with the wind, and a launch may go on a calm day. So its speed has no floor (NFPA 1127 limits only the surface wind, to 20 mph (8.9 m/s)). Radians stated as degrees would read 57 times slower, which a band could tell apart on these 4 tracks. But a band fitted to 4 tracks is a sample, not a bound. So a track’s degrees are held by the latitude-and-longitude row of the table, which needs no band.
Binary records by a stated layout
Some teams’ flight computers save each sample as a fixed run of bytes. One example is a 4-byte
clock in milliseconds, then 24 four-byte floats. Nothing in the file says so: no header, no names,
no marks. Such a file can’t be recognized, only read by a layout someone states. The library reads
it by the layout you give, each field’s name and type in the record’s order
(records::RecordLayout). The library
never guesses a layout. The command line and Python take the layout as a JSON file
(Reading your own logger).
A type is an integer of 8, 16, 32 or 64 bits, signed or not, or a 32-bit or 64-bit IEEE 754 float.
Binary32 and binary64 are the standard’s names for single and double precision. A type is
little-endian unless the layout’s byte_order says
ByteOrder::Big. Little-endian means the least
significant byte first, as most microcontrollers store numbers.
A layout has 2 to 512 fields: a clock and at least one more. Each name is 1 to 256 characters. No
two names are alike. No name is a number. No name holds a comma, a semicolon, |, a quotation mark
or a control character (a line break or a tab among them). No name has spaces at its ends. The
first name doesn’t open with #, sep= or a byte order mark. A layout outside these rules is
refused (LogError::Layout), naming the field and why.
The records are written out as a table: the names are its header, and each record is one row. The
header reader then reads that table. Name a field with its unit,
such as pressure__kpa or Time (ms), and it is read in that unit if its values bear it out. A
field whose name states none is kept as written. A layout whose names state no clock with a unit of
time is refused. For such a layout, records::table gives the table for reading it by a
column mapping instead
(ADR-271,
which decided it).
A 32-bit float is widened to 64 bits exactly. It is written as the shortest decimal that reads back to it. So a pressure stored as the float nearest 101.3 kPa is read as 101.30000305175781 kPa, the value the bytes hold, not as 101.3. A float that isn’t a number or is infinite becomes a gap, and a note counts them. That note is one of the record’s notes on what the reader worked around.
use hpr_flightdata::records::{Field, FieldKind, RecordLayout};
let layout = RecordLayout::new(vec![
Field::new("Time (ms)", FieldKind::U32),
Field::new("pressure__kpa", FieldKind::F32),
]);
let log = hpr_flightdata::records::read(&std::fs::read("flight.bin")?, &layout)?;
// The same records, dumped as base64 in a console capture's block named `data`:
let text = std::fs::read_to_string("capture.txt")?;
let log = hpr_flightdata::capture::read(&text, "data", &layout)?;
The module’s own example reads two invented records and is compiled and run with the library’s tests.
A logger saving to flash leaves the memory it never wrote erased, every byte 0xFF. A dump of its
memory may run on into it. Records that are wholly 0xFF at the end of the file are dropped as
that erased memory. So are erased bytes past the last whole record, and a note counts both. Any
other bytes past the last whole record are refused, as a sign the layout doesn’t fit. An erased
record with written ones after it isn’t dropped, so a logger’s fault stays visible. Its integers
read at their largest (−1 if signed), and its floats read as gaps. With a float clock, that record
has no time. The reading is refused, naming the record by its number and where it starts. With an
integer clock it is read. A u32 clock in milliseconds reads 4,294,967.295 s at that record, and
its floats are gaps. The records after it read at their own times, so the jump shows where the
logger skipped.
The same records may come as a console capture. That is what a terminal program saves when a
flight computer’s USB shell is asked to dump its memory. It holds the commands typed at the shell,
and then each dump as base64 lines (bytes written as text, 3 bytes to 4 characters). Each dump sits
between two marker lines the firmware prints,
----++++//[[( data start )]]\\++++---- and ----++++//[[( data end )]]\\++++----. Here data is
the block’s name (the sample captures’ blocks are data and params).
import::read recognizes a capture by a start marker in its first 1,000 lines. It refuses the
capture, naming its first blocks, as the capture doesn’t state its records’ layout.
capture::read reads a named block by the layout
you give, as records::read reads a file. The base64 is decoded strictly (RFC 4648’s standard
alphabet). The reader refuses each of these, naming the line:
- a character outside that alphabet;
- padding out of place or over bits that aren’t zero;
- a block that never ends;
- a marker inside a block;
- two blocks of one name.
How the survey checked it. The survey reads each file by the types
validation/log-layouts.json states for it, with its names from that table. Each type was found
from the bytes and from that same table. Then the survey
decodes every record’s fields itself from the file’s bytes, apart from the reader’s records. It
compares them with the table field by field. A wrong base64 decoding would fail that comparison
too. Each record read holds the same
channels as the team’s table read by its header. The files are private, so the layouts file holds only their types, by file id. One
capture’s last 12,222 records are erased memory, which the team’s table writes as rows of
4294967295 and nan and the reader drops. The fields of those records agree with the table
too, 1,237,425 fields in all.
What is left out. No primary track, as for any table read by its header.
hpr analyze and the Python package read these files only by the layout you state
(Reading your own logger). A record’s layout can’t be found from its
bytes alone. So a file whose layout no one states stays unread. A capture’s other blocks, such as
the saved state a params block holds, are decoded but not read.
The Blue Raven’s USB download
A Blue Raven can also send its flight data out of its USB port as text, one line a sample, which a terminal program saves. HPR Sim keeps only the lines whose own check value shows them whole. It reads their fields by the maker’s manual wherever a line holds what the manual lists.
The manual describes the download (Blue Raven User’s Guide, Featherweight, updated May 12, 2026,
Appendix A, p22–24). Typed at the logger, <download l> sends the low-rate set, recorded 50 times
a second. <download h> sends the high-rate set, 500 times a second. Each line opens with its
mnemonic, @ LOG_LOW or @ LOG_HIR, then its length, the logger’s date and time of day, a sync
code and the data. It closes with CRC: and four hexadecimal digits. The sync code is “a
millisecond counter recorded in both the low-rate and high-rate data so that the two data sets can
be aligned” (p23). It rolls over every 250 ms (p23). The CRC, a cyclic redundancy check, is a check
value worked out from the line’s text. So a line that lost or changed a character no longer
matches it. The manual names the CRC for the low-rate line (p23). The sample files’ high-rate lines
carry one of the same kind. import::read recognizes a download by a line among its first 1,000.
That line opens with either mnemonic, holds no other @ LOG_, and has a CRC that checks.
import::read reads the download with hpr_flightdata::blueraven_usb
(ADR-272, reading the Blue Raven’s USB download,
which decided it). Each set is a record of its own, as the app’s two files are.
Two invented records, one of each kind, as the crate’s tests read them, each from a file of its own:
@ LOG_HIR 139 2026 5 23 10:15:00.120 20 -15 42 -7 -1 3 98 -3000 1500 -40 29812 0 0 CRC: 7730
@ LOG_LOW 211 2026 5 23 10:15:00.140 40 Bo: 7212 49655 V: 4105 22 21 20 23 Vel: 0 0 0 Pos: 0 0 0 ang: 12 5 0 FER: 400 1c1 c3 c1 c3 0 0 0 CRC: F7EB
Each line’s two checks. A terminal saves what the port sends, and a capture can lose part of
it. In one sample file, a record whose CRC: and line end were lost runs on into the next record,
on one line. So the reader cuts every line before each @ LOG_. It keeps a piece only if two
things the logger wrote for it agree with it:
- Its CRC: CRC-16/BUYPASS, as the manual names it. The polynomial is
0x8005. The CRC starts from 0, with no reflection and no final XOR. Its value for the text123456789is0xFEE8. The CRC covers the text from@to the last character beforeCRC:, with the spaces beforeCRC:left out. The manual says the CRC is “for line of text” but not which characters it starts and ends at. This is the span under which every CRC in the sample files checks. - Its length: the number after the mnemonic is the piece’s length in bytes. The count runs from
@through the CRC’s last digit, plus 2 for the CR and LF the logger sends. The high-rate line above is 137 characters long and states139.
A piece with no CRC, or whose CRC differs from its text, is dropped. That is because it can’t be told from a
record the capture damaged. A note counts each kind. A line with no record is skipped and counted
too, such as the status line, @ BLR_STAT. The port sends that line five times a second (p22). A
piece whose CRC checks is the logger’s own. So anything else wrong with it refuses the whole file,
naming its line:
- a length that isn’t its own;
- another mnemonic;
- a date or time that can’t be one;
- a value that isn’t a whole number (or, in
FER:, hexadecimal digits); - more than 256 values;
- a layout unlike the first record’s.
So a file holding both kinds of record is refused, and so is one in which no record’s CRC checks.
The fields. After the sync code, each value is a whole number, scaled as the manual says:
| Record or group | The manual’s fields, in its order | Read as |
|---|---|---|
| high-rate record | gyro X, Y and Z in deg/s × 100; acceleration X, Y and Z in g × 100; the quaternion’s X, Y and Z terms and its magnitude term, each × 30,000 | Gyro X, Gyro Y, Gyro Z in degrees per second; Accel X, Accel Y, Accel Z in m/s², 1 g being 9.806 65 m/s²; Quaternion X, Quaternion Y, Quaternion Z, Quaternion magnitude as numbers with no unit |
Bo: | the baro sensor’s temperature; the pressure in atm × 50,000 | Bo: temperature kept as written; Bo: pressure in Pa, 1 atm being 101 325 Pa |
V: | the battery’s and the Apo, Main, 3rd and 4th outputs’ voltages, mV; the outputs’ current, mA | V: battery, V: Apo, V: Main, V: 3rd, V: 4th in V; V: current in A |
Vel: | upward, down-range and cross-range velocity, ft/s | Vel: up, Vel: down-range, Vel: cross-range in m/s |
Pos: | inertial altitude, down-range and cross-range position, ft | Pos: altitude, an inertial altitude, and Pos: down-range, Pos: cross-range, distances, in m |
ang: | tilt angle, deg × 10; roll angle, deg; future tilt angle, deg × 10 | ang: tilt, ang: roll, ang: future tilt in degrees |
FER: | the flight event register of the rocket, then of the Apo, Main, 3rd and 4th outputs, in hexadecimal | FER: rocket, FER: Apo, FER: Main, FER: 3rd, FER: 4th, each register’s value as a number |
The gyro rates are “raw data in the sensor axis”, and the velocities and positions are in
“ground-relative inertial coordinates (rather than rocket axes)” (p23–24). The accelerations come
from the ±32 g accelerometers below 32 g and from the high-range one above it. The quaternion is
four numbers the logger keeps its attitude in. It is a unit quaternion, whose four terms’ squares
sum to 1. The manual says the download writes it “with the rotation axis first and the magnitude
term fourth” (p24). The app’s high-rate CSV doesn’t. In each such file among the sample logs whose
first row holds numbers, Quat_1 is the largest term there, about 1 on the pad. So the CSV writes
the magnitude term first (checked by hand on October 15, 2026). Both keep the quaternion’s terms as
numbers, so neither order changes a value read. A flight event register is a set of bits, “one bit
for each event” (p24), such as apogee detected. The rocket’s register records the events that
affect every output. Each output’s register records its own.
Counts unlike the manual’s. A logger’s firmware need not write what the manual of the day
lists. The sample files’ firmware writes other counts. A high-rate record holds 12 values where
the manual lists 10. V: holds 5 where it lists 6. FER: holds 8 where it lists 5. One rule
takes all three:
- A group holding at least the manual’s count is read by the manual, in its order. The values past
that count are kept as written. These are the high-rate record’s 11th and 12th values, and
FER:’s 6th to 8th. TheFER:ones are registers of unknown meaning, kept as numbers. - A group holding fewer than the manual’s count is kept as written whole, as nothing says which
value is missing. So
V:’s 5 values aren’t read as voltages. - A group the manual doesn’t list is kept as written.
A value kept as written is named by its group and its place there, counted from 1, such as V: 3
or LOG_HIR 11. A note says so for each group. The maker’s forum describes two 500 Hz fields the
manual doesn’t. They are the “deployment output current” and the “aux analog voltage” (Featherweight,
Blue Raven development thread, rocketryforum.com, March 31, 2023). The forum doesn’t give their
order. So the high-rate record’s 11th and 12th values stay as written.
The clock. Each record states the logger’s date and time of day to the millisecond, such as
2026 5 23 10:15:00.120. The record’s clock counts from the first record’s, in seconds. A time
that doesn’t come after the one before refuses the file, naming its line. The date need not be the
flight’s. The manual says the date stamp “starts with the build time/date and increments from
there” (p22). That is the firmware’s build date, unless the phone app has set it (p22). So a note gives
the first record’s date and time as written, and the record claims no date for the flight. Year,
Month, Day and Sync are kept as numbers and Time as a time of day, as the app’s CSV keeps
them. The sync code is “a millisecond counter recorded in both the low-rate and high-rate data so
that the two data sets can be aligned” (p23). It also “rolls over every 250 msec” (p23). The reader
keeps the code but doesn’t join the two sets.
What is kept as written, and why.
- The baro sensor’s temperature,
Bo: temperature: the manual states no unit for it in the download, and a note says so. - The registers’ bits: the manual says the registers are “hex-encoded binary values that use one bit for each event” (p24). But it doesn’t say which bit is which event, so no event is taken from them.
- No primary track: the download writes the pressure, not an altitude. So the
record’s time and altitude are empty, as for the Raven’s
.FIPa. Every value is a channel.
A worked example, the two invented records above. In the high-rate record, 20 is the sync
code and -15 the first gyro rate, so Gyro X is −0.15 degrees per second. The sixth value, 98,
makes Accel Z 0.98 g, 9.611 m/s². The quaternion’s four terms, -3000, 1500, -40 and
29812, read as −0.1, 0.05, −0.001 33 and 0.993 73. The four whole numbers’ norm is 30,000.12,
within 2 of 30,000. A unit quaternion’s norm must be within 2 of 30,000 too, after the scaling cuts
it to whole numbers. The last two values, 0 and 0, are LOG_HIR 11 and LOG_HIR 12, kept as
written. In the low-rate record, Bo: 7212 49655 gives Bo: temperature 7,212, as written, and
Bo: pressure 49,655 / 50,000 atm, 100,626 Pa. V: holds 5 values, so they are V: 1 to
V: 5, kept as written. ang: 12 5 0 is a tilt of 1.2°, a roll of 5° and a future tilt
of 0°. FER: 400 1c1 makes FER: rocket 1,024 and FER: Apo 449. The last three registers are
FER: 6, FER: 7 and FER: 8.
How it was checked. The sample logs hold 2
downloads, a team’s high-rate and low-rate sets from one rocket’s logs. The survey,
cargo xtask logs, works out each piece’s CRC and length itself, apart from
the reader. It decodes each record that checks by its own copy of the manual’s table and rule. The
reader must keep exactly the records that check. Each of their values, the clock’s included, must
equal the survey’s:
| File | Pieces | CRC checks | Records read | Values compared | Values differing |
|---|---|---|---|---|---|
| high-rate | 17,930 | 17,930 | 17,930 | 304,810 | 0 |
| low-rate | 1,861 | 1,706 | 1,706 | 49,474 | 0 |
Every record whose CRC checks states its own length too. The low-rate file’s other 155 pieces close with no CRC, records the capture ran together, and are dropped. Three physical checks hold parts of the reading, and of the rule for counts unlike the manual’s, to the files. A file that failed one would be counted as unread. The three checks are:
- Each high-rate quaternion is read from the 7th to the 10th value. Its norm is from 29,998.25 to 30,000.00, within 2 of 30,000 as it must be.
- The low-rate pressure on the pad is the median of the first 20 records. That median is 0.9977 of the pressure a TeleMega (an Altus Metrum board) in the same rocket logged. The check allows 2% either way.
- The first register’s lowest bit is the one the app’s files call
Liftoff. It first sets 0.024 s after the three axes’ acceleration in the high-rate file first passes 3 g. The check allows 0.1 s. This holds the two files’ clocks and the register’s first value to each other. It doesn’t show a launch, as the next paragraph says.
The download records no flight. The high-rate file’s acceleration stays above 3 g for at most 0.056 s at a time. Its greatest mean over any 1 s is 1.68 g. So the bit was set by a short spike, not a boost. Over the whole low-rate file, the Blue Raven’s pressure moves by only 0.16% of its pressure on the pad. By contrast, the TeleMega’s falls to 0.773 of its own. So none of the download’s channels, the gyroscopes’ and accelerometers’ included, describes the TeleMega’s flight. Nothing in the files says why, so the reading keeps the values as written. The survey’s report prints these measures.
What is left out. The record makes no altitude from the pressure, though the readings turn it into a height by the 1976 standard atmosphere. The two sets aren’t joined by their sync code.
A course’s Teensy data logger
Harvey Mudd College’s advanced rocketry course flies a data logger the course builds around a Teensy, a small microcontroller board. The course publishes its flights’ files on its Flight Data page, which lists two kinds, “Teensy Data Logger” and “New Teensy Data Logger”. Both write one sensor’s reading a line. A line holds three things:
- the sensor’s tag, a short label such as
Afor the accelerometer orAltfor the barometer; - the logger’s clock in microseconds since it started;
- the values.
No document describes either layout. So HPR Sim reads what each file states. Where a file states
no unit, HPR Sim reads a unit only if the flight’s own physics confirms it.
ADR-274, the Teensy logger and the rest of the importers,
decided this. import::read reads both with hpr_flightdata::teensy.
The older layout separates its fields by tabs. Seven tags come round in a cycle, each line with its own time. These invented lines are from the crate’s test file, the tabs shown as two spaces:
A 2000 0.25 -0.50 9.75
G 2000 1.50 0.50 -2.00
M 2000 20.10 -3.40 17.80
Alt 3100 P 95000 MSL 540.42
HG 3600 0.4788 -0.9577 10.5337
ADC Pin-35 3700 0.0120000000
ADC Pin-36 3800 0.0150000000
A value is named by its tag and its place, A 1 to A 3. Or it is named by its tag and the name
the line gives it, Alt P and Alt MSL. No line states a unit, so three of the values are read
in SI only because physical checks confirm them:
| Values | Read as | Why |
|---|---|---|
A 1 to A 3 | acceleration, m/s², as written | their magnitude is within 3% of 1 g, 9.806 65 m/s², on the pad and after landing |
Alt P | pressure, Pa, as written | Alt MSL follows from it by the BMP180’s formula to within 0.0103 m (0.41 in), below |
Alt MSL | a pressure altitude, m, as written | it is 44,330 × (1 − (P / 101,325)^(1/5.255)), the altitude formula in the data sheet of the Bosch BMP180 barometer, on every line |
Alt MSL is a pressure altitude: the height at which the standard atmosphere’s pressure equals
the one measured, counted from where it would be 101,325 Pa. It isn’t a height above the sea. In
the line above, 95,000 Pa gives 540.4176 m (1,773.02 ft) by the formula, written as 540.42.
The rest is kept as written, as a number with no unit:
- the gyroscope
G; - the magnetometer
M, a quantity HPR Sim doesn’t hold; - the high-g accelerometer
HG; - the analog inputs.
HG moves in steps of 0.4788 if read as m/s², but it doesn’t agree with A. The comparison is
made during the boost, while A reads from 3 g to 90% of its greatest. HG reads 1.37 to 2.39
times A’s magnitude then, depending on the file. So its scale isn’t settled.
The newer layout opens with a line for each sensor that states its units, the clock’s first.
Each line after them gives a tag, t, the clock, and name-value pairs, separated by commas:
ICM data in us, milli-g, deg/s, milli-T, deg C
MS5 data in us, deg C, Pa
ICM, t, 500000500, xa, 12.20, ya, -20.50, za, 998.40, xg, 0.18, yg, -0.12, zg, 0.06, xm, 30.15, ym, 4.20, zm, -18.75, T, 24.50
MS5, t, 500001000, T, 24.10, P, 95000
The clock’s unit must be us, microseconds. The other units go to the fields by their names. A
field’s group is its name without a leading x, y or z, so xa, ya and za form one
group. The units go to the groups in the order the tag’s first line names them, or, when only one
unit is stated, to every field. In the example:
xa,yaandzaare in thousandths of a g, read as m/s².xgtozgare in degrees per second.xmtozmare stated in milli-T and kept as written. HPR Sim holds no magnetic field. The stated unit also looks wrong, as Earth’s field, 0.025 to 0.065 milli-T, is about a thousandth of the values the sample file holds. Those values fit microtesla.Tis in degrees Celsius, read as kelvins.
A value is named by its tag and its name, such as ICM za. A tag with no units line, such as the
sample file’s VOL, is kept as written. So is a tag whose units don’t fit its groups. A note says
which.
The clock. Each tag is its own set of channels, on its own clock, as each sensor is read at its own rate. In the sample files, each of the older layout’s tags has about 43 lines a second. The newer layout’s main accelerometer has about 1,000. Times are seconds from the logger’s start. The file is refused at any of these:
- a line that isn’t a tag, a clock and values;
- a tag’s line laid out unlike its first;
- a clock that doesn’t increase from the tag’s line before.
The count of microseconds runs over after 2³² µs, 71.6 minutes, so a longer recording is refused there. A file’s last line, if it ends with no line end and can’t be read, is a line the logger was writing when it stopped. That line is dropped, with a note.
How it was checked. The sample logs hold 7 files
in the older layout and 1 in the newer, a 100 s cut from a longer recording. The survey,
cargo xtask logs, decodes each file itself and compares each of the
6,188,639 values with the reader’s. None differs. Four physical checks hold the units read. A file
that failed one would be counted as unread. The four checks are:
Alt MSLagainst the BMP180’s formula, worked out fromAlt Pin 64-bit floats. On all 305,340Altlines it differs by at most 0.0054 m (0.21 in). The check allows 0.0103 m (0.41 in). That is half the hundredth of a meterMSLis written to, plus an allowance. The allowance is 44,330 × 2⁻²³ m, 5.3 mm (0.21 in), for the logger’s own rounding of the formula. On 21,540 lines the gap is more than the half step alone. It is greatest at the same pressure in every file. So the logger rounds the formula its own way, which no document gives.- The accelerometer at rest. Its magnitude on the pad, the median over the 5 s ending 1 s before liftoff, is 0.983 to 0.989 g. Over the file’s last 2 s, after landing, it is 0.997 to 1.008 g. The check allows 3% either way. Read in another unit, such as g or ft/s², it would be 3 or more times off. Over the first 2 s of the older layout’s files, minutes before launch while the logger was handled, three files read 1.034 to 1.048 g. So the pad is taken just before liftoff.
- The time to apogee. From liftoff to apogee, the time is 0.90 to 1.14 times √(2h/g). Liftoff is the accelerometer’s first reading above 3 g in the 30 s before apogee. Apogee is the highest pressure altitude. In the formula, h is the apogee’s height above the pad. The formula gives the time a coast from the pad would take with no drag. This is a coarse check, as the burn adds time and drag takes some away. So the check allows a factor of 2. A clock misread by a power of ten would still be 10 or more times off.
- The pad pressure of the newer layout, the median on the pad, is between 50 and 110 kPa, as any launch site’s is. The report says so without the value, which would give the site’s elevation.
Each check also needs the reader to have read the values it holds as the quantities it takes them in. So a unit the reader got wrong fails the check.
The newer layout’s other stated units rest on the file’s statement. Its high-g accelerometer, read in its stated g, is 0.996 times its main one during the boost. That agrees with the unit stated. The report prints this as a measure, not a check.
What is left out. There is no primary track, as neither layout writes an altitude above the pad; the readings take the pressure instead.
One team’s radio telemetry packets
A university team’s flight computer writes each reading as a packet, a line framed by 255 and
254. It sends the packets down by radio. For one flight the team published four files of them. Two
of them are the flight computer’s own log and the text a ground receiver wrote of what it heard. The
other two are exports of the log, cut to the flight. Each export was saved as an RTF document (a
word processor’s format) and then as CSV by a spreadsheet. No document describes the packets, so HPR
Sim reads what the files show. It holds the reading to the flight computer’s own log
(ADR-274, the Teensy logger and the rest of the importers,
which decided it). import::read reads all three forms with hpr_flightdata::packets.
The readings, such as the apogee, come from the pressure. It is turned into a height by the 1976 standard atmosphere (Flight-log readings).
A packet separates its fields by colons, or by commas in the exports. These invented lines are from the crate’s test files:
255:T:11:PP:100150:950.12:21.50:3.25:254
255:T:11:AA:100152:9.70:0.40:-0.80:254
255:N:88:GG:100200:1.00:2.00:1234.56:9876.54:8.00:250.00:90.00:0.50:254
| Field | What it is |
|---|---|
255 | the packet’s start |
T | the path it came by: T from the flight computer, N relayed by a second transmitter, which also sends the GPS packets |
11 | the flight computer’s stage of the flight, 00 to 55 in the samples, or 88 on a GPS packet |
PP | the packet’s kind, two capital letters: the samples have PP, AA, CC and GG (GPS) |
100150 | the clock, in milliseconds: the flight computer’s, or on stage 88 the relaying transmitter’s own |
| the values | numbers, as many as the kind’s first packet holds |
254 | the packet’s end |
The path, the stages and the GPS packets are read from the files, not from a document. No document
confirms what they mean. What AA and CC measure isn’t known.
Each kind becomes a set of channels on its own clock. They are named by the kind and the value’s
place, such as PP 1. The stage is a channel of its own, PP stage. The GPS packets (stage 88)
carry the relaying transmitter’s own clock, not the flight computer’s, ahead of it by an offset
nothing states. So their times are left empty (gaps, with no place on the record’s time axis). Their
clock is kept as written in a channel of its own, GG clock. A Stage Two line, as the onboard log
writes when the stage changes, becomes an event at the next packet’s time. The word must be a
number’s, One to Nine. A mark the radio garbled is a broken line. One heard again is dropped.
| Values | Read as | Held to |
|---|---|---|
| the clock | seconds, from milliseconds | the time from liftoff to apogee, against √(2h/g) (below) |
PP 1 | a pressure, Pa, from hectopascals | the pad’s pressure, between 500 and 1,100 hPa, and the time to apogee, which takes the height from it |
| the rest | kept as written | nothing settles a unit |
PP 3 climbs with the flight. But where it reads above 200, it is 1.11 to 1.24 times the height the
standard atmosphere gives the pressure, in meters. So neither meters nor feet fits it, and it is
kept as written.
Lines that aren’t packets. The radio loses bytes, so the receiver’s text holds many broken
lines. A broken line is a packet cut short, or run into the next. A broken line is dropped, and a
note counts them. A packet heard again is dropped too: it has the same stage, kind, clock
and values as one already read, by either path. The rule is there because the receiver heard many
packets twice. The onboard log opens with a whole number and its filter’s gains, Gain[0]: …, which
a note counts.
The exports are RTF documents whose lines a spreadsheet split at the colons and saved as CSV. So
each line has commas after it. For the same reason, the document’s markup sits in the first cells,
and a \ ends a line where the document broke it. The reader takes each line on its own. It drops the commas, the markup
before a packet, a \ at the end and the } that closes the document. A line of markup alone is
dropped.
A file is refused if it has any of these:
- no whole packet;
- more than 32 kinds;
- a packet with more than 32 values;
- a clock of 2³² ms, 49.7 days, or more.
How it was checked. The sample logs hold the four
files of one flight. The survey, cargo xtask logs, decodes each file itself
and compares every value with the reader’s. None differs. It then looks up each packet of the
receiver’s text and of the exports in the onboard log, by its stage, kind and clock:
| File | Form | Whole packets | Packets held by the onboard log | Packets differing | Not held: GPS | Not held: other packets | Repeated packets | Broken lines |
|---|---|---|---|---|---|---|---|---|
| the receiver’s text | received | 42,796 | 38,475 | 0 | 4,321 | 0 | 8,368 | 10,495 |
| the export of all three kinds | RTF | 4,939 | 4,939 | 0 | 0 | 0 | 2 | 0 |
| the export of mostly pressures | RTF | 2,469 | 2,469 | 0 | 0 | 0 | 1 | 1 |
Of the receiver’s 38,475 packets the onboard log holds, 29,914 were relayed and 8,561 direct.
The onboard log itself holds 264,462 whole packets and no broken line. Of these, 2 are repeated. Counts include repeats. Repeated counts the packets a reading drops as heard before, by either path. The survey compares 1,315,788 values with the reader’s in all four files, and none differs. The GPS packets are the second transmitter’s fixes. The onboard log doesn’t record them.
Two physical checks hold the units read, on the onboard log:
- The pad pressure is the median of
PP 1over the 5 s ending 1 s before liftoff. It is between 500 and 1,100 hPa, as any launch site’s is. The report says so without the value, which would give the site’s elevation. - The time to apogee. Liftoff is the first packet, after the pad’s stage
00, whose pressure is more than 1 hPa below the median. The median is of the 5 s ending 1 s before that packet. Apogee is the lowest pressure. From liftoff to apogee, the time is 1.055 times √(2h/g), where h is the height the standard atmosphere gives the two pressures. The check allows a factor of 2. A clock misread by a power of ten would be 10 or more times off.
What is left out. There is no primary track, as no packet writes an altitude
above the pad in a unit that is settled. The GPS packets’ values are kept as written. hpr analyze
and the Python package read these files as the library does. Each reading is given within its bound
or withheld for the reason the command prints (Flight-log readings).
A FIP export pasted below no header
Two sample workbooks hold a Featherweight Raven’s FIP export. That is the CSV the Featherweight
Interface Program (FIP) writes. It is pasted into a sheet with its header line missing. Beside each
export is the .FIPa of the same flight, the Raven’s raw download. Each row is
the FIP CSV’s. For each of 16 channels it has a clock, a value and a b status cell (the bILBA
column, kept as a number). Where a channel stops, its two cells are empty
and every channel after it sits one cell to the left. Without the header nothing names the columns,
so the caller states it. hpr_flightdata::raven::read_rows reads the rows under the header line it
is given. read_rows_around reads a sheet another table was pasted over. The decision record,
ADR-274, the Teensy logger and the rest of the importers,
decided both readers. It did so in its amendment for M7.1c20, workbooks with a reading
beside. import::read doesn’t read such a workbook on its
own. custom::read_by_fip_header reads such a workbook under a header stated in a JSON file. The
file holds the header line and the pasted columns. The function reads from a workbook’s sheet or
from the rows as text. hpr analyze --fip-header FILE and Python’s
FlightLog.read(path, fip_header=...) take that file (Reading your own
logger).
The bracketed channels. The two barometric altitudes are held to the sheet’s own pressure and to each other. The two velocities are held to each other where a sheet keeps them. These checks back the names the stated header gives them.
The stated header is in validation/log-headers.json, by the file’s id:
Time@Axial Accel (Gs),Axial Accel (Gs),bILBA,Time@Baro (Atm),Baro (Atm),bILBA,…,
Time@[Velocity (Accel-MPH)],[Velocity (Accel-MPH)],bILBA
The rows are read as the FIP CSV’s are, but for one thing a sheet does. It writes every row as wide
as its widest, so a row may end in empty cells. A first row that reads as a header, its first cell
beginning with Time, is refused. The file has its own header, and raven::read reads it whole.
A table pasted over. In one sample sheet, columns 34 and 35 hold a clock and a value pasted over
the export’s cells. The header puts [Altitude (Accel-Ft)] in those columns. As the export’s rows
shift left where channels stop, the two columns cover different channels’ cells in different rows.
Given the pasted columns, a channel whose sample, in any row, has a cell in them is left out whole.
A note names it and counts the rows. Every other channel is read. To walk a row, each channel must
still show whether it has a sample there. One sign is a cell of its time or value outside the pasted
columns that isn’t empty. Failing that, the sign is the cell after the pasted columns. That cell
must be a sample’s status cell, b and digits, or, for a stopped channel, the next channel’s time.
A row is refused if its pasted cells hide that: the cell after the pasted columns is pasted over or
empty too.
In that sheet the rule leaves out [Altitude (Accel-Ft)] (covered in 1,259 rows),
[Velocity (Accel-Ft/Sec)] (11,331) and [Velocity (Accel-MPH)] (23,921). It reads the other 13
channels. The 11 the .FIPa also holds always sit in a row’s first 33 cells, so no pasted cell
touches them.
How it was checked. The survey,
cargo xtask logs, compares each sheet’s reading with the .FIPa beside it.
It compares the FIP’s own exports with theirs the same way (checked against the makers’
exports). Each sample is compared at the .FIPa’s time as the
FIP prints it. Each value is compared within half a step of the .FIPa’s resolution.
| Sheet | Channels read | Samples compared | Samples differing | Worst time, s | Worst value, steps |
|---|---|---|---|---|---|
| the first | 16 | 40,841 | 0 | 0.00005 | 0 |
| the second | 13 | 48,290 | 0 | 0.00005 | 0 |
Every channel of the .FIPa whose quantity is known has a channel of the sheet to compare with. An
export stops the velocity from the accelerometer early, so the .FIPa’s 850 and 811 samples after
each sheet stops it aren’t compared. An independent reader, openpyxl 3.1.5
(validation/oracles/xlsx/cells.py), reads every cell of both sheets as the workbook reader writes
it.
The derived channels, in each sheet:
[Altitude (Baro-Ft-ASL)]is the standard atmosphere’s height of the sheet’s ownBaro (Atm), less one offset. The height is 44,330.77 × (1 − (P / 101,325)^0.190263) m, with P in pascals, the atmospheres times 101,325. The match is within the pressure’s printed half step, 0.000005 atm, times the formula’s slope, and the altitude’s own. Half the spread is under 0.004 m (0.013 ft) and 0.020 m (0.066 ft).[Altitude (Baro-Ft-AGL)]is that less one constant, the pad’s. It is within both printed half steps (half the spread under 0.0016 m (0.0053 ft) in each). Its first sample, on the pad, is within 3 m (9.8 ft) of 0: 0.20 m (0.65 ft) and 0.72 m (2.4 ft). Were the two altitudes’ names swapped, the pad would read its height in the standard atmosphere. That is more than 3 m (9.8 ft) except where the pad’s pressure is within about 36 Pa (0.005 psi) of 101,325 Pa.[Velocity (Accel-MPH)]is[Velocity (Accel-Ft/Sec)], both in m/s, within both printed half steps, in the first sheet. The second sheet has neither.
A test on invented rows (a_sheet_with_its_altitudes_swapped_fails_its_pad_check, in
xtask/src/logs.rs) reads a sheet both ways round. Swapped, the two altitudes still pass the ASL
and AGL checks, each one offset from the other. The pad check fails, with the pad 540 m (1,770 ft)
up in the standard atmosphere.
The AltiMAX’s Excel export
Rocketronics’ AltiMAX altimeters are downloaded with the maker’s PC software. It can export a flight
“to Excel as altitude values” (AltiMAX G4 Manual, Rocketronics, 2021, p. 52). The sample export is
an .xls file, the binary format of Excel before 2007. It is an unusual one: a bare worksheet
stream, its records end to end. It is not inside the container file (an OLE2 compound document)
that Excel wraps its own .xls files in. hpr_flightdata::xls::read writes the worksheet out as
text. The text is then read, here with hpr_flightdata::altimax. The decision record,
ADR-274, the Teensy logger and the rest of the importers,
decided this. It did so in its amendment for M7.1c20.
import::read refuses the .xls bytes and names xls::read. import::read_one reads its one
sheet. So do hpr analyze and Python’s FlightLog.read with no option. --sheet 0 (sheet=0)
names it.
The stream. An .xls file is written in BIFF, Excel’s Binary Interchange File Format. Its
versions run from BIFF2, Excel 2.x’s, to BIFF8, Excel 97’s and later. A record is a 2-byte id, a
2-byte length and its data. OpenOffice.org’s Documentation of the Microsoft Excel File Format
(Daniel Rentz, revision 1.42, 2008, §2.1) describes it. The sample opens with a BOF (beginning of
file) record, the stream’s start, with the id 0x0809 that BIFF5 to BIFF8 share. Excel writes that
BOF’s body as 8 bytes, version 0x0500, or 16, version 0x0600 (§5.8.1). This one is 6 bytes with
a version field of 0, the kind other tools write. Rentz reads that kind as BIFF5 (§5.8.2). Its cells
settle it. They are BIFF2’s records, INTEGER (0x0002), NUMBER (0x0003) and LABEL
(0x0004), the text in single bytes. And xlrd, below, reads the file as BIFF2 too. The plan called
the stream BIFF8’s, from its BOF’s id. The plan for the rest of the importers, in
ADR-274’s amendment,
records what the stream holds. The stream ends with an EOF (end of file) record. The reader writes these
cells out under whichever BOF opens the stream. The reader refuses these:
- a later version’s cell records, by name: a shared string or a formula, as it doesn’t read them;
- a record longer than 8,224 bytes;
- a cell past column
IV, the 256th, or out of order; - text beyond ASCII;
- a stream with a second BOF or with bytes after its
EOF.
A number is written as its shortest form that reads back to the same double, so no digit is lost or invented.
The table has one header row and a row for each sample:
TIME,PRESS FILTER [hpa],HEIGHT FILTER [m],PRESS RAW [hpa],HEIGHT RAW [m],ACCEL [m/s2],
SPEED [m/s],EVENT,EVENT,VOLT. CHANNEL,VOLTAGE [V]
| Column | Read as | Held to |
|---|---|---|
TIME | s, though it names no unit | its shortest step, 5 ms within 10 %, the 200 samples a second the manual gives (pp. 8 and 10); and the time to apogee |
PRESS FILTER [hpa], PRESS RAW [hpa] | Pa: the values are pascals, not the hectopascals stated | the pad’s pressure, 50 to 110 kPa; and the heights |
HEIGHT FILTER [m], HEIGHT RAW [m] | m above the pad, the raw one the record’s primary track | the formula below |
ACCEL [m/s2] | m/s², its sign as written | 1 g before liftoff, within 15 % |
SPEED [m/s] | m/s, its sign as written | its change against ACCEL |
EVENT, a code and its name | the record’s events, where the code isn’t 0 | nothing |
VOLT. CHANNEL, VOLTAGE [V] | a voltage channel for each channel number, 1 to 5 | nothing: kept as stated |
The reader decides the pressure’s unit by its first value, on the pad. Read in hectopascals as stated, it would put the pad above 50,000 hPa. Read in pascals, it falls between 500 and 1,100 hPa, as any launch site’s does. The two ranges don’t overlap, so only one reading fits. A note says so when it is pascals. A file whose pad fits neither is refused. The reader also refuses:
- a header that names a column twice (but
EVENT), or more than 256 columns (the AltiMAX export has 11); - a file of one row, whose clock has no step to check;
- a value that isn’t a finite number or is too large for pascals;
- more than 16 voltage channel numbers.
ACCEL is measured along an axis pointing down the rocket. It reads −0.94 g at rest before liftoff,
where an axis pointing up would read +1 g. SPEED is ACCEL summed over the clock, gravity left
in. So SPEED isn’t the rocket’s speed, and the record’s vertical speed is left empty.
How it was checked. The survey decodes the stream
itself, apart from the reader. The stream’s records are 50,668 INTEGER, 202,672 NUMBER and 25,345 LABEL
cells, a BOF, an EOF, a DIMENSIONS, 11 column widths and 36 number formats. All 278,685 cells
equal the reader’s text. And xlrd 2.0.2 (validation/oracles/xls/cells.py), which reads the file as
BIFF2, agrees on every one. The 253,340 values of the reader’s channels equal the text read by the
stated units, but the pressures in pascals. Then, on the flight:
- The heights. Each of the 50,668 heights, filtered and raw, matches the standard atmosphere’s height of its pressure in pascals, less one offset for the file. That height is 44,330.77 × (1 − (P / 101,325)^0.190263) m (U.S. Standard Atmosphere, 1976). The match is to within 0.0045 m (0.015 ft). The check allows 44,330.77 × 2⁻²³ = 0.0053 m (0.017 ft) for the software’s own working of the formula. No document gives the form of that working. The offset is the pad’s height in that atmosphere. It isn’t written, as it gives the site’s elevation. Read in hectopascals, the heights would miss by more than a kilometer (0.6 mi).
- The pad pressure, the first raw pressure, is between 50 and 110 kPa (7.3 and 16 psi).
- The accelerometer. Liftoff is
ACCEL’s first magnitude above 3 g. Before it,ACCELreads 0.940 g. The check allows 0.85 to 1.15. A column in g or ft/s², read as m/s², would be 9.8 or 3.3 times off. Over the boost,SPEED’s change is 0.999 timesACCEL, inside 0.9 to 1.1. - The time to apogee. From liftoff to the highest raw height, the time is 0.945 times √(2h/g), h the apogee’s height above the first sample’s. The check allows a factor of 2.
What is left out. The voltages aren’t held to anything. The software lists five (the battery’s,
the igniter’s and three pyro channels’, AltiMAX G4 Manual, p. 42) but not which number is which.
So none is named. The event codes aren’t documented, so they are kept as written beside their names.
The AltiMAX’s own .ALS file of the same flight is read too. It is held to this export (the
AltiMAX’s .ALS).
A MARSA download
MARSA Systems’ MARSA4 and MARSA54 flight computers share their firmware and their PC software,
MARSA_Connect. It downloads a flight and saves it to a .dat file (MARSA54L Flight Computer User
Manual, V1.4, 2014, p. 18). No document describes the file, so the reader takes its layout from the
two sample files. The survey holds each unit to a check against another logger in the same rocket.
The file is the altimeter’s settings, one a line, then a row a sample. An invented download, cut
short:
<BARO_ZERO 0> 790
<ACCEL_ZERO 0> 498
<FIRMWARE VER> 26
<MARSA VERSION> 2
<CHAN 1>
<CHAN APOGEE OPTION> 1
-0.1,-58.1,-0.08
0.0,-58.1,8.20
0.1,-29.0,8.65
The settings are the record’s figures. Each is named as the file names it, after its section’s
heading where it has one. For example, <CHAN APOGEE OPTION> 1 under <CHAN 1> is the figure
CHAN 1, CHAN APOGEE OPTION, 1. No document gives their units, so each is kept as written, and as a
number where it is one. The MARSA4 manual names two. BARO_ZERO and ACCEL_ZERO are “the A/D
values of the ground barometric and sensor readings” (MARSA4 User Manual, Version 1.0, 2009, p.
17). FIRMWARE VER is the record’s firmware.
The samples are three numbers that no line names. They are read as:
- the time in seconds from liftoff, negative before it;
- the barometric altitude in feet, as the manuals give it (the MARSA54L’s display reads “898 ft” in its example, p. 12);
- the acceleration in g, its reading at rest taken out, so about 0 on the pad.
The example’s last row reads 0.1 s, −29.0 ft (−29.0 × 0.3048 = −8.84 m) and 8.65 g (8.65 × 9.806 65 = 84.8 m/s²). The altitude is the record’s primary track. It is a height above the logger’s own zero, which isn’t its reading on the pad. In both sample files the pad reads three counts below that zero, −87 ft (−27 m). The altitude moves by its barometer’s count, about 29 ft (9 m) near the pad. It does not move by the tenth of a foot it is written in. The acceleration is along the altimeter’s axis, so it is the rocket’s own only while the rocket points straight up. AltOS’s acceleration has the same limit.
A spreadsheet’s re-save of the file, each setting’s line ending in two empty cells and the
numbers rewritten (-87 for -87.0), reads the same.
How the units were checked. Each sample file sits in its flight’s folder in the private collection beside an AltOS board’s export. The folder’s other log is the other stage’s, so the board flew in the MARSA’s stage. The survey reads both and holds the MARSA’s units to them:
- The feet. The highest altitude, read in feet, is 0.981 and 0.986 times the AltOS board’s highest height above its pad. The check allows 0.95 to 1.05, the plan’s 5 % (ADR-274, the rest of the importers’ plan). Read in meters, the altitude would be 3.2 times the board’s. That checks the unit, not the MARSA’s accuracy.
- The g. Liftoff is the first acceleration above 3 g. Over the first 2 s after it, the
barometric climb is 0.915 and 1.035 times the acceleration integrated twice from rest. The check
allows 0.6 to 5/3, the band of the
.eepromreader’s climb check. The band is wide so that only a wrong unit fails it. Read in m/s², the climb would be 9.0 and 10.1 times the integrated acceleration. - The g at rest. Before liftoff the acceleration’s median is −0.12 g in both files. The check holds it within 0.5 g of 0, nearer 0 than the 1 g an accelerometer with gravity left in would read.
- The decoding. All 5,712 comparisons of the reader’s record with the survey’s own decoding of the files agree. Each sample gives six: its time and altitude on the primary track, and the times and values of its altitude and acceleration channels. The figures are the settings, by name and value.
What is left out. The settings other than the two zeros aren’t described anywhere, so none is read as a quantity. No line of the file is an event, so the record has none.
AltOS’s telemetry as a table
This is a table of AltOS’s radio telemetry, one packet a row under a header of the packet’s fields.
The packets are the ones an AltOS .telem file logs, decoded. The table is read
from one sample file and the maker’s description of the packets. Only the TeleMega’s 0x09 packet
is read, one board and one packet type to a table. An
Altus Metrum board’s radio packet opens with its serial number, its clock in ticks of 10 ms and the
packet’s type. The type lays out the rest (AltOS Telemetry, Bdale Garbee and Keith Packard,
v1.9.22.2, 2025, §2.1, p. 2). The sample file holds a TeleMega’s type 0x09 packets, “TeleMega
Kalman and Voltage Data for 15V boards” (§2.3, Table 6). An invented row:
serial,tick,ptype,state,v_batt,v_pyro,sense,v_apogee,v_main,ground_pres,ground_accel,accel_plus_g,accel_minus_g,acceleration,speed,height,crc
1234,402.94,9,3,4.1,4.19,0.00 0.00 0.00 4.20,4.2,4.14,98500,-28,-29,10,62.25,27.375,6,TRUE
The reader recognizes the header’s opening, serial,tick,ptype,. It reads each column by its name:
tickis the clock in seconds;heightis the board’s estimate of its height above the pad, m, and the primary track;accelerationandspeedare its estimates along its axis, m/s² and m/s (the packet carries sixteenths, and the table writes them divided out);ground_presis the barometer on the ground, Pa;v_batt,v_pyro,v_apogee,v_mainand each number ofsense, one a pyro channel, are in volts.
The row reads 402.94 s, 6 m (20 ft), 62.25 m/s² and 27.375 m/s (89.81 ft/s). The voltages are volts,
not the packet’s counts. The example’s 4.1 V is a single lithium-polymer cell’s, the battery a
TeleMega takes (The Altus Metrum System, v1.9.22.2, §3.2, p. 6). Each change of state is an
event, named as AltosUI’s exports name the number, 3 boost here.
A row whose crc is FALSE, a packet that failed its check, is left out and counted. A row of
another board or packet type, or a tick no later than the one before, refuses the file at its line.
That is because the tick turns over every 655.36 s. A table of seconds can’t tell a turn from a
board switched off and on.
How it was checked. In the sample file, all 325 rows are type 9 and pass their CRC.
- The decoding. All 12,025 comparisons of the reader’s record with the survey’s own decoding agree. They cover each value and its time in the channels, and each time on the primary track.
- The units. From boost to coast, the median over pairs of rows of the height’s change over their time is 1.019 times their mean speed. For the speed’s change over their time, the median is 0.929 times their mean acceleration. Each check allows 0.6 to 5/3. A speed or an acceleration left in the packet’s sixteenths would miss it. So would a height in feet or a tick in its 10 ms counts. The battery reads 4.09 to 4.10 V. That is within the 2.5 to 5 V that the check allows. The other voltages are read as volts and held to nothing. The first ground pressure lies between 50 and 110 kPa (7.3 and 16 psi).
- The resolution. Every acceleration and speed is a whole number of sixteenths. Every height is a whole meter and every tick a whole hundredth of a second. The packet carries them that way. This is a measure, as a wrong unit could keep them too. On the pad the acceleration’s median is −0.44 m/s², about 0.
AltOS’s CSV after a spreadsheet
Two sample files read as AltOS exports that went through a spreadsheet, and AltOS’s CSV reader reads both. Each case below rests on one sample file and on invented ones in the library’s tests (evidence row G6).
A table cut from an export holds AltOS’s columns alone. Its header has AltOS’s own names with no
#version,serial,flight before them, such as
time,state,state_name,acceleration,pressure,altitude,height,speed. Names alone don’t show the file
is AltOS’s, so its states must. AltosUI’s exports write each row’s state as a number and a name. The
pairs are 2 pad, 3 boost, 4 fast, 5 coast, 6 drogue, 7 main and 8 landed. Of the
file’s first 100 rows, at least one must give one of these pairs. None of those rows may contradict them, such as
3 named pad. A row further on that contradicts them refuses the file at its line. A full export,
whose header shows it is AltOS’s, is held less strictly. A contradicting pair is counted in a note
and its name kept as written, as Debrief’s sample export numbers pad 1. In the sample file, all
1,005 rows give AltOS’s pairs. All 15,948 comparisons of the reader’s record with the survey’s own
decoding agree. They cover each value and its time in the channels, and the primary track’s times
and heights. Those keep the first row at each time AltOS repeats. The record’s events are also
AltOS’s names. The file’s altitude less its height lies within 0.005 m (0.016 ft) of one offset, the
pad’s altitude. The check allows 0.01 m (0.033 ft), the two columns’ centimeter. Its altitude’s
rise from the first row to its highest is 1.000 times the standard atmosphere’s height’s rise of its
pressure. The check allows 0.6 to 5/3. An altitude in feet would give 3.3. And, a measure, its
altitude is that height of its pressure to within 0.006 m (0.020 ft).
An export a spreadsheet re-saved can carry three changes:
- A unit after a name, such as
height (m). The column is read by its name. The unit may be the one the reader reads that column in, such asmfor an altitude orm/s^2for the acceleration. Then the column reads as AltOS’s. Any other unit, such asaltitude (ft), keeps the column as written, as the reader can’t tell how its values were made. So doespressure (Pa)over values that read as hectopascals. A unit aftertimeother thansrefuses the file, as the clock can’t be placed. - Formulas, such as
=3.28084*J2, in place of values. The reader doesn’t work them out. A column of formulas alone isn’t a channel. A column with some has those cells as gaps. Either way the formulas are kept as text in a note, run by run. Each reference to the cell’s own row is written{row}. For example,=3.28084*J2on line 2 and=3.28084*J3on line 3 are one run,`=3.28084*J{row}` on lines 2–3. Each cell the note gives can be rebuilt from it, as a spreadsheet’s CSV writes its row n on line n. A note gives up to 8 runs a column and 200 characters a formula. Up to 64 columns are noted. Past those limits the notes count the cells they leave out. - A deleted
height. With noheight, the record has no primary track, only its channels.
The sample file has all three: 26,916 rows, three columns of formulas only and height deleted.
Each of its 80,748 formulas, rebuilt from the reader’s notes, equals the file’s cell, so none was
cut. All 4,198,896 comparisons of the reader’s channels with the survey’s own decoding agree, each
value and its time.
Formats that need samples
Three of the formats the roadmap names have no sample among the logs the survey reads (evidence row G9). GPX’s layout is published and another program reads it. So its reader was built from the schemas and checked on invented files against that program (GPX) (evidence row G1). For the other two, CATS’s and “Juno”, no reader can be built and checked yet. That is because a reader is built from samples, the bytes a logger wrote. It is best built with the maker’s own export of the same flight beside them. The table says what was found for each of the two, and what a reader would need. The search, of makers’ pages and public repositories, is in a research note, read on October 16, 2026. A sample of a format in the table below can be offered in its issue, #662, with the terms it may be tested on.
| Format | Samples found | What a reader needs |
|---|---|---|
CATS Vega .cfl, the flight computer’s own log | none among the survey’s; 11 public logs from the EuRoC 2023 competition in CATS’s own repository, under the GPL-3.0, and 13 in its gallery, licensed to CATS alone | samples on terms that let their bytes be tested, and a layout: only CATS’s GPL source code publishes one, and this project doesn’t read GPL code, so a reader would be checked against the CSV the CATS Configurator exports, the program run as an outside tool; offer one in #662 |
| CATS ground station’s CSV | none among the survey’s; 22 public files beside those logs, under the GPL-3.0 | samples on terms that let them be tested; its header states each unit, such as altitude[m] and ts[deciseconds], so the table reader may take it, untried; offer one in #662 |
| “Juno” | no logger of that name found: an earlier roadmap’s “EuRoC/Juno CSV layouts” meant a rocket, Projeto Jupiter’s Juno III, whose files RocketPy’s repository holds | a sample from a logger named Juno, if one exists; none was found. The rocket’s own files would need no new reader: its altimeter’s table has an RRC3 export’s columns, which the RRC3’s reader reads, though it isn’t run on them here, as RocketPy’s data isn’t among the survey’s samples; its GNSS receiver’s table and its team’s telemetry state no unit, so they read only by a column mapping someone states, and none is stated; offer one in #662 |
The roadmap names no others, but makers HPR Sim reads also write formats no sample holds. AltOS’s
.eeprom log formats other than 1, 6, 7, 14, 15, 16 and 22 are refused, naming the format (AltOS’s
.eeprom). Public files in formats 5, 9 and 19 exist, but none with terms that let
it be tested (evidence row G4; offer one in
#657). The others with no sample HPR
Sim can test are these (evidence row G9; offer one in
#662):
- Entacore AIM USB’s
.aimfiles; - the Eggtimer Quasar’s and ION’s CSV;
- the Featherweight Blue Jay’s;
- a MicroPeak’s memory;
- Jolly Logic’s AltimeterThree export;
- the EasyTimer V2’s, TeleMini’s and EasyMotor’s logs.
The record
Every reader fills the same record, FlightLog, in SI units:
- What the file says about itself: the logger’s name, serial number, firmware and flight
number where the file states them. The record also holds the figures the logger worked out
itself, such as its apogee. These are kept beside HPR Sim’s readings and never in place of them.
A file that states many such figures, as a Featherweight summary
does, keeps each one in the record’s
stated.figures. Each keeps its name and value as written. - The primary track: the barometric altitude above the pad (AGL, above ground level) on the
logger’s clock. The track also holds the barometer’s vertical speed, the temperature and the
battery voltage where they share that clock. The
readings take the track first. Where it is empty,
they take a pressure or an altitude channel. A log with no barometer, such as a
GPS log, has an empty primary track. So does a raw download,
whose barometer’s readings are pressures, not altitudes. So does an
AltOS export a spreadsheet re-saved with its
heightdeleted. A summary has no samples at all, so its clock and tracks are empty. - Every column, as a channel: each data column of the file, in the file’s order. Each channel carries the name the file gives it, what it measures, and its own clock. Nothing the logger wrote is dropped. A column HPR Sim can’t name a quantity for is kept as written and marked unrecognized.
- Events: what the logger says happened and when, such as AltOS’s change from
boosttocoast. - Notes: what the reader noticed and worked around.
A channel’s unit follows from what it measures:
| Quantity | Unit | Examples |
|---|---|---|
| altitude above the pad (AGL), above sea level (ASL or MSL), from GNSS (satellite navigation, such as GPS), or integrated from the accelerometer | m | height, [Altitude (Baro-Ft-AGL)] |
| pressure | Pa | pressure, Baro (Atm) |
| speed | m/s | speed, Velocity (Accel-Ft/Sec) |
| acceleration | m/s² | acceleration, Axial Accel (Gs) |
| temperature | K | temperature, Temperature (F) |
| voltage, current | V, A | battery_voltage, Current Draw (A) |
| latitude, longitude, an angle | degrees | latitude, pad_az (the bearing from the pad) |
| a rate of turn | degrees per second | Gyro_X |
| a time of day on the logger’s clock | s after its midnight, in no stated time zone | a Blue Raven’s Time |
| distance | m | pad_dist (the distance from the pad) |
| a number with no unit | none | a count of satellites, a signal strength, a state code |
A foot is 0.3048 m (1.000 ft), a g 9.806 65 m/s² and an atmosphere 101 325 Pa, each exactly. A
cell the file leaves empty, or fills with something that isn’t a number, is a gap. A gap is NaN
(“not a number”) in the record, and null in its JSON, which reads back as a gap. A channel’s time
is a gap in the same way where the file gives a sample no time, as a KML path without times does.
A cell can be a valid number and still overflow when it is converted to SI. 1.7e308 read as g
becomes 1.7e308 × 9.806 65. That is more than the largest value a 64-bit floating-point number
holds, about 1.8e308. The reader then refuses the whole file and names the line. So a bad cell
never reaches a channel as an infinite value. Every reader applies this rule, so a channel holds SI
values or gaps and nothing else (ADR-258, the rule for infinite values,
§3).
Units no source states
Most units come from the file’s own column names or from the maker’s manual. A few don’t:
- AltOS’s
pad_distandpad_rangeare read as meters, as its manual says its exports are metric, without naming these columns. - AltOS’s gyroscope and magnetometer columns (
gyro_*,mag_*) are kept as written, unrecognized, as no document states their units. - The Raven’s status columns,
bILBA, are kept as numbers, the bits read as binary. No published source says what each bit means, so the record takes no events from them. - The Blue Raven’s
Currentis kept as written, unrecognized. The app’s file states no unit. The Blue Raven’s manual gives milliamperes only for another download. The values fit amperes better, but that is a size, not a source. - An RRC3’s
Temperaturewith no unit in brackets is kept as written, unrecognized. mDACS’s preferences set the units it applies (mDACS User Manual, rev. 1.71, p5), and two public files in feet hold one in °C and one in °F (evidence row G31). To have it read, put its unit in the header:Temperature [C]. ItsVoltageswith no unit are read in volts, assumed. Each record says so in a note. - GPS Visualizer’s KML altitude is kept as written, unrecognized. The program takes its source’s altitude as meters unless the source’s column names feet. So its KML holds meters only if the source said which, and the file can’t show whether it did. The one such sample, set beside a barometric logger on the same flight, holds feet written as meters.
- Two KML files styled after AltOS’s, which name no writer, give each point a
Secondsand anAltin a comment. The seconds are read as seconds, from the name. The altitude is read in meters, from the KML standard, as a height above the ground. Their tracks rise less than half as high as their flights’ barometric peaks. Neither meters nor feet explains that, so trust their heights least of any GPS log. - AltOS’s KML writes a
timebeside every point. Where it is 0 at every point, as in most of its sample files, the reader takes it as unset. Then the points have no time. No document says so. - AltOS’s KML also writes the GPS receiver’s
altbeside every point. Where it never equals the path’s altitude, as in 3 of its older sample files, nothing in the file shows its unit. In that case, the GPS receiver’s altitude is kept as written. - AltimeterCloud’s Mercury writes an air density, a predicted apogee, a target altitude and a
second temperature (
mt1_temp). No published page gives a unit for any of these. Each is kept as written, unrecognized. - Entacore AIM’s magnetometer (
Mag X,Mag Y,Mag Z) is kept as written, unrecognized. Its manual names tesla, but the sample files’ values are 17 to 34 times the Earth’s field read so (below). - A Featherweight summary’s four pad accelerations and offsets (
Pad Low-G Accel,Pad Hi-G accel,Low-G accel pad offset,Hi-G accel pad offset) are kept as written. Each is three numbers with no unit, which no source states (below).
Units the file decides
These layouts leave some units out of their headers:
- the RRC3’s;
- the Eggtimer’s: its CSV and terminal text, and that text saved as RTF;
- the Blue Raven’s and AltimeterCloud’s;
- Entacore AIM’s, a Fluctus’s and an ARTS2’s;
- AerospaceNU’s flight computer board’s and its ground station’s, and a phone app’s.
A .pfa states none (below). A SillyGoose’s
header names units that one file’s values contradict. For some, the reader works the unit out from
the file as it reads it. For the rest, it takes the unit the maker’s manual gives. It checks that
unit against the file where the file can show a disagreement. Either way the reader writes a note
giving the decision and this file’s evidence. The survey’s report counts the
decisions over the sample logs:
-
An RRC3’s altitude, speed and clock, worked out from the file. Missile Works’ mDACS is the program that downloads an RRC3’s flights to a computer. It writes the altitude, speed and temperature each in the unit chosen in its preferences. The header names none of them unless the units are in brackets. The pressure settles the altitude. The climb the pressure implies in the standard atmosphere is set against the altitude column’s climb. That climb is read in feet and in meters, 3.28 times apart. The unit within 25% of the pressure’s climb is taken. The speed is set against the altitude’s rate of climb, allowing for the speed to lag behind it. Of feet per second, miles per hour, meters per second and kilometers per hour, the one two measures agree on within 3% is taken. The column is kept as written, with a note, where they don’t agree, the climb is under 50 m (164 ft), or the record ends before the rocket is halfway down or while it is moving. The same goes where the speed’s first row is over 1% of its peak, or its running total ends over 1% of the climb from the altitude: a filter that averages ahead of each sample, not only behind it, can do that. These last two rules leave every sample’s unit as it was. The time is in seconds where its step is the RRC3’s 20 samples a second. Of the 51 RRC3 exports among the sample logs, 47 are read in feet from the pressure and 4 state feet. Of the speeds, 36 are in feet per second and 9 in miles per hour. Another 4 state feet per second. The remaining 2, whose records stop early, keep their speeds as written.
-
An RRC3 export saved by a European locale. mDACS’s export in a European locale’s form is semicolon-separated with decimal commas. It may end every line, the header’s too, with a semicolon. The reader drops the empty cell after that semicolon, on full rows and short ones. The one such sample had its rows sorted by a spreadsheet by their time’s text,
10,05before2. Put in order by value, the rows step 0.05 s with none missing. But the reader keeps a file’s order and refuses a time that goes back, naming the line. So that file is refused and counted as damaged. To read such a file, sort its rows by time first. -
An Eggtimer’s clock, worked out from the file. The Classic and TRS write their time in milliseconds, the Quantum and Proton in seconds, under the same
T. The reader takes milliseconds when the median step is above 5. The manuals’ rates, 1 to 33 samples a second, put a step between 0.03 and 1 in seconds and between 30 and 1,000 in milliseconds. In the CSV download, a step above 1 and below 30 is refused (below). Of the 44 Eggtimer files read, 4 are read in milliseconds and 40 in seconds. -
An Eggtimer’s heights and speeds, from the manuals. The Classic and TRS manuals state feet and feet per second. The Quantum and Proton manuals state no unit for the download, but give every height in feet. No Eggtimer manual offers meters. The heights are read in feet for every model. In a terminal download, plain or saved as RTF, they are read in feet only where a condition holds. The condition is that the coast before apogee also slows at about g in feet (below). A speed is read in feet per second only where it matches the altitude’s change over the step on at least 90% of rows. On the sample CSV downloads, the match is on 95.9% or more of rows. Otherwise the speed is kept as written, as the one RTF sample’s speeds are (below).
-
An Eggtimer’s filtered altitude, held to
Alt. The filtered altitude must scale toAltas a filter of it can. The one multiplier that best takesAltto it, with no offset (a least-squares fit through zero), must lie from 0.1 to 2. Otherwise the file is refused. A filter lags the altitude, under it going up and over it coming down. On a steady climb at ft/s to ft, a lag of s lowers the multiplier by about . For 100 ft/s, a lag of 1 s and a climb to 600 ft, the multiplier is 0.75. A decimal place lost writes a value 10 times over, two places 100 times. A refused file’s numbers can’t be trusted, its clock’s among them. A seconds clock written without its decimal point reads as milliseconds. The check doesn’t catch a column off by a factor inside that range, such as a filtered altitude in meters (0.3048 times). On the 44 sample files read, the multiplier is 0.900 to 1.000 (the survey’s report prints the range). A 45th, a download a spreadsheet saved with its decimal points taken out (12.34written1234), gives 99.9. It is refused, and counted as damaged. In the CSV download, a median step between rows above 1 and below 30 is neither seconds nor milliseconds at the manuals’ rates. The file is refused too. A0.05s step written without its point is5. -
An Eggtimer download saved by a European locale. A spreadsheet set to a European locale saves the CSV download with semicolons between the cells. It may write its numbers with a decimal comma, the mark between a number’s whole part and its fraction (
0,05for 0.05). A header that reads as an Eggtimer’s only when split on semicolons is split on them. The reader then uses a decimal comma only if two conditions hold. No number has a point. And some number has a comma before anything but three digits (0,05). A cell in the other mark, such as1,250in a file of points, is refused on its line. The table reader takes the same cell as a gap. Here a cell the manuals write as a number can’t be left out, so a thousands separator is never read as a decimal mark. Two of the sample downloads, from the European Rocketry Challenge (EuRoC), are semicolon-separated. One has decimal points, and is read. The other has none at all, as a spreadsheet took them out, and is refused (above). Decimal commas are tested on invented files only (evidence row G2). -
A Blue Raven’s speeds, inertial positions, rates of turn and accelerations, from the manual. The manual gives their units for the logger’s USB download, which HPR Sim reads too (below). The units are feet per second, feet, degrees per second and g (Blue Raven User’s Guide, May 12, 2026, p23). The app’s own files agree. Its summary of a flight states the top speed in feet per second and the inertial altitude in feet. Its accelerometers read 1 g at rest on the pad. A file that disagreed would still be read in these units. The note on that file would show the disagreement.
-
An Eggtimer TRS’s terminal download, its preamble by its own unit marks. Captured in a terminal program, a TRS’s download prints its flight settings and a flight summary. Both come before the table its CSV download writes (Eggtimer TRS Flight Computer User’s Manual, firmware 2.07, p35–37). The table is read as the CSV download is. But its clock and its heights each rest on two checks that agree. The clock rests on its step and the coast. The heights rest on the manuals’ feet and the coast. Just before the top nothing pushes the rocket, and its drag fades as it slows. So its altitude curves down at gravity: 32.17 ft/s² in feet and seconds, 9.81 m/s² in meters. The reader fits a parabola to each height over the 3 s up to the top. The fit stops early at the row before a charge’s marker or a jump in the altitude. An Eggtimer can fire a charge on the way up. The window is cut short 16 times at most before the file is refused as having no clean coast. The reader takes a slowing of 0.7 to 1.3 g. A clock 1,000 times off would put the slowing a million times off. A file whose clock this doesn’t bear out, or with no such coast, is refused. A height that slows at g in meters rather than feet is kept as written, with the speeds that are its change. In the 3 sample files, two text and one RTF, the raw heights slow at 0.96 to 1.02 g in feet. The summary’s apogee becomes the record’s stated apogee, and its
ASL Alt.the launch site’s elevation, each read by its own unit mark,ft. The summary’s event times, written without a unit in both sample files, are read in seconds, as the manual’s download writes them (secs., p36). They are on the table’s clock: in both sample files every one matches its marker’s row to the millisecond. So a summary time with a matching marker is kept once, as the marker’s event. The top speed’s time, which no marker marks, becomes an event of its own. A time of 0 means a channel that didn’t fire (p25). The settings are kept as written in the record’s notes. So are the other summary lines, such as the base temperature with its ownForC. The name the owner gave the flight computer is left out, since it may name a person. -
AltimeterCloud’s temperature and summary times, worked out from the file. The Nano V1’s manual has a page on its CSV layout (CSV Flight log format, https://www.altimetercloud.com/support/nano-v1/flight-log-format/, read October 13, 2026). The reader follows Debrief’s in recognizing the layout and in the centi-degree temperature.
- From the manual: time in milliseconds from liftoff, altitude above the pad in meters, acceleration in thousandths of a g. Rates of turn and attitude angles are in degrees. The Mercury’s CSV uses the same names for the same columns. So its rates and angles are read in the Nano’s units too, with a note saying so.
- Total acceleration:
acceleration_total(mG)is the acceleration’s magnitude with 1 g taken out. So it reads about zero at rest and −1 g in free fall. It is kept so, as an acceleration along no axis, and its note says what it is. - The Mercury’s temperature:
bmp_temp(x100)holds hundredths of a degree Celsius. It is read so only when three things hold. Every value is a whole number. Every value divided by 100 falls within the barometer’s measurement range. That range is −40 to 85 °C (Bosch Sensortec, BMP581 data sheet, BST-BMP581-DS004-13, table 2, p. 10). And some values as written fall outside that range, so the column can’t already be in degrees. Otherwise it is kept as written. - The summary’s times: the block at the top of a Nano log gives the apogee’s and the landing’s times with no unit. The apogee time is read in seconds when the log’s highest altitude falls within half a second of it. In all 7 sample logs with a summary, the two agree within 0.01 s. The landing time is read in seconds when it passes two tests read so, but not read in milliseconds. First, the time comes after the highest altitude. Second, the log’s altitude there is the summary’s landing height within 0.01 m (0.033 ft). Read in milliseconds, the time must fail at least one of them. The manual’s Flight info page gives the landing as “when it landed, and the height it came to rest at”. In all 7, the two agree within 0.001 m (0.0033 ft). Read in milliseconds, the time falls on the climb, more than a meter from the landing height. A time the altitude doesn’t bear out is left out, with a note saying why.
- Kept as written: the Mercury’s air density, predicted apogee, target altitude and
mt1_temp, which have no published unit. - Gaps: two kinds of value aren’t readings and become gaps, each counted in a note. One is the zeros the accelerometer writes on the pad before its first reading. The other is the exact 0 °C temperatures that end every sample log after readings of 27 to 44 °C.
-
Entacore AIM’s pressure, heights and clock, worked out from the file. The AIM’s export puts a
timecolumn before each group of channels. Each group is on its own clock (AIM XTRA/BASE v4.x.x Manual, Entacore, 2 February 2025, p40). Every column is kept on its own clock, following Debrief’s reader. The record’s altitude is the AIM’s ownPressure AGL, its barometric height above the ground it was set to. Any unit its evidence doesn’t settle is kept as written, with a note saying why.- From the manual: g for the accelerations (p23–24) and degrees per second for the gyroscope
(p24). The ground station’s
RSSIis in dBm (p29), kept as written. - Pressure: pascals, as its first value that is a launch site’s pressure in any unit is one in pascals. The manual’s sample export writes pascals too (Table 2, p40).
- Heights:
Pressure MSLandPressure AGLare in meters or feet, whichever matches how far the pressure climbs in the standard atmosphere. That works as for the RRC3, from a climb of 2 m (6.6 ft). A file that fits neither, or whose pressure can’t settle it, is refused. - Clock:
timeis in seconds whereGPS Time of Week, in milliseconds, rises about 1,000 for each unit of it, and in milliseconds where it rises about 1. Without that column, the step between samples decides, against the AIM’s 10 to 500 ms sampling periods (p2, p21). A file the step can’t settle is refused. - Temperature: it follows the heights’ unit system, °C beside meters and °F beside feet. That is because the software uses one unit system for all it shows (p33). Its first value must be one an electronics bay can have.
- Voltages: volts, as every value lies within 0 to 20. The batteries the manual names are 3.5 to 10 V (p10). Millivolts would read in thousands.
GPS MSL: in the heights’ unit where it reads within 300 m (984 ft) ofPressure MSLin that unit and not in the other. At a site too low for the 3.28 factor to show, it is kept as written.- Magnetometer: kept as written. The manual says tesla, but the sample files’ field would then be 17 to 34 times the Earth’s at its strongest, about 65 µT.
- A run-out GPS group: the export writes the GPS group one empty cell too wide once the GPS stops logging. This happens in 11 of the 13 sample files with GPS columns. The extra cell pushes every later column one place right. The reader drops that cell only where every group is then whole, and counts each drop in a note. A header naming a column twice is refused.
- Events: the rises of
launch detect,apogee detectand the outputs’A on.…D on. The AIM detects launch only after the rocket has kept above 30 m/s (98 ft/s) for half a second (p36). So that event comes after liftoff.
- From the manual: g for the accelerations (p23–24) and degrees per second for the gyroscope
(p24). The ground station’s
-
A SillyGoose’s units, its header checked against its values. AerospaceNU’s SillyGoose board names most units in its columns, such as
pressurePa,tempKandaltitudeM, but two sample files’ values contradict their names. One has temperatures below zero undertempKand an accelerometer that reads 1 at rest. The other looks replayed rather than recorded. After a few samples on the pad it jumps into the boost, it ends still climbing, and its temperature never changes. It hasangularVelRadS_*rates beyond what a gyroscope (a sensor of the rate of turn) can read. So the reader checks each named unit against the file, and keeps a column as written, with a note, where the values refute it.- Accelerometer: m/s² or g. A board at rest on the pad or hanging under a parachute reads 1 g. The reader takes the unit in which the board reads 1 g, within 10%, for at least 1 s. That reading must also last at least twice as long as in the other unit.
- Gyroscope: rad/s or °/s. While the board reads about 1 g, the reader compares how far its rates say it turned. It compares that with how far gravity’s direction turned in the accelerometer. A log too short to show a turn keeps the gyroscope as written.
- Temperatures: kelvin where every value lies within 233.15 to 333.15 K (−40 to 60 °C). That is the range the project takes for an electronics bay. Otherwise the column is kept as written.
- Heights:
altitudeMmust climb within 25% of what the pressure gives in the standard atmosphere. Otherwise the file is refused, as the record’s altitude would have no unit.unfiltAltis read in meters on the same check, and otherwise kept as written. - Speed:
velocityMSmust match the altitude’s rate of climb, within 25%. - Events: each rise of
drogueFiredandmainFired; the flight-state codes, which no source publishes, are kept as numbers.
-
A Fluctus’s GPS altitude, worked out from the file. Silicdyne’s Fluctus writes each unit in brackets in its header, such as
baro-altitude (m), with a decimal comma (Fluctus – Full Documentation v1.7b, p27, p58). ButgpsAltMSLhas none, in the header or the manual. It is read in meters only where the barometric altitude bears it out at the GPS’s fresh fixes, the rows where its reading changes. That takes at least 10 fixes, spanning at least 120 m (394 ft) of the barometric altitude. The fixes must lie along a straight line, with scatter within 10% of that span. The line’s slope must be within 10% of 1. In feet the slope would be 3.28. The 120 m (394 ft) lets two readings each 6 m (20 ft) off move the slope by no more than 10%. That error is twice the manual’s ±3 m (9.8 ft) horizontal figure (p18). That is because a GPS’s vertical error runs about 1.6 times its horizontal. Otherwise, as where the GPS lost its fix in the climb or lags the flight, it is kept as written. In all 6 sample files it is kept. The latitude and longitude are degrees, from the manual (p38) and a range check. Each change ofstatusis an event named as the manual names it (p23). -
An ARTS2’s unit system, worked out from the flight. The ARTS2’s interpreted data comes in English or metric units. Neither the file nor the manual (ARTS2 User Manual V1.0.0, Ozark Aerospace, 2007) says which. So the reader works it out from the flight:
- Velocity, and the length unit: at apogee the drag vanishes, and the logged velocity falls at g: 9.81 a second in m/s, 32.17 in ft/s. The reader fits the last second of coast before the velocity crosses zero. If the acceleration jumps in the 2 s before (a parachute out early), the reader fits the second before the jump instead. Separately, the barometric altitude moves in steps of one sensor count, about 92 Pa (the manual’s MPXA4100A sensor and 10-bit converter, p16). That step is 5.5 to 14.8 m (18 to 49 ft) near any ground, so 17.9 to 48.6 written in feet. The file is read only when both give the same unit, which also pins the clock in seconds.
- Acceleration: g, or the velocity’s unit per second, whichever makes its integral over the boost the velocity’s rise, within 10%.
- Altitudes: the inertial altitude
iAltmust be the velocity’s integral. The barometric altitudepAlt’s peak must be within 25% of the climb the velocity gives, from a climb of 176 m (577 ft).
A file whose velocity or barometric altitude no check settles is refused. An acceleration or inertial altitude none settles is kept as written. The barometric altitude is the record’s altitude, above the pad reading the logger took on entering flight mode (p17). The file starts at launch. The velocity and inertial altitude are the logger’s integrals of its accelerometer, and drift by the end of the descent. So the record keeps them as channels, not as its vertical speed. The same flight’s
.odffile holds the sensors’ counts with the calibration (the ARTS2’s raw data). -
AerospaceNU’s flight computer board, each unit by two checks. The flight computer board (FCB) of AerospaceNU, Northeastern University’s rocketry club, logs a binary file. The club’s tools turn it into a CSV. The club publishes both (AerospaceNU, rocket-flight-data,
README.md, read October 12, 2026). The 20 sample files come under eight headers of 73 to 87 columns. No document describes the columns. So a unit a column’s name doesn’t state is read only where two checks on the file’s values agree. Neither check is one that the weather or the flight can meet in the wrong unit. A check sets the column against a physical mark (1 g at rest, a barometer’s whole pascals, a sensor’s published sensitivity) or against another column. Where that is a sibling, such as the inertial units’ average against the units, it counts only once the sibling’s own unit is decided. So no counted check relates two columns that share one unknown unit. Where the checks don’t agree, the column is kept as written, with a note:- Pressure, in atmospheres: a pad’s pressure lies near 1 in atmospheres or bars. It is far from 1 in pascals, hectopascals, psi or inches of mercury. And every value is a whole number of pascals divided by 101,325, the club’s conversion, a step no flight or weather can mimic. In bars the values would miss a step of 1/100,000 by up to half a step. Every barometer that reads in the 20 files is in atmospheres. One that reads 0 throughout is kept as written.
- Clock, in milliseconds or seconds, whatever the column’s name says. The climb the pressure
gives must match, within a factor of 10, the one the accelerometer integrates to on that clock.
The rows’ median step must also lie within 5 to 500 ms on it. A file neither unit fits is
refused, as nothing in it would have a time. Of the 20,
timestamp_msholds milliseconds in 12, andtimestamp_sholds milliseconds in 6 and seconds in 2. - Accelerations, in m/s² or g: the board reads 1 g at rest. Each scaled column is its raw
counts times one of the inertial unit’s published sensitivities (LSM9DS1 data sheet,
STMicroelectronics, DocID025715 Rev 3, Table 3). The board’s own estimate,
acc_*, is checked by the pad’s 1 g and the climb instead. One board, the FCBV2 in both its files, reads 1.5 g at rest, its counts scaled for another part. That board is kept as written. So is the high-g accelerometer in every file, whose scale is none of the LSM9DS1’s. - Rates of turn, in rad/s: the gyroscope’s turn must match how far gravity’s direction turned in the accelerometer while the board read about 1 g. The gyroscope’s scale must also be one of the LSM9DS1’s gyroscope sensitivities.
- Heights and speed, in meters and m/s:
pos_zis the board’s filtered altitude above the pad and the record’s altitude. It and the other heights must climb within 25% of the pressure’s climb. They must also climb within a factor of 1.8 of the accelerometer’s ( is 3.24, under the 3.28 between meters and feet).vel_zmust matchpos_z’s rate and the accelerometer’s speed. A GPS may write 0, or hold an old value, until its first fix. Sogps_altis checked only at its fresh fixes (a new value other than 0). Each check is a line fitted with its own offset, so that no pad reading enters either. A pad reading far from where its fixes put the pad is a held value, and the column is kept as written. Wheregps_altis read, a 0 is a gap.pos_zreads in meters in all 20 files,gps_altin 12 (kept as written in 8) andvel_zin 18. - GPS position: NMEA 0183’s degrees and minutes run together (42.5° written
4230.0) put every latitude more than 1° from the equator past 90. They put every longitude more than 2° from the prime meridian past 180. No degrees reach those values.gps_latandgps_longare read in degrees and minutes where three things hold. Most latitudes pass 90 and most longitudes 180. Every value’s minutes are under 60. And every converted value is a latitude or longitude.gps_latandgps_longare read in degrees where every latitude lies within ±90 and every longitude within ±180. A position (0, 0) is no fix: it takes no part, and where the position is read it is a gap. The companionsgps_lat_modandgps_long_modcount in neither decision. They are read in degrees only where they hold the decided position in degrees. Of the 20 files, 15 read in degrees and minutes and 4 in degrees. In 3 of the files read in degrees, the companions are kept as written. These companions hold the values converted as if they were degrees and minutes. The remaining 1, with no fix, is kept as written. NMEA 0183 writes the hemisphere (N or S, E or W) in a field of its own, which the board’s columns drop. So only a sign can carry the hemisphere. Where no value ingps_latorgps_longis negative, a place west of the prime meridian can’t be told from its mirror east. Then the position and its companions are kept as written, with a note saying how the checks would read them. That lets someone who knows the site sign them. Each of the 19 files with a fix writes its longitudes negative, west, and is read. - Kept as written: the temperatures, which read as a barometer’s in degrees Celsius or Fahrenheit alike. So are the battery voltages, the magnetometers, and the raw counts the scaled columns are made from. The state codes, in three numberings no source publishes, are kept as numbers, so the record takes no events from them.
-
AerospaceNU’s ground station text, each unit by two checks. The same board sends its readings by radio. The club’s ground station logs each packet as a line, under a
RUN STARTline. The line holds the time of day it arrived, the packet’s name and its fields as a Python dictionary. An invented line, shortened:10:00:01.512345: Position Data {'crc': 'Good', 'time_stamp_ms': 61000, 'fcb_altitude': 0.25, …}No document describes the packets’ units. So each unit a name doesn’t state is read only where two checks on the file’s own values agree. Neither check rests on a column whose unit is as unknown. Otherwise the unit is kept as written, with a note. The club’s per-flight summaries aren’t a check: they exist for few flights and needn’t match the packets received. In the 4 sample files:
- Altitude,
fcb_altitude, the record’s altitude: its climb within 25% of the barometer’s climb in the standard atmosphere, where feet would be 3.28 times off. A climb further off refuses the file. The second check is its coast, from the end of the boost to its highest value. The coast must slow within a factor of 1.8 of 1 g, where feet would read 3.28 g or more. Read in meters in all 4: climbs 1.006 to 1.090 times the barometer’s, coasts slowing 1.08 to 1.28 g. - Vertical speed,
v_speed: its integral over the barometer’s ascent within 25% of the barometer’s climb. The speed is taken as a straight line across gaps in the reception. The second check is its coast, from its highest value to its first at or below 0. The coast must slow within a factor of 1.8 of 1 g. Neither check usesfcb_altitude. In m/s in all 4: the climb 0.909 to 1.004 times the integral, coasts slowing 1.00 to 1.47 g. - Accelerometer: 1 g at rest on the pad, in m/s² rather than g. The second check starts from the launch. Its force along the pad’s direction less 1 g, integrated to a climb, is compared with the barometer’s climb. It must be within a factor of 1.8 (the median 0.997 to 1.090). Read so in 3; kept as written in 1, which reads 0 throughout.
- Pressures, in atmospheres: by their size and their whole-pascal step, as in the board’s CSV.
- Rates of turn, in rad/s: by the board’s turning against the accelerometer’s, and by its tilt from vertical. The tilt can change no faster than the board turns. Read so in 3; kept as written in 1, whose accelerometer isn’t read.
- Positions, in degrees: most fixes pass or , which radians can’t. Most have a fraction of a degree of 0.6 or more, which degrees and minutes run together can’t. One stray fix decides nothing.
- Clock: the board’s
time_stamp_ms, in milliseconds by its name, must advance 0.8 to 1.25 s for each second of the ground station’s own clock. This must hold over at least 20 s. Packets after the board restarts are placed by the ground station’s clock. - Left out or kept as written: a packet whose radio checksum failed (its
crcnot'Good') is left out and counted. That is because its bytes can’t be trusted. The temperatures, the GPS altitudes, the battery voltage and the roll, pitch and yaw are kept as written. Only the barometer could check the GPS altitudes, and that is one check.
- Altitude,
-
A phone app’s
launchCSV, each unit by two checks. An app that no file names logs a phone’s GPS, accelerometer, gyroscope, magnetometer and, in newer files, barometer. It logs about 20 rows a second (from the 27 sample files’ timestamps). No description of the format was found. Of the 27 sample files, 19 are an older layout of 35 columns with no barometer. The other 8 are a newer layout of 67 or 69 columns that adds a barometer.Secondsis the clock, by its name. Every other column is read in a unit only where two checks agree. The checks must read different numbers. The checks can compare two columns, a column against another of settled unit or direction, or a column’s extent against its steps. Otherwise the column is kept as written, with a note. An invented start of a file, shortened:Seconds,Timestamp,AltitudeMSLGPS,Record,Static,Latitude,Longitude,GTotal,Gx,Gy,Gz,… 0.000,1941868800000,100,1,12,40.123456,-100.234567,1.000000,0.000000,0.932039,0.362358,…- Pressure,
hPa: it names its unit, and its first reading must be a launch site’s, 500 to 1,100 hPa. - Barometric altitude, the record’s altitude, in meters: it must be the pressure altitude of
hPain the standard atmosphere. In feet it would be 3.28 times as large. And in the coast before apogee it must slow at 0.7 g to . That is because gravity and drag slow a coasting rocket by at least 1 g, which an altitude written in feet can’t. Read so in 7 of the 8 newer files. The barometric speeds are read in m/s by the altitude’s rate and the same coast. - Accelerations, in g: the pad reads 1, and the boost’s integral matches the barometric climb rate. The older files have no barometer for the second check, so their accelerations are kept as written. Over all the files, the unit is read in g in 6 files and kept as written in 21.
- Attitude, in radians: each angle by its range (within , the pitch ). The
second check is its direction against a sensor that needs no unit, on rows where the phone is
still. That compares the pitch and roll against gravity’s direction in the accelerometer, and
the yaw against magnetic north in the magnetometer. Android’s
SensorManager.getOrientationdefines the three that way. Read so: the pitch in 25 files, the roll in 24, the yaw in 10 (the 8 newer). In most older files the yaw doesn’t follow the magnetometer, so it is kept as written. - Rates of turn, in rad/s: the gyroscope by the attitude’s turn, where all three angles are read. A second check is a full scale a phone’s gyroscope offers. Read so in 7 files, kept as written in 20.
- Heading, in degrees: by its range (0 to 360, some reading past ) and by its period. Crossing north it jumps by 360 less its turn, where gradians would jump by 400 less it.
- Position, in degrees: the latitude and longitude together, both or neither. They are decided by the latitude’s largest reading (past , within 90) and the longitude’s (past , within 180). That rules out radians, scaled integers and NMEA’s degrees and minutes run together, the last for any site on land. No range can tell degrees from gradians (0.9°). Degrees are taken as phones’ location services give them.
- Time stamp: a Unix time in milliseconds, its steps the clock’s and its date in this century.
- GPS altitude, kept as written in all 27: only one check reaches it, its gain against the pressure altitude. Fixes once a second can’t show the coast. On the pad, the weather on record moves a pressure altitude across a band 1,840 m (6,037 ft) wide. A GPS reading read in meters and in feet differs by m. So the pad separates the two readings only where tops about 2,650. That means a pad above about 2,650 m (8,694 ft) if the column is in meters, or 810 m (2,657 ft) if in feet. No sample file’s pad is that high (evidence row G8).
- Pressure,
-
An Eggtimer’s download saved as RTF, unwrapped. One sample file is an Eggtimer TRS’s terminal download that a text editor saved as an RTF document (Rich Text Format, a word processor’s markup). The reader takes the document’s plain text. It follows the parts of the RTF specification (Microsoft, version 1.9.1, 2008) a saved capture needs: groups, control words and escaped characters. Fonts, colors and pictures are skipped. The reader reads that text as it reads a terminal download (above). A document holding several downloads gives the first; the rest are counted in a note. In the sample file, the table’s clock is in milliseconds and its heights in feet, each by two checks, the coast among them (above). Its speeds, which don’t follow the altitude’s change, are kept as written. So are the summary’s apogee and site elevation, which carry no unit mark the reader knows. An RTF document holding anything else is refused as not an Eggtimer’s. The radio packets in two other sample files are read by the packets’ reader, not this one.
Where one of these layouts holds a barometric altitude or a pressure, the readings come from it, as from every logger’s. A file with neither gives none (Flight-log readings).
A unit read in the wrong one of feet and meters would put every height 3.28 times too high or too low. So the RRC3’s is never assumed where its pressure can settle it. And the Eggtimer’s rests on the manuals.
A worked example
PerfectFlite’s CSV export of a flight starts like this. These are the first rows of an invented
flight, perfectflite-export.csv, which the crate’s tests read and check these numbers against:
Time,Altitude,Velocity,Temperature (F),Voltage,Acceleration (calculated)
0.00,0,0,71.5,9.1,-3
0.50,0,0,71.5,9.1,-3
1.00,0,88,71.4,9.1,1
It reads into a record. The record’s primary track has the times 0, 0.5 and 1 s and the altitudes 0, 0 and 0 m (0 ft). The record also has five channels on that clock:
AltitudeVelocity, whose 88 at 1 s reads as 26.82 m/s (88.0 ft/s)Temperature (F), whose 71.5 reads as 295.1 K (71.5 °F)VoltageAcceleration (calculated), which the export doesn’t explain and is kept as written, unrecognized
Featherweight’s summaries
A Featherweight summary is the logger’s own account of a flight, a figure a row, with no samples. The Featherweight app exports one beside a Blue Raven’s or a GPS tracker’s samples. The Blue Raven “records three sets of data for each flight”. The first is “flight summary data such as maximum altitude and speed” (Blue Raven User’s Guide, updated May 12, 2026, p18). Each row is a figure’s name, then its value, with the unit written after the number:
Rocket Name,Club demo
Max Altitude,2500.25 feet
Max velocity,500.50 feet/sec
Thrust tilt efficiency,98.50%
Direction of 1st motion,-1.0000,0.0000,0.0000
How it is recognized. A file is a summary when two things hold. Its first line that isn’t
blank names Rocket Name. And a line among its first 200 names Max Altitude or
Launch time UTC, figures only a summary states. A tracker’s summary is told from a Blue Raven’s
by its Launch time UTC. A name is matched without regard to case or repeated spaces, and kept
as written.
What the record holds. A summary fills the part of the record that says what the file states about the flight, and nothing else:
- Every row is a figure in the record’s
stated.figures, in the file’s order. Each holds its name and value as written, its quantity, and its value in SI where the reader knows the figure. - The stated apogee is
Max Altitudein SI. For a Blue Raven that is the barometer’s altitude above the pad. For a tracker it is its receiver’s altitude above the pad altitude it states. - The pad’s elevation is a Blue Raven’s
Pad altitude ASL, its barometric altitude of the pad, or a tracker’sPad altitude, its receiver’s. - The serial number and firmware are the rows’ text as written, and the flight number is
Flight numberwhere it is a whole number. - The clock, the tracks and the channels are empty. A note says the samples are in the file exported beside it. That file is the Blue Raven’s low-rate CSV or the tracker’s CSV. So every reading withholds on a summary.
A unit is read only where the figure’s name allows it, as a header’s unit is read for a column. Each figure the reader knows names its quantity and the words the files write for its unit. The main ones are these. The reader’s reference lists every figure:
| Figures | Read as | Unit the file writes |
|---|---|---|
Max Altitude, Main chute deploy altitude | altitude above the pad, m | feet or ft, |
Pad altitude ASL (a Blue Raven’s), Pad altitude (a tracker’s) | altitude above sea level, m | feet or ft, |
Max velocity, Drogue descent rate, a tracker’s velocities | speed, m/s | feet/sec or ft/sec, |
Max motor burn acceleration, Peak drag deceleration, each deployment output’s maximum (Apo channel max accel and the like), Max landing accel | acceleration, m/s² | Gs, |
Temperature on pad, Max Temperature, Min Temperature | temperature, K | F, degrees Fahrenheit |
Time to first burnout, each deployment output’s firing time | time, s | sec |
Thrust tilt efficiency | a fraction | %, ÷ 100 |
Direction of 1st motion, Gravity direction on pad | a direction of unit length, a number an axis | none |
The Blue Raven’s manual describes the same summary as the logger’s USB port prints it, with each field’s unit (p31–33). The manual’s unit words match the app’s except for the two figures below. The USB form also scales some figures (accelerations in g × 10). That scaling isn’t compared. These two are kept as written in every file, never guessed:
Main chute descent rate: the app writes its value infeet, a length. The manual, though, gives the USB summary’s average descent under the main in “feet/second x 10”. A figure whose unit isn’t one its name allows is kept as written, with a note, and isn’t made into a speed.- The four pad accelerations and offsets: each three numbers with no unit. The manual gives the USB summary’s in “units of Gs x 10,000”. The app’s are not scaled so, and no source states what they are in.
A name the reader doesn’t know is kept as written too. So is a known figure whose cells aren’t
the numbers it needs, such as a direction with two components. Each of these has a note. A zero
is kept as the file states it. What a zero means is a reading, which HPR Sim doesn’t take from a
summary. The survey’s report counts each figure kept as written by the
catalog’s family. The main’s descent rate, for one, is kept in 26 files filed as
blueraven-summary-csv and 13 filed as featherweight-summary-csv.
Cells and rows. Cells are separated by commas and trimmed of spaces. Empty cells at a row’s end are dropped, as some files pad every row to four cells. Blank lines are skipped. Lines may end in CR, LF or both. A byte-order mark is dropped. A row whose name is empty or a number is refused. So is a name stated twice, and so is a value too large for its unit’s conversion.
A worked example, from the invented Blue Raven summary that the crate’s test
tests/featherweight_summary.rs reads and checks:
Max Altitude,2500.25 feetgives the stated apogee, .Max velocity,500.50 feet/secis a speed of 152.55 m/s (500.50 ft/s).Max motor burn acceleration,12.0 Gsis .Temperature on pad,77.0 Fis 298.15 K (77.0 °F).Thrust tilt efficiency,98.50%is the fraction 0.985.Main chute descent rate,-20.0 feetstays −20.0 as written, with the note`Main chute descent rate` kept as written, in a unit that isn't a speed: the file writes `-20.0 feet`.
Checked against the files beside
A summary and the samples exported beside it describe the same flight. So the survey checks the two
lengths a summary states against them. cargo xtask logs takes each file of samples in the
summary’s folder that its reader reads and that holds an altitude. That means a Blue Raven’s
low-rate CSV, not its high-rate one, or a tracker’s CSV. The command compares the summary’s maximum
altitude with the file’s highest altitude above the pad. For a tracker, that is its highest GNSS
altitude less the pad altitude the summary states. It compares the pad altitude with the median of
the file’s first 20 altitudes above sea level. A figure agrees within 10%. When several files sit
beside a summary, the ratio, summary over file, nearest 1 is the one counted.
Feet and meters are 3.28 apart, so a band of 10% tells them apart. A summary that would agree
only were its feet meters contradicts its unit. cargo xtask logs --check fails on it. A
folder may hold other flights’ files, so agreeing is counted, not required. The
survey’s report prints the counts. It names a file by the survey’s id, the
first 16 hex digits of its SHA-256:
| Logger | Summaries | Summaries with a file beside | Summaries with a file beside and an apogee stated | Apogee agrees | Apogee ratio, range | Pad agrees | Pad ratio, range | Agreeing in neither | Contradicted |
|---|---|---|---|---|---|---|---|---|---|
| Featherweight Blue Raven | 39 | 36 | 36 | 35 | 0.9698 to 1.0091 | 35 | 0.9770 to 1.0032 | cd1bfe19ff70e17d | none |
| Featherweight GPS tracker | 12 | 11 | 5 | 5 | 0.9995 to 1.0000 | 10 | 0.9766 to 0.9999 | 413de085a44f4872 | none |
No summary agrees only as meters. Of the tracker summaries, 5 of the 5 that state an apogee agree in it. The one of each logger that agrees in neither figure agrees with no file beside it, not even as meters. The survey doesn’t show why. Nor is it measured why a Blue Raven’s stated apogee runs up to 3% below its low-rate file’s highest altitude (ADR-260, the summaries’ check §4). The summaries with no file of samples beside them are read by the same rules, unchecked (evidence row G7). No other figure is checked. Summaries inside zip archives are read and checked as the others are, against the files of samples in the same archive (zip archives). The two inside Excel workbooks are read by the same rules, unchecked (Excel workbooks).
GPS logs
A GPS tracker or a flight computer’s GPS receiver logs where the rocket was. A log holds a latitude and longitude in degrees and an altitude above sea level. It also holds figures of the fix (the receiver’s solution of its position), such as how many satellites it used. These logs have no barometer. So a GPS log’s record has an empty primary track and keeps everything as channels, with a note. The readings withhold on it, each by name. A receiver’s altitude lags a climb and overshoots its top, and its fix drops out at liftoff. So no bound can be stated for it.
GPX is read from invented files only, as no sample log is one. Its elevations state no datum (GPX) (evidence row G1).
Five layouts are read. Each point’s time is the one the file gives it. Where the file gives none, the point keeps its place with its time a gap.
- Featherweight’s GPS CSV, from Featherweight’s GPS tracker.
- Clocks. The tracker’s own log times each fix by
UTCTIME, such asJul 14 2031 17:04:31.250 UTC(UTC is Coordinated Universal Time, the time zone GPS receivers keep). ItsUNIXTIMEruns a whole number of hours, 4 to 8, ahead ofUTCTIME. That holds on every row of all 28 tracker logs among the sample logs. It is as if the site’s offset from UTC had been added where it should have been taken away. So that time is kept as written with a note of its offset. In the older layout rows step back in time and repeat. They are kept in the file’s order and counted in a note. The ground station’s log times each row byDATEandTIME, in a zone the file doesn’t state (in most sample files, the launch site’s). That log may hold several trackers. Each gets its own channels, such asLAT [Rocket-1]. - Units. No header names one. The manual gives the altitude in feet, the speeds in feet per second and the heading in degrees (Featherweight GPS Tracker User’s Manual, February 20, 2025, p17). The reader checks each file. The horizontal speed against the distance between fixes is the check that tells feet from meters. That works since the positions are in degrees whatever the unit. Of the 40 sample files, 37 move enough for it, and in all 37 it agrees with the manual. In the other 3 the manual alone decides, and the note says so. Where it disagreed, every length and speed would be kept as written. The vertical speed against the change of altitude shows only that the two share a unit.
- No fix. A position of exactly (0, 0), which the tracker writes before it has a fix, is read as a gap.
- Clocks. The tracker’s own log times each fix by
- KML (Keyhole Markup Language), the XML file Google Earth opens, standardized as OGC
07-147r2.
- Tracks. A track is a path of longitude, latitude and altitude, in meters by the standard.
The track’s
altitudeModesays what its altitude is. It is above sea level forabsolute. It is a height above the ground forrelativeToGround. It is nothing a viewer uses forclampToGround, whose altitudes are kept as written. An AltOS file can hold the barometer’s altitude in the path and the GPS receiver’s beside each point. The reader keeps each as what it is. - Times. Only Google’s
gx:Trackpairs each point with a time (when). AltOS, Big Red Bee’s BeeLine and two unnamed files styled after AltOS’s write each point’s time in an XML comment beside it instead. The reader takes that time. The rest give no time. They are fw2kml’s paths (from a converter of Featherweight’s logs), Missile Works’ RTx and GPS Visualizer. The survey reads 43 sample KML logs. When 42 were read, 9 timed their points and 33 read as paths without times. The survey doesn’t count them yet (#929).
- Tracks. A track is a path of longitude, latitude and altitude, in meters by the standard.
The track’s
- NMEA 0183, the sentences a GPS receiver sends, in the format the National Marine
Electronics Association set. Each is one line and ends in a checksum, two hexadecimal digits
that check the characters before them.
- Sentences. The reader takes four kinds.
GGAholds the position, altitude and fix.RMCholds the position, speed, course and date.GSAholds the satellites used and the precision.GSVholds each satellite in view. A sentence counts only if its checksum checks out. Noise before it, as a receiver writes on power up, is left out and counted. - Clock and units. The time of day is UTC. The date comes only from an
RMCwith a valid fix, because before its fix the receiver writes a placeholder date. A speed in knots is read as 1,852/3,600 m/s a knot.
- Sentences. The reader takes four kinds.
- Missile Works’ RTx, a GPS tracker: the
.rtxfile its maker’s program saves, and the CSV and text files it exports. They have been read since M7.1c12 (below). - GPX, the GPS Exchange Format. It has been read since M7.1d1, from invented files only (below) (evidence row G1).
For example, take a GGA sentence’s position and an RMC sentence’s speed, invented after the
textbook example public descriptions of NMEA 0183 give. A test in the crate reads these two lines
and checks every number below:
$GPGGA,123519.000,4807.0380,N,01131.0000,E,1,08,0.9,545.4,M,46.9,M,,0000*59
$GPRMC,123519.000,A,4807.0380,N,01131.0000,E,022.4,084.4,230394,,,A*62
The latitude 4807.0380,N is 48 degrees and 7.038 minutes north, °. The
longitude 01131.0000,E is 11 degrees and 31 minutes east, 11.5167°. The altitude is 545.4 m
(1,789 ft) above mean sea level, in the unit the sentence names (M). The speed of 22.4 knots
reads as (37.8 ft/s). The course is 84.4° from true north. The
record’s zero is the first sentence’s time, 12:35:19 UTC on 23 March 1994.
Missile Works’ RTx
Missile Works’ RTx/GPS is a GPS tracker built around a u-blox 7 receiver. It keeps its fixes once
a second, up to “~68 minutes per flight”. It radios them to a base station (RTx/GPS User
Manual, firmware 1.31, Missile Works; November 26, 2016; pp2, 14). Missile Works’ mDACS program saves a
download as an .rtx file. The program exports that file to CSV, text and KML (mDACS User
Manual, revision 1.71, May 2024, p16). The KML is read as above. The .rtx and the
CSV and text exports are read by hpr_flightdata::rtx. Neither manual describes the files. What
follows was worked out from two sets of files. They are the 5 .rtx files among the sample logs
and the 13 exports beside them (8 CSV and text, 5 KML). The sample logs hold one more CSV
export, beside no .rtx. No other program’s source was read
(ADR-267, reading the RTx before the other layouts).
Like every GPS log here, an RTx file feeds no reading. That is because the readings need a
barometer’s track (see GPS logs).
In 4 flights the tracker’s climb is 0.98 to 1.15 times the highest altitude of the barometric altimeter flown beside it. The survey reports that figure but doesn’t check it.
-
The
.rtx. A stream written by .NET’s built-in object serializer,BinaryFormatter. It holds one list of 65,536 32-bit integers, in the layout Microsoft publishes as MS-NRBF. That is 4,096 records of 16 slots, 68.3 minutes at one a second, the manual’s flight. The list’s size counts the slots in use. The rest are 0. -
The slots. Each holds a 16-bit number, a word, but not as written. The slot holds the word times 387,420,489 (), keeping only the remainder after dividing by . Multiplying a slot by 513,180,409 and keeping the same remainder gives the word back. That is because leaves a remainder of 1. The files show it three ways. First, the slot holding the time steps by exactly 387,420,489, less any whole , from one fix to the next a second later. Second, every one of the 264,336 slots in use in the sample files reads back as a word below 65,536. A slot drawn at random from 0 to would do that about once in 15,000. Third, the words equal the exports’ figures, field by field.
-
The words. Each record is one fix:
Word number (from 0) Field Read as 0, 1 the time, HHMMSSword 1 × 65,536 + word 0 2 the latitude’s degrees and whole minutes, DDMM3, 4 the minutes’ five decimals, after a leading 1 word 4 × 65,536 + word 3 − 100,000 5, 6, 7 the longitude, as the latitude 8 the altitude, m 9 Velocityas written 10 VDOP, the vertical dilution of precisionas written 11 the hemispheres: NorSin its low byte,EorWin its high12 NavStatus, the receiver’s fix status, in its low byte;Sats(satellites used) in its highas written 13 SOG, the speed over groundas written 14 COG, the course over ground, degrees15 a word the exports leave out, 814 to 2,272 in the sample files as written -
The exports. The CSV and the tab-separated text file hold every fix of their
.rtxbut the last, in the same order. The time isHHMMSS. A position isDDMM.mmmmmand its hemisphere’s letter. In 5 of the 9 sample exports it is instead in signed degrees cut toward zero at the sixth decimal, with a degree sign. The altitude is in whole feet, the meters × 3.280 84 rounded down, which the reader converts back to meters. The rest is as the.rtxholds it. The text file’s header names two empty columns its rows don’t have. -
Units.
- Altitude, meters. The manual says the GPS altitude “is always expressed as Mean Sea Level” (p13). The KML export beside each sample file writes the word as meters. The CSV and text exports convert it to feet. All three come from mDACS reading the same word. So the survey adds one more check, reported but not enforced. The check is that the climb from the pad to the highest fix agrees with the barometric altimeter flown beside the tracker, as above. Feet would be 3.3 times off. The fifth file’s list is full and holds a climb of 0.003 times the altimeter’s. Its memory filled before the flight.
- Altitude at 0. The file can’t hold an altitude below 0. So the receiver’s altitude looks clamped there. In 4 of the 5 sample files, from pads near sea level, most fixes read exactly 0. A note counts them. Each means sea level or below.
- Course, degrees. The course lies 1.7° to 6.9° from the bearing between the fixes either side of it. That is the median difference either way in each file. It is taken over the fixes whose speed over ground reads at least 15 in the file’s own numbers.
- Speed over ground and velocity, as written. The speed over ground runs 3.5 to 4.0 times the speed between fixes in m/s, by file. That is what km/h would give, and km/h is one of the two speed units the tracker’s display offers (p12). But nothing says which unit the file holds, and feet a second would give 3.3. The velocity reads far more than the climb rate in m/s while the rocket climbs. It reads about the fall rate itself while the rocket falls. No document explains that pattern. Plotted, both show when the tracker moved, but not how fast in any known unit.
-
The clock. The GPS’s time of day, UTC, in whole seconds, with no date. The log’s zero is the first fix’s. Each time takes the day that puts it nearest the one before it. So the clock runs on past midnight UTC, and a repeat written across midnight goes back to the day before. In 3 of the 5 sample files a pair of fixes repeats the pair before it a second back. Every fix is kept in the file’s order, with a note. In one file, one fix’s time reads 65,282 × 65,536 more than it should, as a garbled radio packet’s might. A time that isn’t a time of day is a gap, counted in a note.
-
Gaps and refusals. A coordinate out of range is a gap, as is a position of exactly (0, 0). Out of range means minutes past 59 or the decimals without their leading 1. A hemisphere byte other than its two letters counts too, as does a value beyond 90° or 180°. No sample file has an out-of-range coordinate or a (0, 0) position (evidence row G2). An
.rtxthat isn’t the list’s shape, or whose size or slots break the rules above, is refused, naming the byte. An export’s row of other than ten cells, or a cell that isn’t its field’s, is refused, naming the line.
For example, the crate’s tests read an invented .rtx and its exports. The first fix is at
17:59:50 UTC, HHMMSS 175950. That is more than 16 bits hold, so the record splits it. Word 1 is
and word 0 is .
The file holds word 0 as the slot 656,705,342, the remainder of
after dividing by . The reader multiplies it by 513,180,409 and keeps the last nine digits,
44878 again. The latitude’s words are 3259, 35698 and 1. Then , a leading 1 and the decimals 01234. So the fix is 32° and 59.01234′ north,
°. Its altitude word is 1,400 m (4,593 ft). The CSV export
writes the fix as one line
175950,3259.01234N,10658.54321W,4593,0,2,122,9,12,40
its altitude , read back as
. The text export writes the longitude in degrees, -106.975720°.
The .rtx holds , which is °. So the sixth decimal is
cut, not rounded.
GPX
GPX, the GPS Exchange Format, is the XML file GPS receivers, phone apps and mapping tools save
tracks in. Topografix publishes its two versions as schemas,
GPX 1.0 and
GPX 1.1, with
a manual for 1.0. HPR Sim reads both since
M7.1d1, by hpr_flightdata::gpx. The reader was written
from those documents.
The check. The test is every_value_of_the_samples_equals_gpxpys in
crates/hpr-flightdata/tests/gpx.rs. The gpxpy reading is written by
validation/oracles/gpx/gpxpy_read.py. The samples hold only what both readers read alike. gpxpy
reads a number with an exponent, a point off the globe and a time that goes back, which this
reader refuses. gpxpy cuts a time to the microsecond and refuses an ele of spaces only, which
this reader reads as a gap.
- Tracks. A file holds tracks (
trk), each of segments (trkseg), each of points (trkpt). A receiver starts a new segment where it lost reception or was turned off. Each segment is read as a GPS track. Its channels are named after its track, such asFlight 7 latitude. They are numbered where the track has several segments, such asRocket segment 2 speed. A point gives its latitude and longitude in degrees, its elevation in meters (ele) and its time. Where it states them, it also gives its satellite count and its dilutions of precision. These are horizontal, vertical and position (3-D) (hdop,vdop,pdop: how much the satellites’ geometry spreads the fix). In GPX 1.0 it can also give its course in degrees from true north and its speed in meters per second. A value a point leaves out, or leaves empty, such as<ele/>, is a gap. The rest, such asfixand an app’s ownextensions, is counted in a note and not read. - Elevation. GPX gives
elein meters but no vertical datum. It is read as an altitude of unstated zero: only its rise between points means what it says. A receiver’s NMEA GGA altitude is above mean sea level. Android’s location API gives the ellipsoidal height, Apple’s the height above sea level. That offset barely changes over a flight: it moves the pad’s elevation, not the height above the pad. A handheld may write its barometer’s, whose error grows with height. A track point’sgeoidheight, the geoid’s height above the ellipsoid, is read as a channel,<name> geoid height. It doesn’t say whicheleis: GPSLogger, which wrote 7 of 10 such files opened on GitHub, writes the ellipsoidal height unless set to sea level (#645). One Eggfinder track saved as GPX most likely holds sea level, with moderate confidence (a research note; evidence row G1). - Times. GPX times are in UTC, as GPX 1.1’s schema and GPX 1.0’s manual require. A time with
an offset, such as
08:30:00-04:00, is moved to UTC. One with no zone is read as UTC, with a note. A second written 60, a leap second’s, is read as the next minute’s first. The record’s zero is the first time the file gives a track point (or, with none, a waypoint or route point). A point with no time keeps its place with its time a gap. A time that goes back within a track is refused, as such a track isn’t one recording. Two tracks may run in any order, as a file holding two flights does. - Waypoints and routes. A waypoint (
wpt) marks a place, such as the pad, and a route (rte) plans a path. Neither was flown. They are kept apart from the tracks, as figures the file states, such aswaypoint Pad latitude. So no reading takes them for the flight. - Refused. A document type declaration is refused, and so is a reference to an entity XML
doesn’t define, such as
&rocket;, so no entity, XML’s named text, can expand. A point off the globe is refused, with a latitude outside −90° to 90° or a longitude outside −180° to 180°. So is a value that isn’t a plain decimal number, such as1e3, and a time that goes back. Each refusal names what it found and its line. - Limits. At most 256 segments, 1,000,000 track points and 10,000 waypoints and route points are read. The rest are counted in a note and left out.
For example, take the first and the tenth point of the track in the invented sample
gpx-1.1-phone-app.gpx, shortened. A test in the crate reads the file and checks every number
below:
<trkpt lat="35.2000120" lon="-97.1000340">
<ele>402.0</ele><time>2031-07-14T17:04:04.000Z</time>
<trkpt lat="35.2001659" lon="-97.0999611">
<ele>868.4</ele><time>2031-07-14T17:04:13.000Z</time>
The record’s zero is the first point’s time, 17:04:04 UTC on 14 July 2031. The tenth point is later and (1,530 ft) higher. It is the track’s highest point. The
same file marks the pad as a waypoint at 17:03:40 UTC. That is read as the figure waypoint Pad time, 24 s before the zero, −24 s.
Other PerfectFlite files
Besides the .pf2, which has a page of its own, PerfectFlite’s software exports a
flight as CSV or text. An older PerfectFlite altimeter saves its flights as a .pfa.
PerfectFlite’s exports
PerfectFlite’s software exports a flight as CSV, Time,Altitude,Velocity,Temperature (F),Voltage,
sometimes with Acceleration (calculated) after them. The software can also export tab-separated
text, Time, Altitude, Temp., Voltage. The temperatures in the text carry their unit
letter, such as 58.7F. One sample CSV export names its temperature Temp, without the dot, and
is read alike. Some text exports have no header row at all. Their rows are four tab-separated
numbers, the third a temperature with its unit letter, F or C (0.05, 3, 71.5F, 9.2).
No other layout HPR Sim reads writes a unit’s letter after a number in such a row. Among the
sample logs only PerfectFlite’s text exports do. So such a row is read as the text export’s four
columns. The record’s notes say that its columns were taken, not read. That is a guess at which
column is which, made from the layout alone.
The units are a .pf2’s: seconds, feet and feet per second. The header doesn’t state the
altitude’s unit, and the sample logs bear out feet. Of the 21 exports among them, 16 peak at
exactly the height of the .pf2 saved beside them, which states feet. Read in feet, those 16
climb in 0.94 to 1.05 times as long as a fall in vacuum from their peak would take. The other 5
climb in 0.63 to 1.07 times, read in feet. They would climb in 0.35 to 0.59 times read in meters
(the survey’s report prints these, and each of the 5 by id). Of the 4
headerless exports, 2 are one flight, exported once with its temperatures in °F and once in °C.
Both peak at exactly the height of the .pf2 beside them. So the headerless layout writes feet,
whatever its temperature unit. A third climbs in 0.99 times a fall in vacuum read in feet, among
the matched exports’ 0.94 to 1.05. Read in meters it climbs in 0.55 times. The .pf2 files beside
it are other flights’. The fourth has no .pf2 beside it, and its climb settles nothing. Its 0.63
read in feet and 0.35 in meters both fall outside the band of the matched exports. Its altitude is
ragged near its peak. Its feet rest on the layout’s convention alone. Check its altitude against
another source before trusting it. An export doesn’t name the
altimeter’s model, so its logger reads PerfectFlite.
A header with any other name, or these names in another case, isn’t read as PerfectFlite’s. The
RRC3’s Time,Altitude,Pressure,… is the RRC3’s, and a bare time,altitude says nothing of its
units.
PerfectFlite’s older .pfa
The Alt15K/WD, an older PerfectFlite altimeter, saves its flights through PerfectFlite’s DataCap
program as a .pfa. The file has a line naming the altimeter, then Ground:, Apogee:,
NumSamps: and Comments: lines. Then comes a blank line, a **!!Data: line, and one height a
line, such as 00274. Most files end their lines in a carriage return alone, as old Macs did.
Some end them in CR LF. Both read.
The file has no time column and names no unit. The altimeter’s manual says it takes a sample
every 100 milliseconds (Alt15K/WD User’s Manual, p. 2). The manual also says it reports heights
in feet (p. 6). The help of DataCap 1.10 for the Mac (AltCapWD) says 10 samples a second. So each
height is read in feet above the pad, 0.1 s after the one before. The 25 sample .pfas bear it
out. In every one, NumSamps: is the number of heights and Apogee: the highest of them
(the survey’s report prints these checks). Each record says so in a note,
which the survey counts.
Two things in the file aren’t what they look like:
- Time zero isn’t liftoff. The altimeter notices a launch once the rocket is 80 ft up
(manual, p. 2). A later revision lets the threshold be set from 40 to 250 ft (PerfectFlite’s
Alt15K specifications page). The altimeter saves its last 8 samples, the one that noticed among
them (p. 2). DataCap’s help says sampling “begins at a point 0.7 seconds before the launch is
detected”, seven steps of 0.1 s. So time zero is 0.7 s before the
altimeter noticed the launch. The rocket left the pad before it noticed. A slow rocket may
have left before time zero, so the file can miss the first moments of the climb. Every sample
.pfafirst reaches 40 or 80 ft at 0.7 s (17 at 80 ft, 8 at 40 ft, as the report prints). Ground:isn’t the pad’s elevation. It is the pad’s pressure altitude. That is the height the day’s air pressure would mean if sea-level pressure were the standard 29.92 inches of mercury (inHg). DataCap’s help says it is about 100 ft off for every 0.1 inHg the day differs. The help gives it “for interest only”. The record keeps it in a note, not as the ground elevation.
A worked example: take the invented sample perfectflite-alt15k.pfa (read by the test
tests/perfectflite_pfa.rs). Its eighth height, 00088, is the sample at 0.7 s, the first at
80 ft or more. It reads as above the pad.
DataCap’s help also says a NumSamps: of 2,200 (a revision 2 altimeter) or 2,400 (the original)
likely means the altimeter lost power in flight. It says older flights then follow this one in
the data. Such a file reads, with a note saying so. None of the sample files is one. A line among
the heights that isn’t a whole number, or an empty line between them, is refused, naming the line.
That is because every line is a step of 0.1 s, so one left out would move every time after it.
Raw downloads
A raw download is an altimeter’s memory as its maker’s program copies it to a computer. It is the
memory before that program turns it into an export with columns and units. HPR Sim reads six. The
Featherweight Raven’s .FIPa and Missile Works’ RRC3 .rff are described first. The other four
are AltOS’s .eeprom, the ARTS2’s .odf, the AltiMAX’s .ALS and the Entacore AIM’s raw dump.
The AIM’s section covers the dump beside the .xtra file its software makes of it. Each of the
four has its own section below
(AltOS’s .eeprom, the ARTS2’s raw data,
the AltiMAX’s .ALS,
the AIM’s .xtra and raw dump).
Each holds the sensors’ readings as whole numbers, counts. The AltiMAX’s are in pascals instead.
None holds an altitude. The maker’s own arithmetic turns the Raven’s, the RRC3’s, the AltiMAX’s and
the AIM’s counts into SI. The sensors’ data sheets and the calibration the file carries do that for
AltOS’s and the ARTS2’s. A count with no source stays as written.
Not compared: the exports’ altitudes, flags and the velocities they work out. Those are the
programs’ conversions, not the altimeter’s words. The one exception is the ARTS2 export’s altitude,
whose order is checked. Where a number matters, set it beside the maker’s program’s export of the
same flight. The other 2 .FIPa files and 5 .rff files are decoded by the same rules, unchecked
by an export (evidence row G6). The RRC3’s pairs and single words have no
calibration to check. The sections have the rest:
- AltOS’s
.eeprom: the TeleMetrum v1’s pressure assumes its converter’s reference is the sensor’s supply, which no document states. The TeleMega v4’s IMU isn’t read. - The ARTS2’s raw data: the exports’ acceleration agrees within 0.080 of a count on every record after the first. The raw CSVs hold the same 48,614 records word for word.
- The AltiMAX’s
.ALS: pressures, event codes and voltage numbers equal the export’s bit for bit; the rest match to 15 digits once the two rules are applied. The rules are shown consistent with the one file, not to hold for every file. The voltages’ factors and the speed after apogee are the software’s, not the file’s. - The AIM’s
.xtraand raw dump: the dump’s times run slow against the GPS’s clock by 0.9 % in flight and 2.1 % on the pad. The.xtra’s times, which the software sums in 32-bit floats, run slow by about 1.8 % over the climb.
The Raven’s .FIPa
The Featherweight Interface Program (FIP) saves a .FIPa as a few text lines starting #, then
the memory. The text lines give the firmware, the flight’s number, the settings and the length of
a tick of the Raven’s clock. The memory comes in frames of a :, 256 bytes and a checksum byte.
A frame holds four blocks of 32 words of 16 bits. Each block covers 0.05 s, its words taking turns
among the channels:
- the axial accelerometer, 11 bits, 400 times a second;
- the lateral accelerometer, 10 bits, 200 times a second;
- ten slow channels, a word each, 20 times a second. They are the current draw, the four pyro
channels’ voltages, the battery’s voltage, the temperature and the pressure. They also include
the speed the Raven integrates from its accelerometer, and the sixth. The FIP doesn’t export the
sixth (the reader names it
slow channel 5, counting from zero).
The rates follow from the blocks’ layout. The FIP’s export times its rows by them. Featherweight’s manual says the Raven records the data its deployment logic uses at 20 Hz (Raven User’s Manual, updated for the Raven4, August 15, 2020). The first five blocks are the quarter second before the Raven detected the launch. The sixth is the settings block, which holds the accelerometers’ calibration and the ground’s elevation. Time zero is the first sample before the launch, as in the FIP’s export.
Each word becomes the value the FIP’s export prints, by the export’s own arithmetic. Each value then
becomes SI, as the Raven FIP CSV reader reads that column. The pressure word
counts 1/25,000 of an atmosphere. The voltages count thousandths of a volt, and the temperature
hundredths of a degree Fahrenheit. The speed counts tenths of a foot per second. The reader keeps
as written, as unrecognized, the sixth slow channel and the two words after each block’s
samples. On a Raven whose header says its accelerometer has one axis (one sample file), the lateral
bits are kept the same way, as lateral counts. That is because that Raven calibrates no lateral
axis. A frame whose checksum fails is refused, naming its byte.
A worked example, with invented numbers. The crate’s test tests/raven_fipa.rs reads and
checks it. The axial accelerometer reads in g as
where is the count. The settings block gives the gain X1, the zero Z1, and the offset F3 in hundredths of a g. The function trunc drops the fraction. Take a gain of 8,200, a zero of 1,000 counts and an offset of 5 hundredths. A count of 1,025 is 25 above the zero. The FIP works in double-precision floating point. There 8.2 is stored a hair below 8.2, so comes to 204.999… and truncates to 204. Adding the offset gives 209 hundredths: 2.09 g, or 20.50 m/s². Exact whole-number arithmetic would give 205 and 2.10 g. The reader works as the FIP does.
The RRC3’s .rff
mDACS, Missile Works’ program, saves an RRC3’s download as a .NET serialized object. Microsoft publishes that layout as MS-NRBF. The object holds one list of 16-bit words: the altimeter’s memory as it came off the board. The list has no columns and no times, so the reader tells the words apart by their size. Debrief, the project owner’s earlier analyzer, does the same:
- A word below
0x4000(16,384) is a pressure, in tenths of a millibar.0x2710, 10,000, is 1,000.0 mbar, or 100,000 Pa.0x4000would be 1,638.4 mbar. That is above the 1,200 mbar at which the RRC3 itself reports a pressure sensor fault (RRC3+ / RRC3 User Manual v1.71, p. 9). So no reading reaches it. - A word at or above
0x4000is an auxiliary word. Most come in pairs once a second. The pairs are presumably the temperature and battery voltage the RRC3 records once a second, in counts. A few stand alone (three in each sample file: one near apogee, one later, and a last0xFFFF). The first two fall where the manual’s low-voltage samples, taken as the drogue and the main fire, would, but that is a guess. The file holds no calibration for either, so both are kept as written, as unrecognized, in channels of their own. - A zero word ends the log. The reader looks among the first eight words for the first that can be a launch pad’s pressure, at least 500 mbar. The words before it are kept in a note.
The pressures are on the RRC3’s 20 Hz clock, from its manual (RRC3+ / RRC3 User Manual v1.71, p. 23). The nth is at n/20 s. The file has no times to confirm that clock, so the reader checks it another way. The once-a-second pairs must count the same seconds as the pressures do at 20 a second, within 10% and two pairs. Otherwise the file is refused.
What the record keeps
Neither file holds an altitude. The altitudes in the FIP’s and mDACS’s exports are those programs’ conversions of the pressure. So each record has an empty primary track, with a note. A GPS log and the Blue Raven’s high-rate file have the same. The record’s channels hold everything, the pressure among them. The readings turn that pressure into a height by the 1976 standard atmosphere and zero it on the pad. The Raven’s settings block gives the ground’s elevation, which becomes the launch site’s. The Raven’s flight number and firmware are kept as stated.
Checked against the makers’ exports
A raw download and its maker’s export of the same flight are two readings of the same bytes.
So one checks the other sample by sample. cargo xtask logs pairs each raw file with every export
in its folder that the export’s own reader reads. It counts a match when every sample of every
channel the two share agrees. The value must agree within half a step of the raw format’s
resolution, and the time as the export prints it. Every raw sample counts once. The FIP’s export
prints a row every tick of the Raven’s clock and holds each channel’s latest sample in it. So every
raw sample must show at a row of its own time, none skipped. Only the velocity may stop before the
raw file’s last sample, as the FIP stops it at apogee. The velocity’s samples after the stop are
counted apart. cargo xtask logs --check fails on a raw file with an export beside it that matches
none. The survey’s report prints the counts, in its paragraph that opens
“The raw downloads against their makers’ exports”:
| Layout | Files | Files with an export beside | Files matching | Raw samples compared | Velocity samples after the stop | Worst value, steps | Worst time, s |
|---|---|---|---|---|---|---|---|
Raven .FIPa | 57 | 55 | 55 | 6,016,104 | 140,865 | 0 | 0.0005 |
RRC3 .rff | 6 | 1 | 1 | 3,541 | 0 | 0 | 0.01 |
The worst times are the exports’ own rounding. The FIP’s newer exports print a time to six significant figures, 0.0005 s at most here. The mDACS program keeps its clock as 0.05 s added up row by row in single precision. That clock runs a hundredth of a second ahead of the RRC3’s 20 Hz from 156.65 s. Worked that way, the survey reproduces all 3,541 of its export’s times exactly. Every value matches only with the FIP’s own arithmetic. Suppose the accelerometer’s gain used exact whole-number arithmetic. Then 11 files would differ from their exports by a hundredth of a g, as in the worked example above. The other 44 of the 55 would match (ADR-259, a decision record, gives the probes). The one RRC3 export is mDACS’s, in UTF-16 with a UTF-8 byte-order mark written a second time inside it. The importer’s text decoding now drops that mark, so the export reads as RRC3 CSV.
Two .FIPa files and five .rff files have no export beside them. They are decoded by the same
rules and pass the checks each file carries (every frame’s checksum, the RRC3’s clock check). But no
export checks their values.
AltOS’s .eeprom
HPR Sim reads the log an Altus Metrum flight computer keeps in its own memory. It reads that log as
AltosUI, Altus Metrum’s ground software, downloads it and saves it to an .eeprom file. Altus Metrum publishes no layout for these records. So the reader’s
layout was worked out from the 14 sample files and the AltosUI exports (CSV) of the same flights
beside 9 of them. That work was done without AltOS’s or AltosUI’s source code. Each unit the reader
converts rests on a sensor’s data sheet and a second check. A count with no source is kept as
written.
More on the note’s items:
- Checked. The telemetry pressures are compared at a shared tick. Every row of the export is at a tick the file holds.
- Assumed. The exports of the TeleMetrum v1’s flights agree.
- Unchecked. Those 4 files are decoded by the same rules and pass the reader’s own checks. The 14 files are 9 with an export, 1 with telemetry alone, and those 4 (evidence row G4).
The board logs its sensors 100 times a second in the climb and 10 times a second in the descent.
Those rates are in The Altus Metrum System, Bdale Garbee and Keith Packard, v1.9.22.2, 2025,
Appendix F, Table 11, p. 77. Each record is a type letter, a checksum byte, the board’s 16-bit tick
and the type’s fields. F is the flight (its number, the accelerometer’s and the barometer’s
readings on the pad). A holds the sensors. S is a change of state. A board with GPS also has
records of its fix and its satellites. The record size follows the log format the configuration
states:
| Log format number | Record size | Boards |
|---|---|---|
| 1 | 8 bytes | TeleMetrum v1 |
| 6 | 16 bytes | EasyMini v1 and v3 |
| 7 | 16 bytes | TeleMetrum v2 and newer |
| 14 | 16 bytes | EasyMini v2 |
| 15 | 32 bytes | TeleMega v4 |
| 16 | 32 bytes | EasyMega v2 |
| 22 | 32 bytes | TeleMega v6 |
Format 6’s two boards come from the headers of public files, as no Altus Metrum document numbers the formats.
Any other number refuses the file, as misaligned bytes would read as a plausible flight. Firmware before 1.0 states no log format. A TeleMetrum v1’s file is then format 1, as the manual’s release notes for version 1.4 say AltosUI does (§H.43.2, p. 128). Any other product’s file is then refused. The survey’s report marks the files whose format came from the product. A file comes in one of two forms:
- JSON, as AltosUI writes today: the board’s configuration as a JSON object naming
log_formatandproduct, then the memory’s bytes in hexadecimal. Every record’s bytes sum, with 0x5A, to 0 modulo 256. That 0x5A is the seed of the line checksum of the TeleDongle, the radio receiver AltosUI listens through (AltOS Telemetry, v1.9.22.2, §4, p. 10). A record that fails refuses the file. All 29,437 records of the 7 JSON sample files pass. Erased memory, every byte 0xFF, ends the log and is counted in a note. Memory that ends partway through a record is refused. - Text, as older AltosUI and a serial console wrote. It has the configuration as the board
prints it (
Config version:,manufacturer altusmetrum.organd the rest), then one record a line. Each record’s checksum is left out. A last line with no line break, as a download cut short leaves, is left out with a note.
What the reader does with the records:
- The clock is the board’s tick, a hundredth of a second (AltOS Companion Port, v1.9.22.2,
Table 1). The tick turns over every 655.36 s, and each record goes on the turn nearest the latest
tick so far. The records aren’t written in time order. The pad’s samples, held in a ring buffer,
come after the flight record, and a GPS record carries its fix’s earlier tick. So the records are
sorted by tick, the file’s order kept among equal ticks. Time zero is the flight record’s tick,
the board’s detection of boost, as in AltosUI’s exports. So the pad’s samples have negative
times. A record more than 10 s from the latest tick ends the flight. That record and those after
it are counted in a note. One sample file ends with 14 records of another session, more than 10 s
later. Records repeated exactly, the same bytes at the same tick, are dropped and counted. Old
firmware wrote some. A file needs exactly one
Frecord. - Pressure and temperature, MS5607 (the barometer chip on every board but the TeleMetrum v1). The data sheet compensates the chip’s two counts, D1 and D2, by the six constants the configuration lists. It adds a second order below 20 °C (TE Connectivity, MS5607-02BA03, Figures 2 and 3, pp. 8–9). Each division by a power of 2 is a floor, as an arithmetic shift is. Truncating toward zero instead gives different pressures below 20 °C, and a unit test pins the floor. Second checks: the pad’s pressure must lie from 10 to 120 kPa and within 1% of the flight record’s. The pad’s temperature must lie within the chip’s operating range, −40 to 85 °C (p. 8). If any second check fails, the file is refused.
- Pressure, TeleMetrum v1: its MP3H6115A’s output is
Vout = Vs (0.009 P − 0.095), P in kPa (Freescale, MP3H6115A, rev. 5.1, p. 5). The converter of the CC1111, the board’s radio microcontroller, reads that output. The converter’s single-ended result reaches 2,047 at its reference and sits in the top bits of its 16-bit result. That makes 2,047 × 16 = 32,752 at full scale (TI, CC1110Fx/CC1111Fx, SWRS033H, §12.10.2.6, p. 143, and p. 144). That the converter’s reference is the sensor’s own supply is the board’s design, which no document states. The second checks: the pad’s pressure must lie from 10 to 120 kPa, or the file is refused. The climb check below must pass, or the counts are kept as written, since that pressure band alone rejects almost no count. The exports agree too. The sample files’ pressures step by 13.57 Pa (the survey’s report prints each file’s smallest step). That is about 1.13 m (3.7 ft) of height at sea level. - Acceleration, along the board’s axis. AltosUI calibrates the accelerometer antenna up, then
down (the manual, §12.6.20, p. 42). The configuration keeps its counts at +1 g and −1 g. The
record’s value is
(ground − count) / ((minus − plus) / 2) × 9.806 65m/s², withgroundthe flight record’s count on the pad. It is 0 at rest on the pad, positive forward along the flight path. A board mounted antenna down logs flipped counts and keeps a flipped calibration with the same span. So either reads alike, as long as both counts come from one pair. The configuration’s pad orientation is kept as a stated figure. The counts are kept as written when there is no calibration or the calibration is outside a 16-bit count’s range. They are also kept as written when there is no pressure in pascals to check against, or when the climb check below fails. - The climb check holds the pressure and the acceleration to each other on every board with an accelerometer. It looks at the first second after boost. The climb by the pressure is its pressure altitude in the U.S. Standard Atmosphere, 1976, which is ISO 2533’s below 32 km (20 mi). That climb must agree with the climb by the acceleration, integrated twice from rest on the pad. Their ratio must lie from 0.6 to 5/3. A ratio outside that band means neither unit is borne out. The same holds where the samples don’t cover that second or leave a gap in it of more than 0.1 s. So the acceleration stays in counts, and so does a TeleMetrum v1’s pressure, which has no other check. An MS5607 board’s pressure keeps its flight record’s check. On 11 of the 12 sample files with an accelerometer the ratio runs from 0.859 to 1.400. That is because the barometer reads the pressure at its ports, which the airflow past them can lower in the climb. The twelfth, an early TeleMetrum v1 flight with nothing beside it, reads 1.988. Its two sensors disagree by a factor of 2, and nothing in the file says which is wrong. So both stay in counts. The band catches swapped or misplaced fields and a wrong sign. It also catches a calibration off by 2 or more on a flight whose ratio is near 1. Without a calibration, an MS5607 board’s pressure gets the pad’s second checks alone. Then a TeleMetrum v1’s pressure stays in counts.
- A TeleMega v4.0 or v6.0’s or an EasyMega v2.0’s pyro battery, igniter, apogee and main senses are voltages across the pyro channels that show continuity. They become volts by the divider AltOS Telemetry gives a 15 V board (p. 3). The exports agree. The same page gives another divider for 30 V boards. A later TeleMega takes 30 V (the manual’s release notes for 1.9.20), so any other Mega’s senses are kept as written.
- GPS latitude and longitude are in ten-millionths of a degree and altitude in meters. That follows the telemetry’s GPS packet (AltOS Telemetry, Table 15, pp. 6–7). A record without a valid fix is a gap.
- States become events, named as AltosUI’s exports name the numbers: 2
pad, 3boost, 4fast, 5coast, 6drogue, 7main, 8landed. - Kept as written: the battery and other senses and the nine words of the IMU, the inertial unit’s accelerometer, gyroscope and magnetometer. Their factors fit the exports but have no source. The TeleMetrum v1’s chip temperature is also kept as written. That is because no document gives the conversion AltosUI uses, and the CC1111 data sheet’s constants don’t reproduce its export. The GPS’s other fields are kept as written too. Not read: the TeleMega v4’s IMU, and a Mega’s IMU when the flight record’s IMU fields are all zero.
The file holds no altitude. The record’s primary track is empty, as for the other
raw downloads, and every field is a channel. The configuration gives the serial
number and firmware. The F record gives the flight’s number. The record’s stated figures hold the
pad’s readings, the calibration, the pad orientation, the main deployment height and the apogee
delay.
A worked example, invented. A TeleMetrum v2’s flight record, flight 3, in the JSON form:
46 90 64 01 03 00 19 00 d0 7e 01 00 00 00 00 00
| Bytes | Field | Value |
|---|---|---|
46 | type | F, the flight record |
90 | checksum | 0x5A and all 16 bytes sum to 0x300, 0 modulo 256 |
6401 | tick, low byte first | 356; this record’s tick is time zero |
0300 | flight | 3 |
1900 | accelerometer on the pad | 25 counts |
d07e0100 | pressure on the pad | 98,000 Pa |
00000000 | unused |
The text form prints the same record as F 164 03 00 19 00 d0 7e 01 00 00 00 00 00. The tick is
one hexadecimal number, 164, while the other bytes keep their order. Take a calibration of
16,000 counts at +1 g and 16,800 at −1 g: 400 counts a g. With 16,010 on the pad, a count of
12,010 in the climb is (16,010 − 12,010) / 400 = 10 g, 98.07 m/s² above rest. The MS5607 data
sheet’s own example counts, D1 6,465,444 and D2 8,077,636, read 110,002 Pa at 20.00 °C, which a
test pins.
Checked. cargo xtask logs pairs each file with an AltosUI export in its folder of the same
serial number and flight. It reads the export by its column names and lines the two up by tick. At
each of the file’s samples, the export’s row at that hundredth must agree within half the export’s
print step. Each of the export’s rows must fall at a tick the file holds a sample at. With the
board’s .telem file of the same serial number, each pressure at a tick both hold must be equal.
cargo xtask logs --check fails on any file that differs. Of the 14 files:
| Compared | Files | Values | Worst difference (Pa, K, m/s², V) | Half the print step (Pa, K, m/s², V) |
|---|---|---|---|---|
| Pressure, against the export | 9 | 38,908 | 0.005 Pa | 0.005 Pa |
| Temperature, against the export | 7 | 31,673 | 0.05 K | 0.05 K |
| Acceleration, against the export | 7 | 33,095 | 0.005 m/s² | 0.005 m/s² |
| A Mega’s voltages, against the export | 3 | 9,968 | 0.005 V | 0.005 V |
| The export’s rows, at a tick the file holds | 9 | 47,547 | 0 without | |
| Pressure, against the telemetry | 2 | 231 | 0 Pa |
The MS5607 boards’ pressures match their exports exactly. The TeleMetrum v1’s pressures, a
conversion, match within half the export’s 0.01 Pa print step. One export is the damaged one the
survey’s report files as altos-csv-damaged. It zeroes the acceleration at the +1 g calibration
instead of the pad’s reading, so it differs from the file by one constant. The survey finds that
constant within half a step and counts the file apart. The same export counts its time from the
tick itself. Per file, by an anonymized id, the survey’s report prints each
count and each climb ratio.
Left out: the TeleMega v4’s IMU and the fields kept as written, until a source or a second check bears their units out. Also left out is any log format not listed above, which no sample holds (evidence row G4).
The ARTS2’s raw data
HPR Sim reads an Ozark Aerospace ARTS2’s flight from two files. One is the .odf file.
DataAnalyzer, the board’s PC software, saves a downloaded flight to it. The other is the sensors’
counts, their readings as whole numbers, as DataAnalyzer exports them to CSV. The ARTS2 User Manual (V1.0.0, Ozark Aerospace, 2007)
describes neither file. So the layout was worked out from the 3 sample flights that hold both. Each
has DataAnalyzer’s interpreted export of the same flight beside it (an ARTS2’s unit
system). The work used no other program’s source code. The .odf carries
the board’s calibration, so its acceleration and pressure are read in SI. The raw CSV carries none,
so its counts are kept as written.
More on the note’s items:
- Checked. Each export’s barometric altitude follows the pressure in order. The climb check is the climb over the first 2 s by the pressure, over the climb by the acceleration. It gives ratios of 0.754, 1.032 and 1.145, and the reader accepts 0.6 to 5/3.
- Assumed: the rate (evidence row G5). Where the file keeps the rate isn’t known. The reader refuses a file whose likeliest word for it isn’t the sample files’ 2. On the sample files, the climb check is sure to catch only a time step below 0.67 or above 1.38 times the true one.
- Assumed: the pressure (evidence row G5). Against its ±1.5 kPa error band, an AltOS board flown with each flight reads a pad pressure 0.42 to 1.08 kPa above the ARTS2’s.
The ARTS2 reads an Analog Devices ADXL78 accelerometer, set for ±50 g, and a Motorola MPXA4100A
pressure sensor. It reads them with its processor’s 10-bit converter, so each count runs from 0 to
1,023 (the manual, Appendix A, p. 16). The .odf is little-endian throughout. Its length must be
exactly its parts’:
| Offset (bytes) | Length (bytes) | What |
|---|---|---|
| 0 | 4 + 9 | the length 9, then Ozark.odf |
| 13 | 20 | five 32-bit words, the same in every sample file; not read |
| 33 | 256 | the board’s settings and calibration (below) |
| 289 | 4 | the number of records, n |
| 293 | 12 | three 32-bit words, each the memory’s size in records; equal, and at least n |
| 305 | 8 n | the records |
305 + 8 n | 124 | DataAnalyzer’s own settings; not read |
Of the settings block, the reader takes four things, each a 16-bit little-endian word. At its offset 8 is a word that is 2 in every sample file. That is the likeliest place for the recording rate, which the owner sets (pp. 6–7). A file where that word is anything else is refused, as its clock would be unknown. At 10 is the barometer’s count on the pad. This is the “Zero Altitude baseline” the board averages on entering flight mode (p. 17). At 12 is eight times the accelerometer’s count on the pad, its “Zero G baseline” (p. 16). So it keeps an eighth of a count. At 20, 22 and 24 are three sums of 64 accelerometer readings, taken when the board was calibrated “at +1g, −1g, and 0” (p. 16). These are the calibration sums. In every sample file the middle one is the reading on its side, midway between the two ends.
Each record is four 16-bit words, in the order of the raw CSV’s columns. They are the
accelerometer’s count (Acc(HI)), a byte of flags (Acc/Baro(LO)), the barometer’s count
(Baro(HI)) and the board’s state (State). The first record is the two baselines, not a sample:
the pad’s barometer count, and the accelerometer’s cut to a whole count. A file whose first record
isn’t so is refused, as its bytes would be laid out otherwise than the sample files’. DataAnalyzer
exports that record as the flight’s first row, at time 0, and so does the reader.
What the reader does with the records:
-
The clock. The records are 0.02 s apart, 50 a second, from the first. That is the rate DataAnalyzer gives every sample file in both its exports. Where the file keeps the rate isn’t known. The sample files are all at one rate, so no byte can be shown to change with it. The reader refuses a file whose settings word at 8 isn’t 2. Otherwise, the climb check below bounds the clock.
-
Acceleration, along the board’s axis, toward its forward end, from the file’s own calibration. The two end sums are 2 g apart. So a g is a 128th of their difference, in counts: 64 readings in each sum, over 2 g. The pad’s reading is taken out, as DataAnalyzer’s export takes it out. So the rocket at rest on the pad reads zero, gravity with it. With the count, the pad’s baseline and the counts a g, the acceleration is
The pad sets the sign. Standing nose up, the board reads +1 g along its axis. So the pad’s reading lies near one end sum. A count moving further toward that end is an acceleration forward, positive.
The ADXL78’s data sheet must bear the calibration out (ADXL78, Rev. B, Analog Devices, 2010, p. 3, for ±50 g), or the file is refused. A g must be from 36.1 to 39.9 mV, 7.39 to 8.17 counts on the board’s 5 V supply. The side’s reading must lie within 150 mV, 30.72 counts, of half the supply and between the two ends. The pad’s reading must be nearer an end than the side’s.
-
Pressure, by the MPX4100A’s nominal transfer function, the first line below (MPX4100A, Rev 9, Freescale, 2009, p. 5). Here is the sensor’s output, its supply and in kPa. The converter reads the output against the supply as its full scale, so is . That gives the second line:
One count is 92.2 Pa, about 7.7 m (25 ft) of height near sea level. The pad’s pressure must lie in the sensor’s rated 20 to 105 kPa (p. 3), or the file is refused. The sensor’s error band is ±1.5 kPa over that range from 0 to 85 °C (p. 6).
-
The climb check holds the clock and both units to each other, as for AltOS’s
.eeprom. Over the first 2 s from the first record, the climb by the pressure must agree with the climb by the acceleration. The acceleration is integrated twice from rest. The pressure climb is taken as its pressure altitude in the U.S. Standard Atmosphere, 1976. Their ratio must lie from 0.6 to 5/3. The pressure at the window’s end is the median of the 5 records within 0.04 s of it.The window is twice AltOS’s 1 s because this barometer is coarse. Over 1 s, measured that way, one sample flight climbs only two counts. Over 2 s each climbs at least 10 counts.
The check bounds the clock only loosely. The climb by the acceleration goes as the square of the time step. So with a flight’s ratio on its true clock, a step times the true one passes for from to . That is 0.67 to 1.12 for the sample file of the least ratio and 0.83 to 1.38 for the greatest’s.
-
A file that fails the climb check is refused. AltOS’s reader keeps such a file’s counts as written. This reader can’t, because a count kept as written still needs a clock. Nothing else in the file bears a clock out.
-
Kept as written: the flags byte and the state. Bits 3 and 2 of the flags byte are the barometer count’s low two bits in every record of every sample file. A record where they aren’t is refused. That is a check that the words are where the reader takes them. The other bits follow the flight, but no document names them. The state steps through 0, 1, 2, 3, 5, 6 and 7 in each flight, in order. No document names those either, so no event is taken from it.
The file holds no altitude. The record’s primary track is empty, as for the other raw downloads, and every word is a channel. The record’s stated figures hold the two baselines and the three calibration sums.
A worked example, from the invented file the crate’s test
tests/arts2_raw.rs
reads. Its settings block holds a pad barometer count of 800 and an accelerometer word of 4,100
(512.5 counts). The calibration sums are 31,744 (64 × 496), 32,250 and 32,768 (64 × 512). The ends
differ by 1,024, so a g is 1,024 / 128 = 8 counts, inside the data sheet’s 7.39 to 8.17. The side’s
reading, 32,250 / 64 = 503.9, lies between the ends and within 30.72 of 512. The pad’s 512.5 lies
near the 512 end, so the acceleration is positive as the count rises. A count of 576 in the boost is
(576 − 512.5) / 8 = 7.94 g, 77.84 m/s² above rest. The pad’s barometer count reads (800 / 1,024 +
0.1518) / 0.010 59 = 88.107 kPa, inside the sensor’s 20 to 105 kPa.
The raw CSV is DataAnalyzer’s raw export of the same records. Its header names the time,
MET (mission elapsed time, in seconds), then the record’s four words. A row follows for each
record, holding its time and its four words as whole numbers:
MET,Acc(HI),Acc/Baro(LO),Baro(HI),State
0.000,512,0,800,64
0.020,576,0,800,0
It holds no calibration, only the first record’s whole-count baselines. So no column is converted.
The two counts and the flags byte are kept as written, the state as a number, and MET,
DataAnalyzer’s clock, as the time. Every row must hold five numbers. Its four words must be whole
and in range. Its time must be after the row before’s. Its flags byte must hold the barometer’s low
bits. A file where a row fails any of these is refused, naming the line. For values in units, read
the flight’s .odf.
Checked. cargo xtask logs pairs each .odf with the files of its flight in its folder, and
cargo xtask logs --check fails on a file that differs. A raw CSV must hold the .odf’s records
word for word, 0.02 s apart.
DataAnalyzer’s interpreted export holds four columns beside MET
(its reader):
Acc, the acceleration along the board’s axis, with gravity taken out.Vel, the speed, DataAnalyzer’s integral ofAcc.iAlt, the altitude, the integral ofVel.pAlt, the barometric altitude above the pad.
Only Acc and pAlt are checked. HPR Sim’s reader for the export turns Acc into m/s², from g
or from the file’s speed unit per second. The check divides its difference from the .odf’s
acceleration by a count’s worth, . Here is standard gravity, 9.806 65 m/s², and
the counts a g. On every record after the first, that must be within half a count.
Both Acc and pAlt must read zero at the export’s first row, which holds the pad’s baselines,
and at any row after the last record.
pAlt is compared by order only, since one export works it by a formula of its own (the table
below). Each row’s pAlt is paired with the .odf’s pressure one record earlier, as the export’s
altitude lags the barometer by one record. Then each pressure meets one value of pAlt, as an
altitude worked from the pressure must. Paired with the same record, or with two records earlier,
many pressures would meet two values.
pAlt must also be zero at the pad’s pressure and above, and rise as the pressure falls below
that. No row’s pAlt may be missing. For the 3 .odf files, the results are:
| Compared | Files | Values | Result |
|---|---|---|---|
| Records, against the raw CSV | 3 | 48,614 | every word equal |
Acc, against the interpreted export | 3 | 48,611 | within 0.080 of a count |
pAlt’s order, against the pressure | 3 | 48,611 | no pressure meeting two values; none out of order; no gap |
| The climb check | 3 | ratios 0.754, 1.032 and 1.145 |
Some figures are reported, not checked. The first is how far pAlt lies from the standard
atmosphere’s pressure altitude, worked from the .odf’s pressure. The others compare the ARTS2’s
pressure with an AltOS board’s, flown beside it on each flight. The flights are numbered in the
order of the survey’s report, which lists them under anonymized ids with the
same climb ratios:
| Flight number | Climb ratio | pAlt from the standard, m | Pad less AltOS, kPa | Least less AltOS, kPa |
|---|---|---|---|---|
| 1 | 0.754 | 151.2 | −1.08 | −0.48 |
| 2 | 1.032 | 3.1 | −0.42 | +0.02 |
| 3 | 1.145 | 3.3 | −0.44 | +0.11 |
Two exports’ pAlt lies within 3.3 m (11 ft) of the standard atmosphere. Flight 1’s departs by up
to 151.2 m (496 ft), worked by some other formula.
The ARTS2’s pad pressure reads 0.42 to 1.08 kPa below the AltOS board’s. Near sea level that is about 35 to 90 m (115 to 295 ft) of height, and more at a higher site. Its least pressure reads from 0.48 kPa below, about 40 m (131 ft), to 0.11 kPa above, about 9 m (30 ft). All fall inside the MPX4100A’s ±1.5 kPa error band.
Flight 1 stands out three ways. It has the largest pad difference, the 151.2 m (496 ft) departure of
pAlt and the least climb ratio.
ADR-266, the ARTS2’s raw data gives the evidence for the layout.
Left out: the flags byte’s bits beyond the barometer’s two, the state codes’ meanings, the deployment settings and the rest of the settings block. Also left out is where the file keeps its rate. The climb check stands in for that.
The AltiMAX’s .ALS
An AltiMAX altimeter with a memory card writes each flight to it as an .als file (AltiMAX G2
Handbuch, Louis Schreyer, 2010, p. 12). The maker’s PC software opens and exports that file (the
AltiMAX’s Excel export). hpr_flightdata::altimax_als reads the file,
and import::read recognizes it like any log. No document describes the bytes. The layout was
worked out from the one sample file against the Excel export of the same flight. Every value the
file stores is the export’s.
The file is a header of 32 bytes. Then comes one record of 22 bytes for each row of the export. Then
comes a trailer that isn’t read. The header holds the zero pressure, the pressure the export
measures every height from, the apogee’s pressure, and the count of records. A record holds the
filtered and the raw pressure in pascals. It holds the acceleration in counts of 0.01 g along an
axis that points down the rocket. It also holds an event code and the count of one of five voltage
channels, the channels taking turns. A bit of a record’s first byte says whether it was stored 5 ms
or 25 ms after the record before. Those are the 200 and 40 samples a second of the maker’s table
(AltiMAX G4 Manual, Rocketronics, 2021, p. 10). The clock is the running sum, as the export’s
TIME is. The API reference gives every byte.
What the record holds. Each value is a channel, named as the export names its column. PRESS FILTER and PRESS RAW are in pascals. ACCEL is in m/s², each count 0.0981 m/s², the export’s own
factor, so at rest it reads about −1 g. EVENT and VOLT. CHANNEL are numbers. Each voltage
channel’s counts are kept as written, VOLTAGE count (channel 1) to (channel 5). A record’s event
code is an event, named as the export names it (BARO-LIFTOFF, APOGEE PRESSURE, LAND and 13
more). For a code the sample doesn’t show, it is event N. The zero and apogee pressures are
figures. The file holds no height, so the record’s primary track is empty and its
channels hold everything. A height is the standard
atmosphere’s height of a pressure, less that of the zero
pressure. For example, take a zero pressure of 98,000 Pa and a filtered pressure of 97,000 Pa. The
height is 44,330.77 × (1 − (97,000 / 101,325)^0.190263) − 280.5 = 366.4 − 280.5 = 85.9 m (282 ft)
above the pad.
Checked. cargo xtask logs reads the .ALS and the Excel export of the same flight beside it.
cargo xtask logs --check fails if any of these comparisons does. The acceleration, voltages and
clock are written the export’s way. That uses the two rules after the table, which were fitted to
this file:
| Compared, against the export | Values | Result |
|---|---|---|
| Records, against its rows | 25,334 | one a row |
| Both pressures, the event code and the voltage channel’s number, as stored | 101,336 | every one equal |
| The acceleration | 25,334 | every one equal |
| The voltages, by the export’s own factors | 25,334 | every one equal |
| The clock, 5 ms or 25 ms a record summed in 64-bit floats | 25,334 | every one equal |
| The speed before apogee, the counts summed from liftoff | 8,373 | every one equal |
| The events | 21 | the same names, in the same order |
| Each height, filtered (25,334) and raw (25,334), against the standard atmosphere from the zero pressure | 50,668 | within 8.7 mm (0.34 in); the check allows 41.9 mm (1.65 in), the height of half a pascal at the zero pressure |
The survey’s report prints these under the files’ anonymized ids.
How the export writes a number. Two rules, fitted to this one file, reproduce the export’s numbers. Converting is a model of how the export turns a number into 15 digits. Multiplying is how it turns a voltage channel’s count into volts. Neither changes what the reader returns, the values the file stores. The rules only write those values as the export does, so the check can compare them. The software holds each value as a 64-bit float, a double. Its significant part (the significand) holds 53 bits, good to about 16 significant digits. The export keeps 15, as Excel does.
Converting. The export doesn’t round a value to 15 digits once. Its numbers match arithmetic in 80-bit floating point. That is the format of an x86 processor’s older floating-point unit. Its significant part holds 64 bits. The model is fitted to this file, not taken from the software. One row of the 25,334 is what tells it from plainer rules (below). In three steps, the model:
- guesses the value’s power of ten from its power of two: the power of two’s exponent times log₁₀ 2, rounded down. The guess is one too low from each power of ten up to the next power of two. That holds from 10 to under 16, 100 to under 128 and 1,000 to under 1,024, for example. It also holds from 0.001 to under 2⁻⁹, 0.001 953 125;
- scales the value by that power of ten to 18 digits. It rounds that to 64 bits, the nearest number whose significant part fits 64 bits. Where the guess was low, that makes 19 digits. The model then divides them by 10, rounded to 64 bits again;
- rounds the result to a whole number, half to even (an exact half goes to the even neighbor: …498.5 to …498, …499.5 to …500). It then rounds that to 15 digits, upward when exactly halfway.
A clock summed from 5 ms steps in doubles can land just under halfway between two 15-digit values. It can land close enough that the 18 digits land on halfway, which then rounds up. For example, 347 steps make 1.734 999 999 999 984 998 7 s. The model writes that 1.734 999 999 999 99. Rounding once gives 1.734 999 999 999 98.
The file’s clock at 122.005 s is where the guess shows. Its value is 122.005 000 000 015 499 495 s. Its power of two is 2⁶, so the guess is 10¹, where 10² is right. Each line of this table is one step, as a whole number at the scale it works at:
| Step | With the power of ten exact, 10² | With the guess, 10¹ |
|---|---|---|
| Scaled | 122 005 000 000 015 499.495, 18 digits | 1 220 050 000 000 154 994.95, 19 digits |
| Rounded to 64 bits | …015 499.492 | …154 995 |
| Divided by 10 | not needed | …015 499.5 |
| Rounded to a whole number, half to even | …015 499 | …015 500 |
| To 15 digits, half up | 122.005 000 000 015 | 122.005 000 000 016, as the export writes it |
The other choices in the model can’t change a value, so no file can test them. Half up instead of half to even in step 3 gives the same 15 digits, as …499.5 goes to …500 either way. The second rounding to 64 bits moves a value too little to cross a half.
Take the power of ten as known exactly. Values are rounded first to each number of digits, then half up to 15. The table below counts how many of the 25,334 clock values then differ from the export’s. Rounded once, 11 differ, the 122.005 s row among them. Rounded first to 18 digits, only that row differs. Under the model, that row alone needs the guess and the first rounding to 64 bits. A running sum one double higher at that row in the software would explain it under the plainer 18-digit rule. The file can’t rule that out.
| Rounded first to (digits) | Clock values that differ |
|---|---|
| 15 (once) | 11 |
| 16 | 1,245 |
| 17 | 109 |
| 18 | 1 |
| 19 | 11 |
| 20 | 11 |
The model divides by 10 for 2,327 clock values, 3,265 accelerations and 5,066 voltages. Every one of the 25,334 clock values, accelerations and voltages matches the export.
Multiplying. The volts are the double nearest the count times the factor, computed exactly and then rounded once. Multiplying the count by the factor already rounded to a double puts 31 voltages a unit off in the 15th digit.
The survey’s report prints each count. By doubles counts the voltages multiplied by the rounded factor. Divided by 10 counts the clock values, accelerations and voltages the guess put at 19 digits. First rounded to 15–20 digits is the table above.
Left out. The voltages stay counts. The export turns them into volts by one factor for channels 1 and 5 and another for 2 to 4. Those are 0.00314278884 and 0.00266754240 V a count, rounded here. These were found by dividing the export’s volts by its counts. They equal 3.218 215 77 V ÷ 1,024 and 5.463 126 83 V ÷ 2,048 exactly. The multiplying rule uses that reading, which is this project’s own. No document states either factor, nor which channel is which. The export’s speed after apogee, 16,961 rows, is worked out by the software from the pressure, not stored. It isn’t compared. The header’s other bytes and the trailer aren’t read. A record’s last 8 bytes are zero in every sample record. They are held to zero, and a file where they aren’t is refused, naming the byte. So is one with a record past the header’s count. A flight of more than 65,536 records, more than its 16 bits count, would have one. One sample, from one altimeter, is all the layout rests on.
The AIM’s .xtra and raw dump
The Entacore AIM software downloads an AIM XTRA flight computer’s memory and saves each flight as an
.xtra file. The software exports from that file the CSV HPR Sim also reads. The AIM XTRA’s manual
names both files but describes neither (AIM XTRA/BASE v4.x.x Manual, Entacore, 2 February 2025, p.
38). The sample logs hold one flight’s three files. They are the raw dump of the memory, the .xtra
the software made of it, and an earlier copy of that .xtra, cut short.
hpr_flightdata::entacore_raw reads both layouts. import::read takes an .xtra file, and a dump
that holds one recording. The sample’s holds ten: nine whose pressure shows no flight, and then the
flight. import::read refuses a dump of several, naming the byte where the second starts.
entacore_raw::read_dump reads each as a record of its own. import::read_one reads the one
chosen, counted from 0, as hpr analyze --recording N and Python’s FlightLog.read(path, recording=N) do. With none chosen, they read a dump of one recording and refuse one of several,
saying how many it holds (A file of several records).
A dump is the memory’s recordings end to end, then erased memory, bytes of 0xFF. A recording opens
with the byte 0x13 and 101 bytes that aren’t read. After that, a byte from 0x80 to 0xFE adds
its low 7 bits to a clock counted in the computer’s ticks. Any other byte is a record’s type, its
fields following, big-endian (the most significant byte first). Each of the 16 types is one group of
readings, such as the barometer’s or the status’s, at its own rate. The manual gives these rates (p.
2):
- the barometer every 20 ms;
- the accelerometers and gyroscope every 10 ms;
- the magnetometer every 100 ms;
- the temperature every 500 ms;
- the GPS’s position every 200 ms and its time every 500 ms.
The .xtra is an archive in the binary format of Boost, a C++ library. It holds the same samples
converted, one record each with its time in seconds. The API
reference gives every type and field.
What the record holds. Each group’s fields are channels on the group’s own clock, named as the CSV export names the same columns:
acceleration,lat. X accel.andlat. Y accel.in m/s², from the g the computer records;Gyro XtoGyro Zin degrees a second;pressurein pascals;temperaturein kelvin;battery 1 voltage,battery 2 voltageandA VoltagetoD Voltagein volts;lat,long,GPS MSL,SVsand the GPS’s time;- the status,
stateand the four outputs’onandcontflags.
The magnetometer and the attitude quaternion are kept as written. Each change of state is an
event, state 1 to state 3. So is each output’s firing, such as C on. The values are converted
as the software converts them, in 32-bit floats (single precision, about 7 significant digits), so
the two readers’ channels are equal. A raw battery record 04 80 00, for example, holds the count
2,048 in its top 12 bits. The count is then multiplied by 3.3 V × 133/33, a factor of 13.299 999 2 V
taken in 32-bit floats, and divided by 4,096. The result reads 6.649 999 6 V, one step of a 32-bit
float below 6.65 V, as the software writes it to the .xtra. Neither file holds an altitude, so the
record’s primary track is empty, as for the .ALS.
The clock. The dump’s ticks are read as milliseconds, as the software reads them. The .xtra’s
times are the software’s own sum of them in 32-bit floats. That sum falls behind as it grows. In the
sample, it is behind by 2.40 s by the end of the recording, and by 0.9 % of the climb’s time.
Neither set of times is GPS time. Against the GPS’s time of week, recorded beside them, a tick is
1.009 ms of the GPS’s clock over the flight. On the pad it is 1.021 ms. So the dump’s times run 0.9
% short in flight and 2.1 % on the pad. The .xtra’s times are behind the ticks as well. They are
about 1.8 % short over the climb (0.9910 of the ticks’ time, each tick 1.0087 ms: 0.982 of the
GPS’s). The reader doesn’t correct either set of times. One flight can’t tell whether that is this
computer’s clock or every AIM’s.
Checked. cargo xtask logs reads the three files of the flight. cargo xtask logs --check
fails if any of these comparisons does:
| Compared | Values | Result |
|---|---|---|
The .xtra’s channels, against the dump’s flight recording | 435,075 | every one equal, bit for bit |
The .xtra’s times, against the dump’s ticks summed in 32-bit floats a tick byte at a time | 224,643 | every one equal |
| The dump reader’s times, against the ticks walked apart from it | 224,644 | every one equal |
The short copy, against the whole .xtra’s first samples | 814,206 | every value and time equal; its bytes are the whole one’s first |
| The pad: the three accelerometers’ medians over the last 10 s before liftoff, as one magnitude | 0.965 g, inside 0.85 to 1.15 | |
| The time from liftoff to the least pressure, over √(2h/g), h the standard atmosphere’s climb | 1.064, inside 0.5 to 2 |
The dump holds one sample past the .xtra’s, which the software leaves out. On the pad the
accelerometer reads 0.965 g, 0.961 along the rocket alone. The maker’s .xtra reads the same. On
this flight the sensor reads about 3.5 % low. The check allows 15 %, the band for an accelerometer
at rest that the AltiMAX export set. Against that band, the axial
reading in another unit or at another of the sensor’s ranges is 2 or more times off. The sideways
readings are held to the .xtra’s values, bit for bit. Liftoff, for these checks, is the first
reading above 1.5 g in the run that holds state 1. That state is the computer’s launch detect,
which came 1.14 s after liftoff on the sample flight.
Left out. A recording’s 101 opening bytes; what state’s numbers mean; the magnetometer’s unit;
and which battery is the computer’s and which the charges’. Each byte whose meaning the sample
doesn’t show is held to the one value it has there. A file where it differs is refused, naming the
byte. A type or class the sample doesn’t hold is refused too, as its length is unknown. But among a
dump’s first 1,000 records, or as an .xtra’s first, such a type or class leaves the file
unrecognized instead. One flight, from one computer, is all the layouts rest on.
How it was checked
Each layout’s reader is also fed cut, changed and arbitrary bytes, failing on a panic or a hang: Damaged files.
cargo xtask logs, a command of the project’s own build tool, reads every sample log the project
holds, each distinct file once. The sample logs come from:
- the private collection’s catalog of flight logs;
- the public fixtures and samples of Debrief;
- AerospaceNU’s published flight logs.
The command leaves out a cache of downloads whose flights’ logs the collection already catalogs. It
also leaves out the data folder of RocketPy’s repository, tables RocketPy processed. The teams’ logs
from that folder that the collection catalogs are read like any other. It writes what came of each
to
validation/reports/log-import.md.
That report holds:
- per layout, how many files were read and how many refused and why;
- how many files’ readers decided each unit their headers leave out, and how;
- how each raw download compares with its maker’s export (above);
- how each Featherweight summary compares with the files of samples beside it (above);
- how AltOS’s telemetry compares with AltosUI’s export beside it, and its board’s estimates with each other (above);
- how each AltOS
.eepromfile compares with the export and the telemetry beside it (above); - how each ARTS2
.odfcompares with the raw CSV and the interpreted export beside it (above); - how each RTx
.rtxcompares with the CSV, text and KML exports beside it (above); - how each table read by its header had its columns decided, as counts (above);
- per file, an anonymized id with a digest, a hash, of the record read from it. The id is the start of a hash of the file, which says nothing of its contents.
The files inside the zip archives among them are unpacked and counted too, each once. Of the 29 in the 8 archives, 19 are in no other source (zip archives). The report also covers:
- each Excel workbook’s sheets, by the layout each reads as (Excel workbooks);
- each table read by a mapping its publisher states (above);
- the range of the Eggtimer files’ filtered-altitude multiplier (above);
- each file of binary records, against its team’s table (above);
- each Blue Raven USB download, against the survey’s own decoding of it (above);
- each Teensy logger’s file, against the survey’s decoding and its physical checks (above);
- each file of radio packets, against the survey’s decoding, and each received or exported packet, against the onboard log’s (above);
- each FIP sheet, against the
.FIPabeside it (above); - the AltiMAX export, against the survey’s own decoding of its stream and its physical checks (above);
- each MARSA download, AltOS telemetry table, table cut from an AltOS export and re-saved AltOS export. Each is held against the survey’s own decoding and the checks of its units (above);
- each table a mapping holds to physics, against its checks (above);
- the AltiMAX
.ALS, against the export beside it (above); - the AIM’s
.xtrafiles and raw dump, against each other (above).
Of the 1,122 files it holds today, 1,052 are read. The counting rules are:
- the 8 archives count as read when they unpack;
- the 16 workbooks of their own layout count as read when a sheet of each reads;
- the 2 FIP sheets count as read when they read under their stated headers and match their
.FIPa; - the AltiMAX
.xlscounts as read when it reads and holds to its checks; - the
.ALSand the AIM’s files count as read when they hold to theirs.
Of the other 70, 67 aren’t logs and 3 are damaged (below). No file of a layout HPR Sim reads is left
unread. Since M7.1c23, the last of the importers that
ADR-274
plans, cargo xtask logs --check fails on one. Since M7.2b, readings on every
logger, it also takes the readings from every record it reads.
It counts each reading given and withheld, by family and by reason, with a case for each reason
(Flight-log readings).
A file the collection’s catalog files under a layout it doesn’t have is moved, by id, with the reason printed. One is a spreadsheet’s re-save of an AltOS export, its header edited, held to AltOS’s reader (above). Another is an AltOS export whose header line is damaged, two column names run together. No reader can line up that line with its rows, and the file is refused. A third, a KML file, is a map of a flight made in a map program. Its predicted tracks have the pad and landing spot pinned. The file is read but counted apart as not a log.
And 62 files the catalog files as generic CSV, by their extension, are in these layouts and held to those readers:
- AltimeterCloud’s layout (10);
- Entacore AIM’s (15);
- a Fluctus’s (6);
- an ARTS2’s interpreted data (4);
- the phone app’s
launchCSV (27).
The same filing holds more:
- 2 more are Eggtimer downloads saved with semicolons, one held to the Eggtimer’s reader and one, its decimal points taken out, counted as damaged (above);
- 6 are tables whose publisher states their mapping (above);
- one is an RRC3 export counted as damaged (above);
- 4 are AltOS’s: its telemetry decoded to a table, a table cut from an export and 2 whole exports, each held to its reader (above);
- 12 are tables a mapping holds to physics (above);
- 6 aren’t logs (below).
The 2 files the catalog files as XML, for their <…> lines, are MARSA downloads, held to their
reader (above). Of the 4 files it files as binary, 2 are a team’s binary
records, read by a stated layout (above). The other 2 are the
AltiMAX’s .ALS and the AIM’s raw dump, held to their readers (above,
above). Of the 3 RTF files the catalog files as not a log, by their
extension, one is an Eggtimer’s download, held to its reader. Two are exports of radio packets, held
to the packets’ reader (above). Sixteen spreadsheets are
workbooks of flights’ logs, held to the workbook reader. Three files filed as text are console
captures. Two filed as binary are files of records. Each of these is read by the layout stated for
it (above). Two more filed as text are a Blue Raven’s USB
downloads, held to their reader (above). Eight more are a course’s
Teensy logger’s, held to theirs (above). Two are radio packets, the
onboard log and the receiver’s text, held to the packets’ reader
(above). Five files filed as generic CSV or text are
PerfectFlite’s exports: four with no header row and one that names its temperature Temp.
A Blue Raven high-rate file with no date is held to the Blue Raven’s reader. Its low-rate partner was edited by a person in a spreadsheet (a column with no name, two columns named in words the app doesn’t write). It was counted as damaged until M7.1c13. It is now read as a table by its header, as are 30 other files filed as generic CSV. Three more are an ARTS2’s raw CSV, held to its reader. Nine are mDACS’s exports of an RTx’s fixes, five CSV and four text, held to their reader. Six more filed as text, and a ground station’s conversion of a SillyGoose flight, are tables a mapping holds to physics (above). So is one workbook. The conversion has its columns in the order of the board’s log, with its settings under no header.
Some files aren’t flight logs, and are counted apart as not logs, as pictures and maps are. By id,
four are spreadsheets of a team’s checklist for preparing a flight, its steps and no measurement.
Nine are spreadsheets of a Blue Raven’s deployment settings, with a Hardware_Channel: row naming
its outputs. Three are spreadsheets of a flyer’s summary of flights, a few rows of figures by flight
or by launch and no samples. By family, six are Debrief’s made-up sample flights. Their first row
says each isn’t a recording of anything. Twelve are text files a flyer’s own program wrote from a
Blue Raven’s low-rate file, titled as that file’s events. By family too, since
M7.1c17, one is a text file the same flyer’s program wrote
from a Blue Raven’s summary CSV beside it. It has the summary’s rows as cells between |. It is a
copy, every cell equal to the CSV’s, and the CSV is read.
By id, since M7.1c7, two more are those events files. Three are descriptions of a rocket written for a flyer’s or a team’s own program. Three are one-row files of a team flight computer’s saved state (a boot count, gyro biases, the pressure before boost). One is an OpenRocket simulation’s export, a simulation and not a flight. Inside the archives, by id, there are three more events files and one more description of a rocket. There are also a Blue Raven’s settings as a spreadsheet and as CSV, and a wind profile, altitude against wind speed and direction.
By id, since M7.1c22, these are not logs either:
- a flight computer’s housekeeping (its processor, memory, disk and network counters);
- a battery pack’s housekeeping (its cells’ voltages, temperatures and current);
- two GPS tracks’ coordinates copied from their maps with no clock, the tracker’s own file of the same fixes beside each;
- three tables a program worked out from a log:
- a Kalman filter’s state in a workbook, whose altitude reaches 169 km (105 mi);
- an inertial unit’s recording turned into the rocket’s frame with gravity taken out;
- a flyer’s rebuild of an altimeter’s log, rows marked as made up, the altimeter’s own file beside it read.
The collection is other people’s data. Debrief’s fixtures come from flights shared on terms nobody recorded. AerospaceNU’s are published under the GPL. So no file and no value read from any of them is committed. The digest pins each reading instead, as a snapshot (a stored copy of a test’s output) would. The check fails if a reader’s output changes or a file of these layouts stops reading. Invented files in the crate’s tests are read in CI and pinned whole by snapshots.
PerfectFlite .pf2 flight logs
See how HPR Sim reads the flight log a PerfectFlite altimeter saves, a .pf2 file of barometric
heights and speeds, and what it refuses.
A .pf2 file is the flight log a PerfectFlite altimeter’s software saves: the Pnut’s, the
StratoLogger’s and the StratoLoggerCF’s alike. It is plain text: a few lines about the altimeter
and the flight, then one row per sample, about 20 a second. Each row holds the time, altitude,
speed, temperature and battery voltage. A PerfectFlite has a barometer and no accelerometer, so every
height and speed in it comes from air pressure.
To read a flight from one, run hpr analyze on it, or see
Flight-log readings for what is read and how.
This page is the reference for HPR Sim’s reader. PerfectFlite publishes no specification of the
format, so everything here was learned from exported files. Debrief, the project owner’s earlier
flight-log analyzer, learned it that way, and this reader follows Debrief’s. Every .pf2 among
the project’s sample logs is read: 175 files. Of them, 101 are a StratoLoggerCF’s, 39 a Pnut’s
and 35 a StratoLogger (SL100)’s (the survey).
Code: hpr_flightdata::perfectflite
(API reference), written for
M4.2d, the milestone that added hpr analyze.
The layout
PerfectFlite Pnut
Firmware: 1.0
Software: 1.1
Serial Number: 0
Apogee: 1281' AGL
Ground Elevation: 600' MSL
NumSamps: 984
Flight Number: 1
Comments: invented for hpr-sim's tests; no real flight's data
Data: (Time, Altitude, Velocity, Temperature (F), Voltage)
0.00, 0, 0, 70.00, 4.20
0.05, 0, 0, 70.00, 4.20
0.10, 0, 0, 70.00, 4.20
0.15, 0, 0
That is the head of the invented log the tests and the command-line guide read.
| part | what HPR Sim reads |
|---|---|
| first line | the altimeter’s name. It must contain PerfectFlite, or the file is refused |
Apogee: | the apogee the altimeter worked out, in feet above the pad, marked ', ft or feet. A value that isn’t a plain number of feet, such as PWRLOSS (the power failed in flight) or 1,009', is noted, not read |
Ground Elevation: | the pad’s height above sea level, in feet, marked the same way |
NumSamps: | the sample count; if the rows differ, a note says so |
Serial Number:, Firmware:, Flight Number: | kept as the file states them |
Data: | the columns, in order |
| the rows | numbers separated by commas, one row per sample |
Other Key: value lines, such as Software: and Comments:, are skipped.
The columns and their units:
| column | unit in the file | HPR Sim’s unit |
|---|---|---|
Time | seconds from the altimeter’s start | s |
Altitude | feet above the altimeter’s reading on the pad | m |
Velocity | feet per second, up; the altimeter works it out from its own altitude | m/s |
Temperature (F) | degrees Fahrenheit, inside the electronics bay | K |
Voltage | volts, the battery | V |
A row may stop after the speed: the temperature and voltage are logged less often. A missing
cell is a gap, stored as NaN. A foot is 0.3048 m (1.000 ft) exactly. Lines may end in \r\n, \n or a
lone \r, and a leading byte-order mark is skipped. hpr analyze
reads bytes that aren’t UTF-8, such as a Latin-1 degree sign in a comment, as replacement
characters, so the numbers still read.
What is refused, and what is noted
A file is refused, with its line number, when:
- a row holds something that isn’t a finite number, or more values than there are columns;
- a time doesn’t come after the one before it;
- a row stops before its time or its altitude;
- the
Data:line names no time or no altitude column, or names one twice; - a stated height is marked with another unit, such as
m: the reader knows only feet, and won’t read meters as feet; - a line after the rows began isn’t a row.
These are noted and read around. hpr analyze prints each note as a
note: line, and its JSON output lists them in log.notes. A file with many unreadable lines
keeps the first 20 notes about them and counts the rest in one more:
- no
Data:line: the columns are taken to be the five above, in that order, as Debrief takes them; - a column the reader doesn’t know: kept as written, among the record’s channels, marked unrecognized (the record);
- a line in the header that isn’t
Key: value: skipped; - a sample count that differs from
NumSamps:; - a stated apogee or ground elevation that can’t be read as feet, such as
PWRLOSS,1,009', or1009 AGLwith no unit.
Where this comes from
Debrief’s lib/parsers/perfectflite.ts (MIT, the project owner’s own) reads the same layout. It
was written from exported files and cites no document. HPR Sim’s reader differs in these ways:
- Debrief assumes the column order; HPR Sim takes it from the
Data:line when there is one. - Debrief skips any line that isn’t a row; HPR Sim refuses one after the rows have begun.
- Debrief reads a stated apogee only when it is marked
'. HPR Sim also acceptsftandfeet, and refuses a height marked with another unit.
The public Pnut log marks its apogee with ', as 1009' AGL, and its rows agree with that
figure (Flight-log readings).
Ghost files
A ghost file is one flight’s path, from its logs, on one clock in a frame at the pad, as hpr analyze --ghost writes it.
It holds the path for a viewer to replay: as JSON for your own program, as CZML for Cesium (a free 3D globe), or as glTF for any 3D tool. This page covers what each holds, where each number comes from and what the file assumes when a log can’t say. It is for anyone who wants to see a flight in 3D or load its path into a program. The app’s replay will read it too. It is called a ghost for the simulated flight that will fly beside the real one. Today it holds logs only (#1091).
Writing one
hpr analyze flight.csv \
--ghost flight.czml
hpr analyze telemetrum.csv \
telemega.csv \
--ghost flight.json \
--ghost flight.gltf
hpr analyze flight.csv \
--ghost flight.czml \
--pad 39.39,-8.29,120
The file’s extension picks its format: .json, .czml or .gltf. Give --ghost again for another
format. --pad states the
pad’s latitude and longitude in degrees, then its height in meters above the WGS 84 ellipsoid if you
know it. It overrides what the log’s fixes say. Each option of hpr analyze that reads a log, such as --mapping, works with it.
What a track holds
Each log gives one track, named by its file’s name. Where logs share a file name, each of them
takes as many of the folders above it as tell it apart from the others, such as d1/x.csv and
d2/x.csv. Paths whose folders match, such as one given twice, are numbered: x.csv (1) and
x.csv (2). A track is a list of moments, each with these numbers.
| Number | Where it comes from |
|---|---|
| Time, s | Counted from the log’s liftoff, so that two logs of one flight share a clock. A log with no liftoff stands alone on its own clock, marked "synced": false. It can’t join other logs in one file. |
| Up, m | The log’s own altitude above the pad. A column above sea level, or with no stated zero, is taken less its own reading on the pad: the median of its last 20 samples before liftoff, or of its first 20 with no liftoff. A log with no altitude takes its GNSS altitude less the receiver’s on the pad. With none of these, every height is null. |
| East and north, m | The log’s GNSS fixes (a fix is one position from the receiver) in the frame at the pad, in a straight line between fixes. Both are null before the first fix and after the last. A log with no fixes has none. |
Why the log’s altitude and not the smoother’s: on a barometer alone the
smoother can run far from the log through a sudden swing. On RocketPy’s Lince flight, as its
recovery fires, it runs to 10,205 m (33,481 ft), 6,618 m (21,713 ft) past the flight card
(#1073). hpr analyze’s health card
says to go by the reading there, and a file for a viewer has no card. So a barometer’s smaller
spikes stay in the height, and a receiver’s lag on the climb stays in east and north.
The pad
The pad is the frame’s origin: a flat east, north and up grid there, on the WGS 84 ellipsoid (the frame’s equations). It comes from the first of these a flight has:
--pad;- the median of the last 20 fixes before liftoff. On the 180° meridian some fixes read near +180° and some near −180°. With as many of one as of the other, the two middle values lie one each side, and a plain median lands near 0°. So each longitude’s distance from the plain median is found first. If the median of those distances is over 90°, the negative (western) longitudes are moved up by 360°, the median is taken, and the result is brought back into the range from −180° up to, but not including, 180°. Otherwise the plain median stands. Fixes close together have a median distance over 90° only when the meridian splits them, or near a pole. For fixes at 179.9°E, 179.9°W, 179.8°E and 179.8°W, the plain median is 0°; this one is 180°, written −180°;
- the first fix, and how long after liftoff that was, where the log can tell.
A pad from the first fix may be off by what the rocket has already flown. With no fix at all, nothing says where the flight was, and the file says that (below).
The pad’s height comes from the same place, and never from a fix in flight. So fixes before liftoff with no height, or a first fix after liftoff, leave it unknown. A receiver’s height stands in for one above the ellipsoid. Most receivers state sea level, which is off from the ellipsoid by the local geoid, within about 110 m (361 ft). Up isn’t affected: it is measured from the receiver’s own reading.
What is left out
Each track counts what it leaves out, in fixes, heights_too_fast, heights_below_pad and
moments_left_out. CZML and glTF say how many rows went. A fix goes when any of these holds:
- it is empty, out of range, or within 0.01° of 0°N 0°E, which is a receiver’s way of saying no fix;
- its clock didn’t go forward;
- it lies more than 200 km (124 mi) from the track’s median (taken across the 180° meridian as the pad’s is), as a longitude with its sign flipped does;
- reaching it from the last fix kept would take over 1,500 m/s (4,921 ft/s), plus 200 m (656 ft) for a receiver’s scatter.
A height goes on the same speed, plus 50 m (164 ft). The first kept is the first that agrees with the middle of the log’s first 9 usable rows, so one bad first row can’t shut out the flight. That catches a logger’s garbage rows, such as the last two of Juno III’s altimeter file, at 10,700 m (35,105 ft) and −2,490 m (−8,169 ft). It also took 57 of the 44,454 rows of Lince’s height, in the swing as its recovery fires.
Three more go, each counted:
- A height over 500 m (1,640 ft) under the pad. A receiver with no lock can write a height near sea level. One of Juno III’s files does that for 3,400 rows, 1.4 km (0.87 mi) under its pad. They come close enough in time to pass the speed test.
- A moment with no height, or a height of exactly 0 from a receiver, in a track that has heights. Each track has a height at every moment or at none, and a viewer’s line crosses the gap.
- A clock past about 317 years, or about 116 days from the log’s opening.
The three formats
JSON follows schema/cli/ghost.schema.json.
Every number is the track’s own, with null where a log can’t say. Use this one for a program.
CZML is Cesium’s scene format. Each track is an entity with an Earth-fixed position, a point and a path.
glTF is Khronos’s 3D scene format, one file with its numbers inside. Each track is a line along its whole path, with a marker 10 m (33 ft) across moving along it. In meters, +x is east, +y is up and −z is north.
These last two have no null, and a drawing needs a number at every moment. So they draw something
where a log can’t say, and each track’s own text says what it drew:
| Where the log can’t say | CZML and glTF draw |
|---|---|
| No fix yet, or no longer | The nearest fix. A log with no fixes is a straight vertical line over the pad. |
| No height in the whole track | 0 |
| No place for the pad | CZML: 0°N 0°E. glTF has no globe, so it needs none. |
| No height for the pad | CZML: the path starts on the ellipsoid, which can be far under or over the ground. glTF needs none. |
Each also has a limit of its own:
- CZML needs a date, and most logs hold none, so liftoff, or a log’s first moment if it has none, is always noon on 1 January 2000. The time on its clock is seconds from then, not the day of the flight.
- glTF’s times can’t be negative, so its clock starts at the earliest moment. The file’s
extras.first_moment_ssays which that was. - glTF stores 32-bit numbers, which stand about 0.06 ms apart at 1,000 s and 2 mm (0.079 in) apart at 30 km (19 mi). Two moments it can’t tell apart become one.
- East, north and up are on the flat plane at the pad, which rises off the curved ground as you go. So a height is drawn about 31 m (102 ft) too high at 20 km (12 mi) downrange.
A worked example
RocketPy’s repository holds two boards’ logs of its Prometheus flight, shortened here. Reading them both:
hpr analyze \
5115-TeleMetrum.csv \
6583-TeleMega.csv \
--ghost prometheus.json
The TeleMetrum’s liftoff, at 0.23 s on its clock, is 0 in the file. It holds 5,710 moments. Its height peaks at 3,904 m (12,808 ft), the apogee RocketPy’s notebook states from the same column. It kept 5,712 of its 7,081 fixes, which is normal: the other 1,369 rows repeat the time of the row before them. The fixes put the rocket at most 1,170 m (3,839 ft) from the pad, and the fixes before liftoff put the pad at 1,390 m (4,560 ft) above sea level. The TeleMega’s track sits on the same clock and in the same frame, and peaks at 3,898 m (12,789 ft).
How it’s checked
cargo xtask ghost writes each file of each of the 22 logs, then reads them back with open-source
readers this project didn’t write. CI runs the same on two invented flights, as refs/ isn’t there.
- Ajv, a JSON Schema checker, holds the JSON to the schema.
- Cesium’s own
CzmlDataSourceloads the CZML. Cesium’s own transform takes each position to the pad’s frame, where it comes within 1 cm (0.39 in) of the JSON’s at every moment. The file’s count of them matches. - Khronos’s glTF-Validator finds no error in the glTF. glTF-Transform’s animation comes within 1 cm (0.39 in) and 1 ms of the JSON’s at every moment, none missing. Its path’s line holds the same places.
So the formats agree with each other. What ties them to the log is pinned apart from that:
- A foot read as a meter would miss by a factor of 3.28. So each height is held to an apogee from RocketPy’s notebooks that wasn’t read off that column. Of the 16 logs with a barometer’s or a filtered height, 13 peak within 2% of a flight card or another board’s record. Valkyrie’s log, at 1.9% under, is the widest. The other 3 have no such figure, so they are held to RocketPy’s simulated apogee above the pad, the widest 0.3% off. The two with only a receiver’s altitude, on Juno III, peak 4.9% and 5.9% over its altimeter’s card.
- East and north match the ellipsoid’s radii of curvature, by a route that doesn’t use the rotation under test, to 5 mm (0.20 in).
- The bytes of a small CZML and glTF file are worked out by hand from each format’s spec.
What it leaves out
Damaged files
See what happens when a file or a server’s answer is damaged, how that is tested and what the tests leave out.
A flight log pulled off a card can be truncated or corrupt, and a download can stop halfway. This page covers every reader in the five crates that read files and servers’ answers. They read the design, motor, weather and elevation files, each flight-log format, and what the weather, elevation and motor servers send. It is for anyone who wonders what a bad file does, and for anyone adding a reader.
What a reader does with one
A reader stops with an error that says what it couldn’t read. If that happens, copy the file off the card again, or export it again from the logger’s own software.
Some damage doesn’t stop it: a log cut in half often still holds a shorter flight, so it reads as that flight. Check a log’s end before you trust its landing, and its top before you trust its apogee. Compare them with what the logger reported on the pad.
How it is tested
A test walks a list of the readers in hpr-io, hpr-flightdata, hpr-motor, hpr-format and
hpr-net, the crates that read outside files. Each entry on the list is a
reader and a sample for it. A check fails if a public function named read… or parse… in them has
no entry. Another fails if a flight-log format has none. Each reader is called directly, or through
the parser that feeds it if it takes a parsed value. Each is given:
- a real sample cut at 64 places, spread evenly from its first byte;
- the same sample with one byte changed, at 64 places: all its bits at every other place, only the lowest at the rest;
- 256 cases of arbitrary bytes, up to 4,096 of them, from a seed fixed for each entry.
Changing all of a byte’s bits moves a length field far. Changing the lowest keeps a digit a digit.
The test fails on a panic, the program’s own crash on a broken assumption, or on a read still running
after 10 s. Many entries read on from what a
reader gives, as a caller would: a GRIB2 file’s values, a GeoTIFF’s heights, a design from a .ork.
A sample is a committed public file where one serves. Where none does, the test builds one and says
why, as for a server’s answer too long to read a few hundred times.
The maintainers’ private collections, larger than the committed samples, get a test of their own.
cargo xtask logs --check, cargo xtask ork-flights --library --check and cargo xtask fixture-flights --check read 8 cuts of each log and each design in them, and of a design’s XML. They
print the counts and fail on a panic.
An example
On October 31, 2026, the maintainers’ cargo xtask logs --check cut each of the private collection’s
1,122 sample files at 8 places (they aren’t in the repository, so you can’t rerun this), 8,976
reads in all. Of those, 3,921 still gave a log, 5,055 were refused, and none panicked or ran past
10 s. So 44% of the cuts read as something, which is why a read isn’t a sign that a log is whole.
What it leaves out
- Other damage isn’t tried: two bytes changed, a stretch of bytes moved, or a file built to attack a reader. Arbitrary bytes might do any of these, by chance.
- Very long files aren’t tested for time or memory in the public tests, whose inputs stay small. A read that runs out of memory or stack ends the program. That fails the test and names no place.
- Other readers aren’t on the list: a Mach table’s CSV in
hpr-aero, and the JSON the command line reads for a design or a sounding (#1079). - Deep in a design, cuts reach nothing. A
.orkis a zip with its directory at its end, and its XML must close. So a cut of either is refused first. A changed byte in the XML reaches further. Other checked layers stop damage early too: a workbook’s zip, a.hprz’s, and an RTx raw file’s slots. - A private file past 10 s is printed and counted, not failed, since a long log can take that long in an unoptimized build.
- The tests call the Rust readers on a desktop system. The command line, Python and WebAssembly call the same code, but aren’t run on damaged input here.
- These tests look only for a panic or a hang. Whether a damaged file’s value is close to the truth isn’t measured, and it can be far off: a log cut before its top gives too low an apogee.
Checking a claim
Trace any number HPR Sim computes to its published source, the test that pins it and any comparison with another program or a flight.
Every number HPR Sim computes, and every number on this site, should have that trail. Where a comparison exists, it’s with another program or a real flight. This page shows how to follow it, with two worked examples. It’s for anyone who would rather check a claim than trust it. If a trail breaks, that’s a bug, and the last section says how to report it.
The trail
- The page. Each model has a page on this site. Its In short says what the model is, where it comes from, how well it’s validated and what it leaves out. Below that, each section gives the equations in words and symbols, and cites its source by a short key in square brackets, such as [NGA].
- The source. Near the top of the page, under Code and sources (or Sources), each key’s
full reference is listed. Downloadable sources are pinned in the reference lock file
by address and SHA-256 hash, so everyone checks the same file. A hash is a fingerprint of the
file’s exact bytes (the reference library decision).
cargo xtask refs fetchdownloads them into the repository’srefs/folder, which is never committed, andcargo xtask refs verifychecks their hashes again. A few sources couldn’t be fetched, such as Dormand and Prince’s 1980 paper, and the page says so: “cited, not fetched”. - The test. The page’s Verification or Tests that pin this section names the tests that
hold the code to the source, with each one’s tolerance. A tolerance is
how far a result may be from its reference and still pass.
cargo testruns all of them, on every change, on macOS, Windows and Linux. - The comparison. Where a model is compared with another program or a high-precision
calculation:
- The reference values are a fixture, a file under
validation/fixtures/. - A program under
validation/oracles/, an oracle, writes each fixture, with a record of how. - The model page’s verification section names the fixture and the test that reads it.
- Some comparisons, today the descents under a parachute, are also run by the validation
harness. That’s the program behind
cargo xtask validate, which flies them again and rewrites the committed validation report, one row per number. To fly them again and check the report without rewriting it, clone the repository and runcargo xtask validate --check(what it checks). - Each of those has a case file under
validation/cases/. It says what is flown and how close the two must agree, and argues for that tolerance. - The rules behind this are in the validation harness decision.
- The reference values are a fixture, a file under
The Accuracy page gathers every result from steps 3 and 4 in one place.
Example: gravity at the equator
The claim is that the simulator’s gravity on the equator, on the WGS 84 ellipsoid, is 9.7803253359 m/s². That’s at height 0 above the ellipsoid, which isn’t quite sea level (see ellipsoidal height).
-
The page is Gravity and Earth rotation. It models normal gravity, the pull of an idealized Earth plus the effect of its spin. The table under Defining parameters and derived constants gives , the value at the equator, as 9.7803253359 m/s², and cites Table 3.6 of [NGA].
-
The source, [NGA], is the US National Geospatial-Intelligence Agency’s WGS 84 standard, NGA.STND.0036 (2014), a US government work. The lock file pins it as
wgs84-nga-stnd-0036, andcargo xtask refs fetch wgs84-nga-stnd-0036downloads it. Table 3.6 prints the same value. -
The test, under Tests that pin this, is
gravity::tests::somigliana_matches_published_valuesincrates/hpr-core/src/gravity.rs. It checks the constant against Table 3.6 to its printed digits. It also checks gravity at 11 latitudes and heights against values computed from the standard’s formulas at 40 digits, by a separate script,normal_gravity.py. Run it with:cargo test -p fusionspace-hpr-core somigliana_matches_published_values -
No comparison is needed here: the standard itself is the reference. This is the second of the four kinds of evidence that Accuracy describes: a model checked against its published source.
Example: how far a rocket drifts under its parachute
The claim is about the NDRT 2020 rocket, one of RocketPy’s example rockets. HPR Sim’s north drift under the parachute differs from RocketPy’s by +2.865%, inside the 3% tolerance its case allows.
- The validation report has a row for the case
descent-ndrt-2020-nose-to-tailand the metricdrift_north_m. It gives HPR Sim −50.83 m (−166.8 ft) and RocketPy −49.42 m (−162.1 ft). The difference is +2.865%, the tolerance 3.000%, and the verdict pass. - The case file,
descent-ndrt-2020-nose-to-tail.toml, names the rocket’s design and the reference file, and holds each metric to 3% (impact_speed_m_sto 0.1%). Its opening comment argues why there’s no absolute floor, a fixed allowance in meters that would pass any smaller difference. A floor big enough to excuse a drift component near zero would hide a real error in a large one. - The reference values come from
rocketpy-descent.json, which the report names with its hash. The scriptrecovery.pywrote it by flying RocketPy 1.13.0’s own parachute phase. The lock file pins that RocketPy by commit, the id of one exact version of its code. The reference file’s first lines say what RocketPy computes, and what the comparison overrides. Both codes start from the same state, with the first parachute opening at once. - The model page, Recovery, explains HPR Sim’s descent, and its section Against RocketPy explains the differences that remain. The likely cause is added mass, which HPR Sim has no term for. RocketPy treats the air a canopy drags along as extra mass: 15.9 kg for NDRT’s main against the rocket’s 20.8 kg. It slows the response to the opening, which most likely moves this small drift component by 2.86%. That fits the size of the gap, but no test has isolated it yet.
- The test
recovery::tests::descent_matches_rocketpy_examplesincrates/hpr-sim/src/recovery.rsreplays all five cases on every change, andcargo xtask validatewrites them into the report.
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. The real flights compared so far stop at apogee, so no descent has been checked against one yet.
Rules that keep the trail honest
- A reference is never changed to make a comparison pass. It moves only when its generator runs again, a deliberate step recorded in the history. This guards against Loft lesson L76. Loft, the project before this one, said to regenerate a reference when its drift check failed, so the reference moved with Loft’s own drag.
- On every pull request, CI reruns every case on macOS, Windows and Linux. It fails if a metric is outside its tolerance, or if the committed report no longer matches, apart from last-digit rounding. The workflow that regenerates the references runs only when a person starts it. It can’t commit: its output is a diff for a person to review (how CI and regeneration work).
- A tolerance lives in its case file, with its reason. Loosening one to turn a failure into a pass isn’t allowed. A target that can’t be met gets a decision record that shows the measurement, and the gap stays in the report.
- The site checks its own numbers. Its build fails if any of these breaks:
- Every number on Accuracy outside code must appear in a file that its paragraph, list item or table row links to. A number is anything with two or more digits, a decimal point, an exponent or a percent sign. The file can be the validation report, a case file or a model page outside its In short. A guide page such as this one doesn’t count, so no page can vouch for itself.
- It must appear there written the same way: the same digits, and the same sign and percent sign where Accuracy writes them. So 2.8 doesn’t match 2.865, and −2.865% doesn’t match +2.865%.
- Accuracy’s table of the descent results must match the validation report cell by cell, and hold every result in it.
- Every number in a model page’s In short must appear in the rest of that page, or in a file its item links to.
- That check has two blind spots. When a number changes at its source, the build fails until the page that quotes it follows. It doesn’t if the old number still appears elsewhere in that file. And the check can’t tell whether a number is quoted in the right context, such as for the right rocket. The reviews check that, and the model pages say what each number means.
When the trail breaks
The trail breaks where a number has no source, no test, or a test that doesn’t check what the page says. If you find one on this site or from the code, please open an issue with the page and the number. The pencil icon at the top of each page opens its source on GitHub, where you can propose a fix.
What backs each claim
This page lists the gaps the docs state in their own evidence, what would settle each, and the issue waiting for it.
The pages say plainly when a file reader, a model or a check rests on less than the real thing:
- a format read only from files invented for its tests;
- a value assumed because no sample states it;
- a model checked only against another program.
Each such statement is a row of the register, validation/evidence.toml. A page that
states a gap in one of the check’s phrases links its row here, so the gap has a place to be closed. A row short of the
evidence it wants keeps an open issue labeled needs-sample until a real sample or
measurement settles it. A decision record set this up.
The check fails a page that states a gap in one of its 23 phrases (the list) without linking a row. It fails a row whose page or anchor is gone, and a row short of its wanted kind with no open issue. It can’t see a gap inside double quotation marks or a code block. It skips the pages about the project’s own process: the roadmap, the plan, the writing guide and the release steps. The gaps it’s known to miss, most of them the aerodynamics page’s “no measurement”, wait in #685.
The kinds of evidence
A row’s kind says where its evidence comes from. The kinds follow the FDA’s guidance on
computational models (2023, §VI.B) and NASA’s modeling handbook’s referent grades
(NASA-HDBK-7009B, Table 24), which the decision record cites. They’re categories, not a
scale, apart from one rule: real is what every row wants unless a decision record sets less. The
four kinds on Accuracy are a different list: they say how a
model is checked.
| Kind | What it means | Example |
|---|---|---|
| real | A file or a measurement from the device or flight itself | A logger’s own download of a flown rocket |
| sibling | A real file from a related device or firmware | Another model of the same maker’s altimeter |
| code to code | Another program’s answer to the same input | GPX values compared with gpxpy’s |
| spec | Built from a published layout, schema or model, and checked on invented inputs | A reader written from a format’s manual and tested on files made for its tests |
| calibration | Checked against the data it was fitted to, or seen while it was chosen | Flights compared with the simulation after its models were tuned beside them |
| reasoning | An argument only | A unit inferred from what a rocket can do |
| none | Nothing yet | A format no one has a file of |
The report below has a column only for a kind some row has; today one row, G41, is sibling. A row also says
what its evidence doesn’t cover (not checked). It lists each real sample with its SHA-256 hash
(a fingerprint of the file’s bytes) and the test that reads it. It logs each search for better
evidence by date: each place it looked and what it found, so the next doesn’t repeat it.
Sending a sample
If you have a file a row asks for, attach it to the row’s issue. Or say there where it can be
downloaded, and under what license. A sample is kept outside the repository, in the refs/ folder
the checks fetch into. Its hash lets every check confirm it reads the same bytes.
Checking a claim shows how a pinned file is fetched and verified.
The register
The register holds 41 rows, as of November 20, 2026.
By kind. Each surface’s rows, counted by the kind of evidence behind them now:
| Surface | Real · rows | Sibling · rows | Code to code · rows | Spec · rows | Calibration · rows | Reasoning · rows | None · rows | Rows |
|---|---|---|---|---|---|---|---|---|
| Flight-log readers | 0 | 0 | 3 | 2 | 0 | 3 | 3 | 11 |
| The flight analyzer | 0 | 0 | 0 | 1 | 1 | 0 | 0 | 2 |
| Flight models | 0 | 0 | 0 | 1 | 0 | 3 | 1 | 5 |
| Aerodynamics | 0 | 1 | 3 | 2 | 0 | 2 | 0 | 8 |
.ork import | 0 | 0 | 0 | 1 | 0 | 1 | 0 | 2 |
| Accuracy against real flights | 0 | 0 | 0 | 0 | 1 | 1 | 0 | 2 |
| Fin flutter | 0 | 0 | 0 | 1 | 0 | 0 | 0 | 1 |
| The motor finder | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 1 |
| Design export | 0 | 0 | 1 | 0 | 0 | 0 | 0 | 1 |
| The synthetic flights | 0 | 0 | 0 | 0 | 0 | 1 | 0 | 1 |
| The smoother | 0 | 0 | 0 | 0 | 1 | 0 | 0 | 1 |
| Flight-log readings’ 90% intervals | 0 | 0 | 0 | 0 | 1 | 0 | 0 | 1 |
| Two logs of one flight on one timeline | 0 | 0 | 0 | 0 | 1 | 0 | 0 | 1 |
| One logger to a stage on one timeline | 0 | 0 | 0 | 0 | 1 | 0 | 0 | 1 |
| Ghost files | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 1 |
| The least-squares fit | 0 | 0 | 0 | 0 | 1 | 0 | 0 | 1 |
| Public flights predicted first | 0 | 0 | 0 | 0 | 0 | 1 | 0 | 1 |
| All | 2 | 1 | 7 | 8 | 7 | 12 | 4 | 41 |
Short of what’s wanted. 39 of the 41 rows don’t yet have the kind of evidence they want. Each has an open issue labeled needs-sample, linked in its row below.
The rows.
| Row | Surface | Claim | Evidence | Wanted | Issue | Last search |
|---|---|---|---|---|---|---|
| G1 | Flight-log readers | GPX tracks are read as the GPX 1.0 and 1.1 schemas define them, checked against gpxpy on three invented files. Not checked: what a real tracker or phone writes, and what its elevation (ele) is measured from. | code to code | real | #654 | 2026-10-20 |
| G2 | Flight-log readers | Paths no sample log reaches are checked by the readers’ tests alone: decimal commas, workbooks dated from 1904, a Raven .FIPa temperature below zero, an RTx fix at (0, 0). Not checked: a real file that takes any of these paths. | spec | real | #655 | 2026-10-17 |
| G3 | Flight-log readers | AltOS radio telemetry is decoded from AltOS’s documents for the packet types the samples hold. Not checked: the eleven packet types no sample holds, which are left out; the GPS ground speed, climb rate and course, which nothing checks. | spec | real | #656 | 2026-10-17 |
| G4 | Flight-log readers | AltOS .eeprom logs are read in formats 1, 6, 7, 14, 15, 16 and 22, with the TeleMetrum v1’s converter assumed. Not checked: that the TeleMetrum v1’s converter measures against the pressure sensor’s own supply, which no document states; the TeleMega v4’s IMU, which its one sample never ran; 4 of the 14 sample files, with neither an export nor telemetry beside them; formats 5, 9 and 19, refused. | reasoning | real | #657 | 2026-10-28 |
| G5 | Flight-log readers | ARTS2 raw data is timed at 50 records a second, the rate the maker’s DataAnalyzer gives every file. Not checked: where the file stores its rate, if it does, and a file recorded at another rate. | code to code | real | #658 | 2026-10-17 |
| G6 | Flight-log readers | Some layouts rest on one sample or on no export to compare with: the AltiMAX .ALS, the AIM .xtra and raw dump, 7 of 63 raw downloads, 5 of 6 RRC3 .rff files, and each case of an AltOS CSV re-saved by a spreadsheet. Not checked: a second flight of each layout read beside its maker’s export; the raw downloads with no export beside them. | code to code | real | #659 | 2026-10-17 |
| G7 | Flight-log readers | Featherweight summaries are checked on their maximum and pad altitude only. Not checked: the speeds, accelerations, times and the rest, converted from the unit the file writes and checked against nothing. | none | real | #660 | 2026-10-17 |
| G8 | Flight-log readers | GPS heights are kept in the unit the file writes: a phone app’s altitude as written, KML heights the least sure. Not checked: each height’s unit and what it is measured from, beside a barometric log of the same flight. | reasoning | real | #661 | 2026-10-17 |
| G9 | Flight-log readers | Formats with no sample on terms that let their bytes be tested (CATS’s and the others listed) have no reader of their own. Not checked: the formats the list names, of which no sample can be tested on its terms. | none | real | #662 | 2026-10-17 |
| G10 | The flight analyzer | Checked on an invented flight of known readings, one real log when fetched, and the synthetic flights the bounds were tuned on: 171 with a barometer logged 43 ways, 71 with an accelerometer 3 more, the 500 Hz IMU’s 38 once more at ±8 g, which 28 of their tops reach; every reading within its bound (cargo xtask synthetic). Not checked: other real logs, with no truth beside them; flights outside the tuning set; loggers noisier than its six profiles; a high-g part held at its stated range, beyond every tuning flight; a quiet part’s single-valued thrust plateau, read as flat, given only as a floor; accelerometer noise correlated between samples; a canopy’s filling time (synthetic canopies open at once). | calibration | real | #663 | 2026-10-17 |
| G11 | The flight analyzer | Reading your own logger by a stated mapping or layout is shown on one invented flight’s logger and GPS tracker files. Not checked: a real logger’s files read by a mapping or layout someone states. | spec | real | #664 | 2026-10-17 |
| G12 | Flight models | Dryden gusts are generated as MIL-F-8785C gives them for aircraft, and no flight uses them. Not checked: any rocket flight, for which the model is unvalidated. | spec | real | #665 | 2026-10-17 |
| G13 | Flight models | A dropped booster or middle stage is flown after the split as a point, a mass with only its recovery device’s drag. Not checked: the whole flight of the dropped part, which is not validated at all. | none | real | #666 | 2026-10-17 |
| G14 | Aerodynamics | Base drag with the motor burning takes the motor case off the base. Not checked: any measurement of base drag under power on a hobby rocket; on the one missile model’s flight checked, whose motor case is wider than its base, the rule leaves no base drag under power and reads low. | reasoning | real | #667 | 2026-11-19 |
| G15 | Flight models | Thrust about a center of gravity off the axis turns the rocket in HPR Sim, and not in OpenRocket. Not checked: which of the two is right, which nothing measures. | reasoning | real | #668 | 2026-10-17 |
| G16 | .ork import | A part’s roll angle in an .ork file turns the way HPR Sim assumes. Not checked: which direction OpenRocket turns it. | reasoning | real | #669 | 2026-10-17 |
| G17 | Flight models | The apogee printed for an unstable sustainer assumes it stays upright, and flights off a rod and off a rail differ. Not checked: an unstable sustainer’s real flight; where the rod and the rail differ, not traced. | reasoning | real | #670 | 2026-10-17 |
| G18 | .ork import | An inner tube’s automatic outer radius is held to OpenRocket only on fourteen probe designs, and a ring’s automatic bore rests on its unit tests. Not checked: OpenRocket’s values for a real design’s automatic radii, which the library’s files never cache, and for a ring’s automatic bore. | spec | real | #671 | 2026-10-17 |
| G19 | Aerodynamics | RASAero II’s exported tables are flown from one real export, to Mach 0.75. Not checked: a real export flown faster, checked by unit tests alone; past the export’s last angle, and at 0° faster than Mach 1.3, the values are assumed. | spec | real | #672 | 2026-10-17 |
| G20 | Flight models | A pushed part leaves through the end the simulator assumes, from the way its body points as it falls. Not checked: a measured deployment; the directions are assumptions, not measurements, and for a drogue between the booster and the avionics bay a guess. | reasoning | real | #673 | 2026-10-17 |
| G21 | Accuracy against real flights | Four of the seven altimeters of the public flights compared first are taken as barometric, and the designs’ fin edges are guesses. Not checked: each of the four altimeters’ sensor, none of them calibrated; each design’s fin edges. | reasoning | real | #674 | 2026-10-17 |
| G22 | Fin flutter | Martin’s flutter criterion (NACA TN 4197) places a fin against the line his missile and wind-tunnel wings drew. Not checked: a hobby rocket’s flutter, but for one sighting of inferred fin material; that it errs safe, which nothing shows; a fin glued to a tube, less stiff at its root than Martin’s wings (a plate with its root restraint cut read 1.10); at least four kinds that fluttered below HPR Sim’s speed in tests: plies coupling bending to twist (1.13 to 1.42 times the onset), built-up wings (up to 1.47), stiff inboard with a soft tip and trailing edge (1.05 to 1.43 or more), solid swept fins (1.17 to 1.42, or up to 1.80 on another reading), none a bound. | spec | real | #675 | 2026-10-17 |
| G23 | The motor finder | The motor finder is replayed on ThrustCurve.org’s own searches of three makers, recorded unchanged on October 29, 2026, each record the same, field for field, as in ThrustCurve.org’s raw answer of October 28, 2026, and each solid motor’s as in the snapshot hpr-motor compiles from it. Not checked: the tests of fetching one motor on demand, which replay invented answers for cases the real records don’t hold; and the in-stock list, recorded on October 1, four weeks before the searches. | real | real | none | 2026-10-29 |
| G24 | Accuracy against real flights | The simulation’s apogees miss 12 public real flights by 8.88% on average and 60 private ones by 12.09%, both outside the 5% target. Not checked: a flight held out from every choice of model and every fit, predicted before its log is read. | calibration | real | #676 | 2026-10-17 |
| G25 | Design export | The .ork files hpr convert writes are checked by opening them in OpenRocket. Not checked: whether RockSim opens them. | code to code | real | #677 | 2026-10-17 |
| G26 | Aerodynamics | Drag is compared with the RASAero II curves of RocketPy’s example rockets, of which Calisto’s is the one real RASAero II export. Not checked: a measured drag of any of them; the other curves’ rockets, which record no fins or surface finish, so HPR Sim flies stated guesses for them; and the comparison misses past Mach 1.6, where against Calisto’s export HPR Sim is within 10% at 8 of the 17 rows from Mach 1.2 to 2.0. | code to code | real | #678 | 2026-10-17 |
| G27 | Aerodynamics | Tube fins’ normal force and center of pressure are compared with OpenRocket 24.12’s on 14 probe designs and its tube fin rocket. Not checked: a measured tube fin’s lift or center, of which none was found; which code is right, as OpenRocket’s tubes lift 1.26 to 1.86 times HPR Sim’s at every Mach number; the interference between tubes, an unchecked estimate. | code to code | real | #679 | 2026-10-17 |
| G28 | Aerodynamics | A flared body’s supersonic normal force rests on one measured flare, and a flare past its corner’s limit flies a rule checked against nothing. Not checked: a second measured flare; any flare past its corner’s limit; the attachment test, a wedge’s limit rather than a flare’s own; a near-flat flare, read by the older generalized method. | reasoning | real | #680 | 2026-10-17 |
| G29 | Aerodynamics | Faster than sound, a boattail’s share of the body’s force comes from the shock-expansion method, and a blunt tip flies it behind a Newtonian cap. Not checked: the boattail’s share, unvalidated; a blunt tip, checked on a sphere-cone only. | spec | real | #681 | 2026-10-17 |
| G30 | Flight-log readers | The AltiMAX’s Excel export keeps its voltages as the file states them. Not checked: the voltages, which nothing checks. | none | real | #682 | 2026-10-17 |
| G31 | Flight-log readers | An RRC3’s Temperature column that states no unit is kept as written; its Voltages column that states none is read in volts. Not checked: the voltage’s unit, which is assumed; a file whose voltage can be checked against another record of the same flight. | reasoning | real | #683 | 2026-10-20 |
| G32 | The synthetic flights | The synthetic loggers’ noise follows the makers’ datasheets and the noise measured on a few public logs, each drawn term tested on its own; the accelerometer’s residual bias, the GNSS loop’s range, damping and noise, the dropouts, the port’s place, the Bosch-class part on two profiles, PerfectFlite’s offset and one bench sensor’s slow noise on every barometer are assumed, and the MS5607’s error read as a gain is inferred. Not checked: a synthetic log as a whole against real logs of the same family: the pad’s noise and its correlation, and the ejection pulses. | reasoning | real | #725 | 2026-10-17 |
| G33 | The smoother | At burnout, the top speed, apogee and a drawn moment, the smoother’s 90% intervals on height and vertical speed hold between 94.2% and 99.4% of the synthetic flights’ truths in the three sets’ cells, and two logger cells 88.7% and 89.2%, on the 171, 820 and 845 flights smoothed of three sets of 200, 1,000 and 1,000, its rules set with those sets in view; the same flights’ logs cut at liftoff, on an assumed pad, hold in every cell too (95.6% to 98.7% overall on A and B, on the true zero). Not checked: a real flight’s smoothed height and speed against a truth apart from the log, such as a second logger’s or a ground tracker’s. | calibration | real | #981 | 2026-10-31 |
| G34 | Flight-log readings’ 90% intervals | Twelve readings state 90% intervals, and a floor a lower end, fitted on 2,000 synthetic flights of their own. On sets A and B each passes the coverage test or its lower tail (the top speed below its transonic mark; a clipped top near an imposed clip); every probe fails. The misses gather: the height’s, the top speed’s and the descent rates’ gather on days more than 10 K from standard, a warm day’s above the interval (#1055, #1061); the times lean by logger (#1056, #1062), and the top acceleration most (#1070). Not checked: a real flight’s readings against a truth taken apart from the log, such as a second logger’s or a ground tracker’s record of the same flight. | calibration | real | #1052 | 2026-10-31 |
| G35 | Two logs of one flight on one timeline | A shared liftoff recovers the clock offset between two logs of one flight, within a bound that held on the synthetic flights. On one real pair, RocketPy’s Prometheus flight, it lies about 0.08 s from what the boards’ GPS time gives, where an offset of zero would miss by 0.13 s. Not checked: a real pair whose clocks differ by more than a fraction of a second; the Prometheus logs both start at the boost, and the GPS reference has no stated error of its own. | calibration | real | #1088 | 2026-11-02 |
| G36 | One logger to a stage on one timeline | A shared liftoff lines up a logger in each stage of a staged flight, within a bound that held on 135 simulated two-stage flights. Not checked: a real flight’s log from each stage, where a booster’s board may read the pad’s shock and the separation otherwise. | calibration | real | #1084 | 2026-11-02 |
| G37 | Ghost files | Each of the 22 real flight logs in RocketPy’s repository with an altitude or a GNSS track gives a ghost file as JSON, CZML and glTF, which outside readers read back and hold to each other. Not checked: a person looking at one in Cesium or a modeling tool: every check is of the numbers; east and north against the real logs’ fixes, only the invented cases and a hand check on three. | real | real | none | 2026-11-02 |
| G38 | The least-squares fit | Each of the drag scale, impulse scale, wind on logs with a track, and mass has a 90% interval that passes its test on two sets of synthetic flights, seen while its model was chosen. Not checked: a real flight’s fit against what was measured apart from the log: a weighed mass, a static test’s impulse, a measured wind. | calibration | real | #1104 | 2026-11-02 |
| G39 | Public flights predicted first | Astra’s, Andromeda’s and Erebus 11’s logs are each taken as a barometric altimeter’s, and each prediction is read the same way. Not checked: each of the three altimeters’ make and sensor. | reasoning | real | #1403 | 2026-11-10 |
| G40 | Aerodynamics | A tangent-ogive nose’s pressure drag past Mach 1 is its equivalent cone’s by the method in Niskanen’s thesis, set beside OpenRocket 24.12’s on an invented probe from Mach 1 to 2 and on the designs of 5 logged flights just past Mach 1. Not checked: a measured pressure drag of a tangent ogive past Mach 1, including between Mach 1 and 1.3, committed as data with a test that scores HPR Sim’s nose against it. | code to code | real | #616 | 2026-10-16 |
| G41 | Aerodynamics | Below Mach 0.8 a base behind a boattail keeps d_B/d of the flat-base drag, changed on one missile model’s measured free flight. Not checked: a measured base drag behind a hobby rocket’s boattail below Mach 0.8; the one flight checked, the Hermes A-3A drag model’s, has a long 4.5° cone and is not a hobby rocket. | sibling | real | #1572 | 2026-11-20 |
Due a search. A row is due one when it has none yet, or its last was more than 30 days before November 20, 2026:
- G1
- G2
- G3
- G5
- G6
- G7
- G8
- G9
- G10
- G11
- G12
- G13
- G15
- G16
- G17
- G18
- G19
- G20
- G21
- G22
- G24
- G25
- G26
- G27
- G28
- G29
- G30
- G31
- G32
- G40
Searches so far.
-
G1, October 17, 2026, looked at:
- the download pages and documents of Featherweight, AltOS, Eggfinder, Missile Works and BigRedBee
- public repositories of flight logs
It found no openly downloadable GPX of a real rocket flight. The dedicated trackers write KML, CSV or raw NMEA. GPX comes from phone apps, handheld receivers and mapping tools.
-
G1, October 20, 2026, looked at:
- Rocketry Forum thread 135349’s attachments, fetched from the forum’s attachment links, their GPX files counted for
geoidheight - GitHub code search for GPX files with
geoidheight, with and without rocketry words - OpenStreetMap traces tagged rocket
- Zenodo, figshare, Kaggle and other data sites
- phone-app posts (the survey in docs/research/public-logs-evidence-gaps.md)
It found a source to cite only. Thread 135349 (2016, no terms stated, cached under refs/samples-search/G1) holds four GPX files of an Eggfinder’s track of two flights. None has
geoidheight. Beside them is the receiver’s raw NMEA, whose GGA sentences state the geoid separation. GitHub’s GPX files withgeoidheightare everyday phone tracks (#645). - Rocketry Forum thread 135349’s attachments, fetched from the forum’s attachment links, their GPX files counted for
-
G2, October 17, 2026, looked at:
- GitHub code search for
.FIPaand.rtxfiles and semicolon-separated altimeter exports (mDACS, Eggtimer and Blue Raven headers split by;) - the Harvey Mudd College advanced rocketry course’s flight data page (its 11 workbooks fetched)
- a University of Minnesota course directory (one
.FIPa) - the 1904 date flag, counted in every workbook of the private collection
It found nothing usable: the one public decimal-comma export found is a SpaceTeam Aachen RRC3 export (2021) in the GPL-3.0 repositories M0WW0M/European-FlightData and catsystems/euroc21-team-data. Its European-FlightData copy is byte for byte a file the private collection already holds. None of 126 private workbooks (copies included) and 11 public course workbooks uses the 1904 date system. No public
.rtxwas found; the Minnesota.FIPa(no license) records a June flight. - GitHub code search for
-
G3, October 17, 2026, looked at:
- GitHub code search for
.telemfiles: 16 rocketry files in 9 repositories - 15 of them downloaded, each line’s packet type counted against the AltOS Telemetry document’s table
- each repository’s license
- PSAS’s launch repositories
It found a partial answer: real packets of 3 of the 11 undecoded types under MIT, but no flight and no export beside them. A TeleMega’s pad recording is in lunng/HART_CS_2020 (MIT): types 0x08 and 0x09, 538 of each. UCC-Rocket-and-Space-Exploration/CosmoSoft (MIT) holds a TeleMini v3’s pad packets (type 0x11), beside an AltosUI CSV of a later flight that a spreadsheet re-saved. Flights with types 0x08, 0x09 and 0x14 exist with no license (Maeswoon/UNHSEDS, with AltosUI’s telemetry CSV beside it; AIAANortheastern/KarmanSims; Mines-Rocketry-Club/JEFF-modular-rocket-system). No export found has a GPS ground speed, climb rate or course column.
- GitHub code search for
-
G4, October 17, 2026, looked at:
- the JSON headers of 17 public
.eepromfiles from GitHub code search (log_formatin.eeprom) - PSAS’s launch repositories (psas/flight_data-2010.06.27, Launch-8, Launch-10 to Launch-14)
- Mines-Rocketry-Club’s flight data
It found a partial answer, to cite only: PSAS flew a TeleMetrum v1.0 (serial 221) from 2010 to 2013. Its October 17, 2010 and June 30, 2013 files are already in the private collection. A third, in psas/flight_data-2010.06.27 (no license), is an older text-form
.eeprombeside a table of time, height, speed and acceleration not in AltosUI’s CSV layout. No TeleMega v4 file whose IMU ran, and no new file in log format 5, 9 or 19, was found. The other public files are TeleMetrum v2 to v4 (format 7), EasyMini (6 and 14) and TeleMega v6 (22). - the JSON headers of 17 public
-
G4, October 28, 2026, looked at:
- GitHub code search for
log_formatin.eepromfiles, every header of the 44 hits parsed - the names
TeleMetrum-v1andTeleMega-v4across GitHub
It found a lead for the TeleMetrum v1’s converter: ISSUIUC/flight-data holds a TeleMetrum v1.2
.eepromin log format 1 with AltosUI’s export beside it (no license; cache under refs/ only). No TeleMega v4 file whose IMU ran. Format 5, 9 and 19 samples were found earlier and are listed in the CATS and Juno sample note (docs/research/sample-logs-cats-juno.md); the October 17 search’s none was too narrow. - GitHub code search for
-
G5, October 17, 2026, looked at:
- the ARTS2 User Manual V1.0.0 (pp. 7, 9, 16)
- PSAS’s launch repositories for ARTS2 flights beyond the samples (May 31, 2009; June 27, 2010; and October 17, 2010)
- PSAS’s ARTS-2 checklist page
- web searches for DataAnalyzer documents
It found a partial answer: the manual says the recording rate is set per flight profile in DataAnalyzer (p. 7). The memory fills in 82 s to 26 min, depending on the rate (p. 9). The sensors are read at 200 Hz whatever rate is recorded (p. 16), so files at other rates can exist. PSAS’s 2009 and June 27, 2010 ARTS2 tables (no license) each hold 16,384 or 16,385 records 0.020 s apart. At 200 a second, 16,384 records last 82 s. By inference, the memory holds 16,384 records, and the rates run from about 10 to 200 a second. PSAS’s checklist sets 50 Hz in both profiles. No file at another rate, and no document of where the
.odfkeeps the rate, was found. Each sample flight also carried a TeleMetrum, whose liftoff and deployment times could time the ARTS2’s records. -
G6, October 17, 2026, looked at:
- GitHub code search for mDACS’s export header
- listings of team flight data repositories
- the Harvey Mudd College advanced rocketry course page and its dofpro.org mirror, for AIM XTRA files
- M0WW0M/European-FlightData, for AltiMAX files
It found 7 RRC3
.rfffiles in RIT-Launch-Initiative/flight-data (MIT, commit ffa9f44), saved by mDACS 1.61 from 3 launches in 2023 and 2024. 6 have mDACS’s CSV export beside them. 4 of the exports have units typed into their headers by hand, as the team’s procedure says. The team’s notes record avionics-bay failures in flight on two vehicles. The private collection holds 5 of the exports and none of the.rff; all are cached under refs/samples-search/G6/rit-flight-data. AIM.xtra: the course page lists 15.xtrafiles of 2017 beside AIM CSV exports. Every.xtralink returned HTTP 404 and the mirror’s one link is an empty file; only the CSVs download. AltiMAX: the only public.ALSfound is the sample already held. A second AltiMAX flight in the same GPL-3.0 repository has its Excel export only. -
G7, October 17, 2026, looked at:
- GitHub code search for Featherweight’s summary header (
Rocket Name,Launch time UTC) in CSV files
It found 16 summaries in 10 repositories, 3 of them under MIT. RIT-Launch-Initiative/flight-data (MIT, commit ffa9f44) holds two Blue Raven flights, each with its summary, low-rate and high-rate CSVs. It also holds a Featherweight GPS tracker’s summary beside its track; RMIT-Hive-Rocketry/GCS (MIT) a Blue Raven summary with both rate CSVs (June 20, 2026). Neither is in the private collection. Lmx154/RL-RocketPy-Notebook (MIT) has a summary and low-rate pair the private collection already holds. The RIT files are cached under refs/samples-search/G7/rit-flight-data.
- GitHub code search for Featherweight’s summary header (
-
G8, October 17, 2026, looked at:
- GitHub code search for Featherweight GPS tracker CSVs (
UTCTIME,UNIXTIME,ALT, 12 files in 7 repositories) with KML or a barometric log beside them - the Harvey Mudd College course page’s AIM KML files
It found two MIT flights each with a tracker file (RIT’s a summary CSV, Lmx154’s a track), a KML and a Blue Raven barometric log. Their KMLs are
altitudeModeabsolute. One is RIT-Launch-Initiative/flight-data’s second airbrake testbed flight (the app’s and the desktop’s KML). Its two files disagree on the date (April 7, 2026 by the Blue Raven’s clock, May 16, 2026 by the tracker’s UTC): their pairing has to be shown first. The other is Lmx154/RL-RocketPy-Notebook’s Lonestar 2026 flight, whose CSVs the private collection already holds and whose KML is new. Peaks read 3.6% and 3.8% higher on the tracker than on the Blue Raven. The course page’s KML links return HTTP 404. Both are cached under refs/samples-search/G8. - GitHub code search for Featherweight GPS tracker CSVs (
-
G9, October 17, 2026, looked at:
- GitHub code search for the Eggtimer ION header, Blue Jay, MicroPeak, EasyMotor, TeleMini, EasyTimer and AltimeterThree files
- GitHub code search for CATS’s
.cfland its exports’ column names - GitHub repository search for flight data collections
- M0WW0M/European-FlightData
It found nothing usable for the listed formats. The CATS hits are the GPL-3.0 catsystems/cats-logs and euroc21 files already known. The only new logger files are two Eggtimer Quantum CSVs (lower-case header, GPL-3.0, Skyward’s 2022 flight), a device the list doesn’t name.
-
G10, October 17, 2026, looked at:
- team flight data repositories on GitHub with a license and a logger’s own figures beside its log: RIT-Launch-Initiative/flight-data, RMIT-Hive-Rocketry/GCS, Lmx154/RL-RocketPy-Notebook, AerospaceTeamGraz/RocketFlightData, ISSUIUC/flight-data, curtscraw/osu_rocketry_data
It found these, under MIT: RIT-Launch-Initiative/flight-data’s 6 RRC3 exports beside their
.rfffiles, whose summary statistics the team’s note describes. RIT’s two Blue Raven flights’ summaries state the peak, the first burnout’s time and each channel’s firing time. RMIT-Hive-Rocketry/GCS has a Blue Raven flight with its summary. None is in the private collection but 5 of the RRC3 exports. The other repositories have no license, except Lmx154/RL-RocketPy-Notebook (MIT), whose files the private collection already holds. -
G11, October 17, 2026, looked at:
- team repositories whose own flight computer’s files come with a stated layout and another record of the same flight: RIT-Launch-Initiative/flight-data, Lmx154/RL-RocketPy-Notebook, curtscraw/osu_rocketry_data, ISSUIUC/flight-data
It found RIT-Launch-Initiative/flight-data (MIT, commit ffa9f44): the team’s airbrake controller writes
data.csvwith units in each column name (accel_x__m_s2), aparams.csvand a raw capture. The airbrake-test README states the files’ columns, units and meanings. On the two testbed flights a Blue Raven flew beside it. None of these files is in the private collection; they’re cached under refs/samples-search/G11/rit-flight-data. Lmx154’s flight computer log with unit-named columns and alignment notes is already held privately; curtscraw/osu_rocketry_data states its units indata_units.txtbut has no license. -
G12, October 17, 2026, looked at:
- web searches for measured against predicted dispersion of small and sounding rockets, with the wind measured
- web searches for Dryden or other turbulence models checked against rocket flights
- the team repositories found for the rows above, for wind records beside their logs
It found nothing usable: the dispersion work found is simulation or wind-weighting studies. No team repository found holds a measured wind profile beside its flight logs.
-
G13, October 17, 2026, looked at:
- GitHub repository and code search for staged flights with the booster’s own log
- ISSUIUC/flight-data
- Minnesota Space Grant’s Midwest Rocketry Competition reports, whose rockets drop a booster after burnout
It found a partial answer, to cite only: ISSUIUC/flight-data (no license) holds booster logs of two two-stage flights with the sustainer’s beside them. On November 18, 2023 they’re two StratoLoggers; on March 23, 2024, a TeleMega v6
.eepromwith a CSV export beside it. There are also files named for a booster alone (October 1, 2023). Every booster file checked is already in the private collection, and no design file was found. The competition’s reports describe booster descents but link no log. -
G14, October 17, 2026, looked at:
- Craven, College of Aeronautics Report 129 (1960): its record and full text at Cranfield
- NACA free-flight reports on base pressure with rocket motors burning, by web search
- measurements of base pressure on hobby rockets in flight
It found nothing beyond the October 17, 2026 power-on base drag note. Craven’s record describes a subsonic stream with a supersonic jet at a jet-to-base diameter ratio of 0.1875. There, slight under-expansion raises base pressure and higher stagnation pressure lowers it again. Its full text returned HTTP 403. No measurement on a hobby rocket under power was found.
-
G14, November 19, 2026, looked at:
- NACA and NASA reports on subsonic base drag with a rocket jet, on the NASA Technical Reports Server
- the project’s research notes on power-on and hot-jet base drag
It found one free flight whose base drag curves, power on and power off, run below Mach 0.8: NACA RM SL55F15’s Hermes A-3A drag model A(1), whose base drag under power is more than twice its power-off value. HPR Sim’s rule, its motor case wider than its base, leaves none and reads low; given the nozzle exit it reads high, as the whole base does. It is now a validation reference (validation/fixtures/aero/base-drag-under-power.json). Its jet is overexpanded and carries jet vanes, and its base is behind a long boattail, so it is not a hobby rocket’s. No measurement on a hobby rocket under power was found.
-
G15, October 17, 2026, looked at:
- web searches for flight tests of rockets with a measured lateral center-of-gravity offset or mass asymmetry and their drift under thrust
It found nothing usable: only simulation and dispersion analyses, none a logged flight with a known offset.
-
G16, October 17, 2026, looked at:
- OpenRocket’s user guide (basic rocket design page) and wiki
- openrocket/openrocket issues found by searching for angle, rotation, rail button and mirror (#940, #1548, #1640)
It found a partial answer: #940 puts 0 degrees at the top of the rocket and #1548 discusses pods’ angles with rear-view pictures. No source states which way the angle turns. The OpenRocket 24.12 jar, run on a probe with one part turned by a known angle, remains the way to settle it. This search didn’t run it.
-
G17, October 17, 2026, looked at:
- web searches for logged two-stage flights whose sustainer went unstable after the split
- The Rocketry Forum staging threads
- Spaceport Rocketry’s staging guide
- a 2018 UTN Haedo stage-separation paper (rtyc.utn.edu.ar, article 101)
- the private collection’s design and log catalog, counted only
It found nothing usable: the forum threads found describe sustainers that didn’t light. The UTN paper is a wind-tunnel study of a first stage, CC BY-NC 4.0, with no flight. The private collection holds 148 flights of designs with two or more stages that carry a log. None is yet screened for a sustainer unstable after the split. No flights of one design off both a rod and a rail were found.
-
G18, October 17, 2026, looked at:
- the private collection’s 714 .ork files (copies included), opened and counted for inner tubes and centering rings set to
auto
It found that no file holds OpenRocket’s computed radii, as the issue says, but the designs exist. 43 files have an inner tube with an automatic outer radius (43 tubes), 446 have rings with an automatic bore (1,179 rings), 35 have both. Reading OpenRocket’s own values needs its jar run on them as an oracle. A GitHub code search is no help, as .ork files are zipped.
- the private collection’s 714 .ork files (copies included), opened and counted for inner tubes and centering rings set to
-
G19, October 17, 2026, looked at:
- GitHub code search for .CDX1 design files and RASAero II’s export header (“CD Power-Off” with “CN Potential”, “CA Power-Off”, extension:csv)
- the repositories found: anbanpillay/ASRI-PyROPS, rkuhlf/rocket-simulation, activecontrols/Propulsion, stanford-ssi/rockets-irec, spaceconcordia/rocketry-performance, AIAANortheastern/KarmanSims
- the private collection’s RASAero designs, counted only
It found a partial answer: anbanpillay/ASRI-PyROPS@76cd2a46 holds a RASAero II CSV export (rocketpy_migration/data/aerodynamics/rasaero_data.csv) to Mach 5 at 0°, 2° and 4°. Its workbooks Inputs/RASAeroII15 Detailed.xlsx and RASAeroII15.xlsx hold RASAero II output at 0° to 15°, 20° and 25° at Mach 0.1, 0.5, 1.1, 2 and 5. These would check the values assumed past 4° and at 0° faster than Mach 1.3. No license, so cite only; no flight log with them. The other exports found hold 0° only. The private collection has 76 RASAero design files (copies included) and no exports. 12 of their flights carry a log, a few of them past about 255 m/s (837 ft/s) by a plausible logged speed. So RASAero II exports of them would meet the row.
-
G20, October 17, 2026, looked at:
- web searches for measured deployments: onboard video or accelerometer traces of ejection, nose cone and drogue separation
- student post-flight reports (Stanford SSI wiki, NAU capstone)
- Rocket Reviews ejection tests
- the private collection’s logs, counted only
It found nothing usable: the reports describe outcomes, not which end each part left through. The private collection has 227 logs (copies included) on 94 flights with tilt, gyroscope or orientation channels (Blue Raven, AltOS and team loggers). They show how a body pointed at deployment, not which end a part left through, and there’s no video.
-
G21, October 17, 2026, looked at:
- CATS’s EuRoC 2023 team data (github.com/catsystems/euroc23-team-data, GPL-3.0) and the CATS Vega paper (arXiv 2511.04725, ESA symposium 2024), for Cavour, Genesis and Lince
- EPFL Rocket Team’s repositories (EPFLRocketTeam/BellaLui, MorgesHAB/ERT2020GS) and RocketPy’s Bella Lui data, for Bella Lui
It found a partial answer: the Vega paper (§2.4, p. 3) says its one-axis Kalman filter trusts the IMU most during the burn. As the speed falls in the coast, the filter weights the barometer more, so a Vega height near apogee rests mostly on its barometer. The euroc23 ground-station CSVs give only altitude and velocity, and the raw .cfl logs’ layout is published only in GPL code. EPFLRocketTeam/BellaLui (no license, cite only) has driver folders for a BME280 barometer and a BNO055 IMU on the 2020 flight computer. Nothing says which made the logged height; no fin-edge drawings were found for any of the four.
-
G22, October 17, 2026, looked at:
- web searches for measured flutter of hobby-size fins (wind tunnel, ground test, logged failure)
- Cal Poly’s 2013 Fin Flutter Analysis (digitalcommons.calpoly.edu/aerosp/109)
- a 2008 WPI project report
- Dinulović et al., FME Transactions 50(3) 2022 and Aerospace 11(1) 2024 (doi 10.3390/aerospace11010026)
- the same group’s Materials 2025 test of 3D-printed PLA plates, cited in the hardware line’s note
It found a candidate: Dinulović, Rašuo, Slavković and Zajić, ‘Flutter Analysis of Tapered Composite Fins: Analysis and Experiment’, FME Transactions 50 (2022) 576 to 585. In its Table 4, p. 583, five clamped e-glass fins fluttered at 19.6 to 21.5 m/s (64 to 71 ft/s) in a wind tunnel. They’re 0.65 mm (0.026 in) thick, 180 mm (7.1 in) root, 90 mm (3.5 in) tip, 262 mm (10.3 in) span. The paper evaluates TN 4197’s speed on thickness over the mean chord and an effective shear modulus of 7.96 GPa. That gives 15.3 m/s (50 ft/s), 21.9% to 28.8% below. HPR Sim’s reading, thickness over the root chord, gives about 10.7 m/s (35 ft/s) at sea level on that modulus, 45% to 50% below. Both are on the safe side for the speed, on that one fin, which HPR Sim’s deciding check (Martin’s figure 3) doesn’t score yet. The paper is copyright the Faculty of Mechanical Engineering, Belgrade, all rights reserved, so cite only. Its fins are clamped plates at low speed, not fins glued to a tube. The Materials 2025 plates, which fluttered at about 10 to 12 m/s (33 to 39 ft/s), are the same group’s, so not an independent test. The Cal Poly report found no measured flutter speed, and the WPI report says flutter wasn’t tested. The 2024 Aerospace article (CC BY) couldn’t be reached (HTTP 403).
-
G23, October 20, 2026, looked at:
- ThrustCurve.org’s pages, for a license on its motor records: the site’s footer, its API and contribute pages
- the site’s own source repository, JohnCoker/thrustcurve3, with its API client
- GitHub’s other copies of the site’s data
It found no license for the motor records (the home page reserves all rights; the API page states none). A lead: JohnCoker/thrustcurve3 (ISC, commit 3325878d, cached under refs/samples-search/G23) holds a 2016 sample dump of 280 real motor records and 411 curve files. The records have the fields the stand-ins leave out, and each curve file its own class (104 public domain, 16 free, 291 unmarked). ISC grants rights in ‘this software’, so using the records is a licensing question.
-
G23, October 28, 2026, looked at:
- ThrustCurve.org’s contribute, API and privacy pages and its full-text site summary
- openrocket/motor-database and JohnCoker/TCTG
It found no openly licensed motor database. The only license statement is the contribute page’s class for each file, which the API doesn’t return; openrocket/motor-database (GPL-3.0) points other projects to the API.
-
G23, October 29, 2026, looked at:
- ThrustCurve.org’s API: the searches of AeroTech, Cesaroni Technology and Loki Research the tests replay
It found the three answers, of 307, 296 and 60 records, now committed unchanged as published facts with ThrustCurve.org’s credit. Each solid motor’s record is the same, field for field, as in the October 28 snapshot
hpr-motorships; AeroTech’s seven hybrids are not in that snapshot, which holds solid motors only. -
G24, October 17, 2026, looked at:
- public pairs of a design and a log not yet used
- CATS’s EuRoC 2021 team data (github.com/catsystems/euroc21-team-data, GPL-3.0)
- GitHub repository and code searches for EuRoC designs (extension:ork)
- the private collection’s catalog, counted only
It found a partial answer: three loggers’ records of one 2021 flight in euroc21-team-data@ef54912c (STA-CARL2: AltiMAX, RRC3, Eggtimer). No design file was found for it. The private collection pairs a design with a parsing log on 339 flights, 53 of them compared so far. So the samples a held-out set needs exist. RIT-Launch-Initiative/flight-data (MIT) also holds public pairs:
rocket.orkdesigns beside their Featherweight flight logs and an OpenRocket simulation export (2026/AirbrakesL1Tests). What’s missing is the held-out protocol: a set fixed and predictions written before its logs are read. -
G25, October 17, 2026, looked at:
- Apogee Components’ RockSim information page
- OpenRocket’s documentation and wiki on importing and exporting
- The Rocketry Forum threads on RockSim and OpenRocket files
It found nothing usable: no source says whether RockSim opens .ork files. OpenRocket’s documents describe only OpenRocket writing RockSim’s .rkt files. The maker’s page offers RockSim 11 for Mac and Windows with a 30-day trial, so the check needs RockSim itself run on files
hpr convertwrote. -
G26, October 17, 2026, looked at:
- GitHub code searches for RASAero design files of RocketPy’s example rockets (Valetudo, Calisto, Juno III, extension:CDX1)
- RocketPy’s data/rockets folder
- RocketPy-Team/RocketPaper (MIT)
It found a partial answer: no RASAero design file or measured drag curve of any of them was found. RocketPaper@23d9271d holds Valetudo’s real RRC3 log (Valetudo_RRC3/RRC3_original.csv, MIT, with a note that some values make no sense). Valetudo’s RASAero II curve is one of those compared, and a drag could be inferred from its coast once its mass and motor are settled.
-
G27, October 17, 2026, looked at:
- web searches for wind-tunnel or flight measurements of tube fins’ normal force and center of pressure (NARAM R&D reports, DTIC, NTRS)
- PSAS’s fin design references
- the private collection’s .ork files, counted only
It found no wind-tunnel or flight measurement of a tube fin’s lift or center. The private collection has 8 .ork files (copies included) with a tube fin set. 1 of their flights has a parsing log, which can check an apogee but not the lift or center.
-
G28, October 17, 2026, looked at:
- NTRS, for reports on flared bodies
- NASA TM X-653 (Jorgensen, Spahr and Hill, 1962)
- NASA TM X-30 (Kirk and Chapman, 1959)
- NACA RM A57I30 (Dennis, 1957)
- NACA RM L57J29 (Kehlet, 1958)
- the Redstone Arsenal reports TM X-30 draws on
It found candidates, all US government work, public use permitted. TM X-653 measured normal-force slope and center of pressure of sharp and blunted cone-cylinders with 10° and 20° conical flares. Its range is Mach 0.60 to 5.82 (figs. 4 and 6). Its 20° flare separated at Mach 1.20 and 1.37 (fig. 7), below the speed where a 20° wedge’s shock attaches. So it covers a flare past its corner’s limit. TM X-30 gives flare-alone normal-force slopes and centers for 80 cone-cylinder-flare bodies with flares of 5° to 20° at Mach 2.18, 2.81 and 4.04. It sets them beside the second-order shock-expansion method. RM A57I30 measures flares at Mach 3.0 to 6.3; RM L57J29 has no force data. The Redstone reports 6R3P, 6R3N2 and 6R3N1 weren’t found online.
-
G29, October 17, 2026, looked at:
- NTRS, for measured supersonic forces on boattailed and blunt-nosed bodies
- NACA RM A52E22 (Dennis and Cunningham, 1952)
- NASA TM X-653 (1962)
- NASA TN D-916
- NACA RM E54B11 (Moskowitz and Jack, 1954), which the project already holds
It found candidates, US government work, public use permitted. RM A52E22 tabulates lift, drag and moment against angle (tables V to VIII) for 3/4-power and 1/2-power blunt bodies of fineness 3 and 5. They’re at Mach 2.75 to 5.00, blunt tips that aren’t sphere-cones. RM E54B11’s table I gives pressure coefficients by meridian at 3° and 9° over four boattails at Mach 3.12. The boattail’s own share of the normal force can be integrated from it, though the project uses it only for drag. TM X-653’s blunted nose is another sphere-cone.
-
G30, October 17, 2026, looked at:
- GitHub code search for flight-log CSVs
- CATS’s EuRoC 2021 team data (github.com/catsystems/euroc21-team-data@ef54912c, GPL-3.0)
- Rocketronics’ AltiMAX manuals, already held
- the private collection’s AltiMAX files, counted only
It found a candidate: STA-CARL2/sta-carl2-altimax/sta-carl2-altimax.xls, a second real AltiMAX Excel export (9,940 rows, GPL-3.0, cache under refs/ only). Its header and events are in German (
ZEIT,RAMPE); an RRC3 and an Eggtimer log of the same flight come with it. Of its five voltage channels, one stays near 0.5 V and one holds about 8.2 V throughout. Two fall from about 7.7 V to about 0.5 V within 0.1 s after the export’s own pyro events (24.9 s and 123.1 s). The RRC3 logs its drogue at 23.8 s, the AltiMAX’s apogee time, and its main at 121.4 s. That checks the voltages’ behavior and their tie to the flight, not a second measurement of the same battery. The private collection has one AltiMAX Excel export. -
G31, October 17, 2026, looked at:
- GitHub code search for RRC3 exports (“Temperature Events Voltages” extension:csv)
- CATS’s EuRoC 2021 team data (GPL-3.0)
- RocketPy-Team/RocketPaper (MIT)
- RocketPy’s Juno III data
- the private collection’s RRC3 logs and the other loggers on their flights, counted only
It found a partial answer: euroc21-team-data@ef54912c’s STA-CARL2 RRC3 export states no units. Its altitude is in meters and its pad temperature 36.1. No other logger on that flight records temperature. RocketPaper@23d9271d’s real Valetudo RRC3 file states
Temperature [°C]beside both a feet and a meters altitude column. In the private collection, 90 RRC3 CSVs (copies included), 4 with bracketed units. -
G31, October 20, 2026, looked at:
- public flight-log repositories on GitHub, and airport weather records
It found two RRC3 exports in feet, one in °C by three other sensors on its flight and one in °F by its airport’s air, named in §4 of the public-logs note. Their voltages fit volts, a weak check.
-
G32, October 17, 2026, looked at:
- the public logs the sensor noise note measured at rest (five Blue Raven flights, ten StratoLoggerCF, five AltOS, one RRC3, one team-built board)
- the makers’ datasheets it cites
It found pad and rest noise for four families, upper bounds that mix in wind and handling, and the datasheets’ white noise. It found no family’s noise measured over a whole flight, and no hobby receiver’s GNSS loop measured against a truth.
-
G33, October 31, 2026, looked at:
- prs2026/Procyon, a repository new to this search (no license)
- the private collection, by file hash
It found one flight on June 7, 2026 with a Blue Raven and a TeleMetrum v4.0 logging barometer and accelerometer, and a Featherweight tracker’s GPS beside them. Barometer peaks agree within 2.5 m (8.2 ft); GPS peaks read 4% to 5% higher. No radar or optical record. It has no license, so it is cited on the issue and cached under refs/samples-search/G33 only.
-
G34, October 31, 2026, looked at:
- prs2026/Procyon, a repository new to this search (no license)
- Harvard Dataverse, Figshare, Zenodo and arXiv
- web searches for a hobby rocket’s apogee measured by radar or optical tracking
It found one flight on June 7, 2026 with two barometric loggers and two GPS receivers, each with its own record of the peak and times. It has no license, so it is cited on the issue and cached under refs/samples-search/G33 only. No radar or optical record of a flight.
-
G35, November 2, 2026, looked at:
- AerospaceNU/rocket-flight-data’s October 31, 2026 flight, added on November 2 and 3, 2026 (commit c939c32b, GPL-3.0)
- GitHub code search for
extension:pf2(250 hits in 31 repositories) - rlhatcher/rocketry-files (MIT, commit 2ddcaf88)
It found a real pair whose clocks differ by about 4,028 s. On the October 31, 2026 flight two of the club’s boards count from their own power-on: one logs GPS time beside its clock, the other has no GPS. Liftoff (over 3 g) falls at 5,331.6 s and 1,303.6 s on the two clocks, and each board’s peak about 19.7 s after it. It is GPL-3.0 data, so it is cached under refs/samples-search/G35 only, to report statistics and digests. The pairs in the
.pf2hits and rlhatcher/rocketry-files both start at the boost. -
G36, November 2, 2026, looked at:
- GitHub code search for
extension:pf2(250 hits in 31 repositories) andextension:telem(17 hits, every rocketry repository already named in the project’s notes) - GitHub code search for CSV files with booster and sustainer words
- GitHub repositories pushed since October 30, 2026 with rocket words
- a web search for a two-stage flight’s booster log
It found no log from each stage of one flight. No
.pf2or telemetry file is named for a booster or sustainer, and the CSV hits are not rocket logs. - GitHub code search for
-
G37, November 2, 2026, looked at:
- GitHub code search for CZML files with rocket words (316 hits) and with apogee or altimeter (none)
- GitHub code search for glTF binaries of a rocket’s flight path (none)
It found no other program’s CZML or glTF of a real rocket flight to set beside a ghost file. The CZML hits are Cesium demos and satellite orbits. A look in Cesium still needs a person.
-
G38, November 2, 2026, looked at:
- NASA Student Launch post-launch reports, by a web search
- Florida State University Panama City’s 2026 post-launch report (no terms stated)
- Zenodo, Dryad and Hugging Face for rocket flight data
It found a lead with no log. The Florida State report states the launch-ready vehicle’s final mass, its sections’ weights, the wind speed and a TeleMetrum’s apogee, but publishes no log or motor test. It is cited only, cached under refs/samples-search/G38. The data sites hold no flight log with a weighed mass, a static test or a measured wind.
-
G39, November 10, 2026, looked at:
- RocketPy v1.13.0’s example notebooks for the three flights (astra_flight_sim.ipynb, andromeda_flight_sim.ipynb, erebus_flight_sim.ipynb)
- each flight’s folder under RocketPy’s data/rockets
It found no answer. Each notebook imports its log under the name COTS Altimeter Flight and names no make or sensor; Astra’s also labels the series Telemetry. The folders hold the log, a drag curve and, for two, a thrust file. The logs are a time and a height (Astra’s with a position, Andromeda’s with a vertical speed), and none has a header naming a device.
-
G40, October 16, 2026, looked at:
- NASA TR R-100 (Stoney, 1961), for a tangent ogive among its fineness-3 noses
- NACA Report 1386 (Perkins, Jorgensen and Sommer) and NACA TN 3716 (Perkins and Jorgensen), for measured pressures on tangent ogives
- AFATL-TR-77-8 (Butler, Sears and Pallas, 1977)
- NACA Report 1306, NACA TN 2250 and NACA TN 2399
It found four NACA and Air Force reports that give a tangent ogive’s pressure drag past Mach 1.3, one of them, NACA Report 1386, with a point at Mach 1.24 too; TR R-100 holds no ogive. They are read in docs/research/ogive-wave-drag.md, with the note’s own arithmetic to take friction out, and none is committed as data yet.
-
G41, November 20, 2026, looked at:
- NASA TR R-100 (Stoney, 1961) and Hoerner’s Fluid-Dynamic Drag (1965), for a subsonic rule for the base behind a boattail
- NACA RM E54I13 (Salmi) and NACA RM L51L03 (Stoney), for measured base pressures behind cones held without a rear sting
It found a rule and three measurements. TR R-100 gives the base drag of a conical afterbody as the cylinder’s times (r_b/R) cubed on the largest cross-section, and Hoerner’s eq. 35 has the same dependence. Salmi’s jet-off base pressures behind 5.6° cones at Mach 0.9 and Stoney’s free-flight body from Mach 0.6 to 0.85, read by eye, both put the base drag below that rule, as the Hermes A-3A’s flight does. None is a hobby rocket.
Real samples. Each file a real row reads, kept under refs/, with its SHA-256 and the test that reads it:
- G23:
refs/snapshots/thrustcurve/2026-10-28/search.json, SHA-2566fac854e349521f526c2f8cafadb91b23c91527261380a9461c27a7af892f510; ThrustCurve.org’s answer to a whole-catalog search, recorded unchanged on October 28, 2026 byvalidation/oracles/thrustcurve/snapshot.py; its records used as published facts with ThrustCurve.org’s credit; read byfusionspace-hpr-net’s testeach_record_is_the_raw_snapshots_own. - G37:
refs/rocketpy/data/rockets/NDRT_2020/ndrt_2020_flight_data.csv, SHA-2565e64b446199988ac183b2f3965d76da27e57496bb2a33f78df73aa23fd18d7b8; MIT, RocketPy’s repository; read byfusionspace-hpr-cli’s testanalyze_writes_a_ghost_of_each_of_rocketpys_logs. - G37:
refs/rocketpy/data/rockets/andromeda/flight_data.csv, SHA-256ebd3b757555b564c63937b69d2c222d6596355fc6e938d49537af293a9d48d14; MIT, RocketPy’s repository; read byfusionspace-hpr-cli’s testanalyze_writes_a_ghost_of_each_of_rocketpys_logs. - G37:
refs/rocketpy/data/rockets/juno3/cots_altimeter.csv, SHA-256eef81b3bcc4c285667727c1e2c9ca502a67cb374f5e31bc4f87ed76b8a04c1ee; MIT, RocketPy’s repository; read byfusionspace-hpr-cli’s testanalyze_writes_a_ghost_of_each_of_rocketpys_logs. - G37:
refs/rocketpy/data/rockets/prometheus/2022-06-24-serial-5115-flight-0001-TeleMetrum.csv, SHA-2569fe8d17a25e7944267b34a45ed955303afd5818b3f18479a5f7ffb31a574cecf; MIT, RocketPy’s repository; read byfusionspace-hpr-cli’s testanalyze_writes_a_ghost_of_each_of_rocketpys_logs. - G37:
refs/rocketpy/data/rockets/prometheus/2022-06-24-serial-6583-flight-0003-TeleMega.csv, SHA-256befe40714e6b88b3bd5af8cd51b569a94544c486ced299878f66ab264f9105a6; MIT, RocketPy’s repository; read byfusionspace-hpr-cli’s testanalyze_writes_a_ghost_of_each_of_rocketpys_logs. - G37:
refs/rocketpy/data/rockets/EPFL_Bella_Lui/bella_lui_flight_data_filtered.csv, SHA-256ccf8bcecd91d5b912e8f8b3bcf9efe13248453e1a81dc79d2b4daea4e985de2d; MIT, RocketPy’s repository; read byfusionspace-hpr-cli’s testanalyze_writes_a_ghost_of_each_of_rocketpys_logs. - G37:
refs/rocketpy/data/rockets/astg/altimeter_halcyon.csv, SHA-2567f1fec2faa53f63a183c97d8a9b692763e7b53d60eab15cc6f42ab646afa85a0; MIT, RocketPy’s repository; read byfusionspace-hpr-cli’s testanalyze_writes_a_ghost_of_each_of_rocketpys_logs. - G37:
refs/rocketpy/data/rockets/astg/gnss_halcyon.csv, SHA-2561a4715c45c85671c41fd8b3a870a9650548e7e5bae70c781c5e34f054090862f; MIT, RocketPy’s repository; read byfusionspace-hpr-cli’s testanalyze_writes_a_ghost_of_each_of_rocketpys_logs. - G37:
refs/rocketpy/data/rockets/astra/flight_data.csv, SHA-256dd5287b375e84be8961a7c867dc9af764a42752af3109c25086d228978e4acae; MIT, RocketPy’s repository; read byfusionspace-hpr-cli’s testanalyze_writes_a_ghost_of_each_of_rocketpys_logs. - G37:
refs/rocketpy/data/rockets/camoes/flight_data.csv, SHA-2568ceb1a196901569e32a6e9f09067feebb5ca1406d686e402f726e715a1be1dcc; MIT, RocketPy’s repository; read byfusionspace-hpr-cli’s testanalyze_writes_a_ghost_of_each_of_rocketpys_logs. - G37:
refs/rocketpy/data/rockets/camoes/gnss_flight.csv, SHA-256ea6129167650b503477282e6dd2864530145bc33a26487a612dcfc4e781f99e6; MIT, RocketPy’s repository; read byfusionspace-hpr-cli’s testanalyze_writes_a_ghost_of_each_of_rocketpys_logs. - G37:
refs/rocketpy/data/rockets/erebus11/flight_data_filtered.csv, SHA-256045f5b9ed473b80095805d3ca7b831ca4b67c5afbe9156d58d1e91df9fc0b4a9; MIT, RocketPy’s repository; read byfusionspace-hpr-cli’s testanalyze_writes_a_ghost_of_each_of_rocketpys_logs. - G37:
refs/rocketpy/data/rockets/genesis/flight_data_faraday.csv, SHA-256d88a7fc53cbd55d1dafeed5d5c6fcfcad27c7cf8e0a15221e67aae97eaa05a74; MIT, RocketPy’s repository; read byfusionspace-hpr-cli’s testanalyze_writes_a_ghost_of_each_of_rocketpys_logs. - G37:
refs/rocketpy/data/rockets/genesis/gnss_faraday.csv, SHA-2565843d20becfb8cda3246f7ebbca2e090579ffffd5ac148ae3519be91a0c7b90b; MIT, RocketPy’s repository; read byfusionspace-hpr-cli’s testanalyze_writes_a_ghost_of_each_of_rocketpys_logs. - G37:
refs/rocketpy/data/rockets/hedy/cats_tust/filteredDataInfo.csv, SHA-256a5fe9e1a760a17a8c22c920097f3658e00b42030bca7f44123e20d5425fa0d9b; MIT, RocketPy’s repository; read byfusionspace-hpr-cli’s testanalyze_writes_a_ghost_of_each_of_rocketpys_logs. - G37:
refs/rocketpy/data/rockets/hedy/cats_tust/flightInfo.csv, SHA-256481375091cf0da74fd1d933189546d9b846b3ca54b4c29f90d4a90f40b5f7731; MIT, RocketPy’s repository; read byfusionspace-hpr-cli’s testanalyze_writes_a_ghost_of_each_of_rocketpys_logs. - G37:
refs/rocketpy/data/rockets/hedy/cats_tust/gnssInfo.csv, SHA-2568ab7e041385698a4adab7d9abbd3c985c5a38b42ead8667a5b53fc9223cbcbc3; MIT, RocketPy’s repository; read byfusionspace-hpr-cli’s testanalyze_writes_a_ghost_of_each_of_rocketpys_logs. - G37:
refs/rocketpy/data/rockets/juno3/cots_GNSS.csv, SHA-256557c80be4c0d9a5e6a5493177a9adfaa3b02c11b8ff814ed238b53540ac9f062; MIT, RocketPy’s repository; read byfusionspace-hpr-cli’s testanalyze_writes_a_ghost_of_each_of_rocketpys_logs. - G37:
refs/rocketpy/data/rockets/juno3/srad_telemetry.csv, SHA-2568cff1691d9a89bfccdb3a85f1a55ac26432b220c64e1c4c80cd7df16077af39c; MIT, RocketPy’s repository; read byfusionspace-hpr-cli’s testanalyze_writes_a_ghost_of_each_of_rocketpys_logs. - G37:
refs/rocketpy/data/rockets/lince/main_data.csv, SHA-256a9cf47fe2b2e5be03168d36b1c41f0a5651a0c3b6db4ed091e1afc274bd7473e; MIT, RocketPy’s repository; read byfusionspace-hpr-cli’s testanalyze_writes_a_ghost_of_each_of_rocketpys_logs. - G37:
refs/rocketpy/data/rockets/polito/altimeter_cavour.csv, SHA-256f912724676eea0ca9ba031c3779e48f861538814170b050b7bda2887c31f29a8; MIT, RocketPy’s repository; read byfusionspace-hpr-cli’s testanalyze_writes_a_ghost_of_each_of_rocketpys_logs. - G37:
refs/rocketpy/data/rockets/valkyrie/flightInfo_merged.csv, SHA-2560c7808a84fb39c83908ba9caa1d2d3ccb609d6db46c3d660b85977e6917795bc; MIT, RocketPy’s repository; read byfusionspace-hpr-cli’s testanalyze_writes_a_ghost_of_each_of_rocketpys_logs.
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.
The API reference
Find which crate of FusionSpace HPR holds what, and reach each crate’s rustdoc reference for every public type, function and constant.
The API reference documents FusionSpace HPR’s code: every public type, function and constant,
generated from the source by rustdoc, Rust’s documentation tool. Use it when you write a program
with the hpr library, as Getting started does. The library is released (0.1.0)
but not yet at 1.0, so none of its interface is stable: any of it can change. The simplest way in is the hpr
crate’s builder (The builder).
Where to read it. On the site, the crate names below open the reference. On GitHub they lead nowhere, because the reference is built rather than stored in the repository. Build it on your own machine instead:
cargo doc --workspace --no-deps --open
That opens one crate’s front page; the others are in the list of crates on the left. cargo xtask site builds this whole site, with the reference beside the guide.
The crates
The code is split into crates, Rust’s packages, so that a program takes only
what it needs. The split also lets the models, which don’t read or write files or use the network,
build for the web. Eleven crates hold most of the code today. The names below are the ones a
program writes in its code (use hpr_core::…). A published crate’s package, the name crates.io
and Cargo.toml know it by, adds FusionSpace’s prefix
(the public name).
So hpr is the package fusionspace-hpr, hpr_core is fusionspace-hpr-core, and so on.
hpr_validate, hpr_py, hpr_ffi and hpr_wasm aren’t published.
| crate | what it holds | limits and open work | the guide’s pages |
|---|---|---|---|
hpr | One crate to depend on: the builder for environments, motors, rockets and flights, with the other crates re-exported by name (more below) | One motor per built rocket | The builder, Models of your own |
hpr_core | Vectors and quaternions (a compact way to store a rotation), frames, the Earth’s shape, distance and bearing between places, gravity and magnetic field, interpolation tables and numerical integration of functions | Frames, Geodesy, Gravity, The magnetic field, Interpolation tables, Adaptive quadrature | |
hpr_atmos | The standard atmosphere, humidity, soundings, wind profiles and turbulence | A flight doesn’t use the turbulence yet | Atmosphere, Wind, Turbulence |
hpr_motor | Solid motors: thrust curves, mass and inertia through the burn, .eng and .rse files, and ThrustCurve.org’s whole solid catalog, bundled | Hybrid and liquid motors, which are out of scope | Solid motors, .eng files, .rse files |
hpr_design | The rocket: its tree of parts, their shapes and materials, mass properties and design checks | The design tree, Shapes, Mass properties | |
hpr_format | The HPR design format: a design as one JSON document (.hpr) with its JSON Schema, read from and written to .ork, in a zip container with other files (.hprz), older versions migrated | None. Its TypeScript and Python types are done, outside the crate | The HPR design format |
hpr_aero | Aerodynamics: normal force, center of pressure and drag to Mach 5, tables from other programs for the drag and the normal force, and drag models of your own (Models of your own) | Faster than sound, some shapes are checked on one case or not at all, and some use a theory that reads low past Mach 3 (below) | Aerodynamics |
hpr_sim | The flight: the launch rail, the equations of motion, time integration, events and recovery | Staging, air starts and clusters are checked by tests and against OpenRocket, a dropped stage’s own flight not at all, and parts that leave the airframe against exact answers only (below) | How a flight is simulated, Rigid-body flight, Time integration, Recovery, Staging |
hpr_flightdata | Reading a flight log on its own, with no design and no simulation, and the readings taken from it (below) | Not yet: formats no sample holds (listed as needing samples, evidence row G9); readings from a GPS track; the top acceleration from a board’s three axes (#781); the Mach number; a 90% interval on each reading | Reading a flight log, Flight-log readings, .pf2 files, Flight logs |
hpr_validate | The validation harness: cases, whole flights against RocketPy among them, reference data, metrics and reports | None | Accuracy, Checking a claim |
hpr_py | The fusionspace-hpr Python package (fusionspace.hpr): the builder’s environment, motor, rocket and flight from Python (more below) | Python |
Six more crates are partly built or not yet begun, and each front page says what it will hold.
hpr_ffi and hpr_wasm hold no code yet; the other four already hold some:
| crate | what it holds or will hold | done and planned |
|---|---|---|
hpr_io | Import and export of OpenRocket, RockSim and RASAero designs, export to RocketPy, OpenRocket’s parts catalog, and weather and elevation files (below) | Done: reading a .ork and its parts, writing one, ERA5 files and the parts catalog; RockSim, RASAero and RocketPy files next |
hpr_net | Optional online data, cached for offline use: weather, soundings, elevation and motor data (below) | Done: the cache, Open-Meteo’s weather, soundings, GFS and RAP, hpr weather, whole GRIB2 files in complex packing and JPEG 2000, elevation and motor stock |
hpr_analysis | Monte Carlo dispersion, sensitivity analysis and optimization (below) | Monte Carlo done; optimization done, EGO on six variables too, but for robust designs; competition rules not yet |
hpr_forensics | A flown flight against a simulation of it: what will differ, what that says about drag, mass, impulse and wind, and what went wrong | Planned: residuals and fits to a log and diagnosis |
hpr_ffi | A C interface, for other languages | Planned: use from C and in the browser |
hpr_wasm | WebAssembly bindings, for the browser | Planned: use from C and in the browser |
The command-line tool, the package fusionspace-hpr-cli, is a program rather than a library, so it has no reference here.
The command line documents its commands, output and exit codes.
The builder crate
hpr holds the builder and re-exports the other crates by name. A rocket’s parts can be made
from catalog parts (parts from a catalog). A drag model
of your own can fly in the simulator’s place.
hpr::ork::separation turns a .ork file’s staging into a
flight’s separation (example).
The reference holds a guide too, hpr::guide.
Aerodynamics faster than sound
Faster than sound, what hpr_aero flies depends on the body’s shape:
- A pointed nose, its cylinder and a boattail behind them take the shock-expansion method. The boattail’s share is unvalidated (evidence row G29).
- A blunt or vertical tip flies the method behind a Newtonian cap, checked on a sphere-cone only.
- A conical flare flush with the part ahead of it flies the method too and ends the run. It’s checked against one measured flare.
- Any other widening shape, or any step, behind the nose keeps slender-body theory, which reads low past Mach 3.
Staging, clusters and parts that leave
- Staging and air starts fly. Tests check them, and so does a comparison with OpenRocket’s two-stage, cluster and air-start examples. Each flight is within 5% of OpenRocket’s in apogee and largest speed (a two-stage and a cluster design against OpenRocket). Three cluster apogees are compared with OpenRocket’s flight with no parachute, since its parachute opened before apogee. The flight of a dropped booster or middle stage after its split isn’t validated at all (evidence row G13).
- A cluster flies, one mount of several tubes or one mount per motor, and so does a motor out. Tests check them against a hand calculation.
- A nose cone, a section or a payload can leave the airframe, optionally pushed by its charge. It lands on its own, under its own parachute or tumbling (ejection, the airframe parting, a charge’s push). This is checked against exact answers only.
Flight logs
hpr_flightdata reads a flight log on its own, with no design and no simulation, into one record.
It keeps every column but those a table pasted over a FIP sheet covers, and reads the files of a
zip archive one by one. Depend on this crate directly rather than on hpr, which pulls in the
simulator. It reads:
- PerfectFlite’s
.pf2and exports, and PerfectFlite’s older.pfa. - AltOS’s CSV, its radio telemetry (
.telem) and raw downloads (.eeprom), and its radio telemetry decoded to a table. It also reads AltOS’s CSV re-saved by a spreadsheet, its formulas kept as text, or cut to its columns. - The Raven’s FIP CSV and the Blue Raven’s, and the Raven’s
.FIParaw download. - A Raven FIP export pasted below no header, under a header you state.
- A Blue Raven’s USB download, each line held to its CRC.
- RRC3’s CSV and the RRC3’s
.rffraw download. - Eggtimer’s CSV, an Eggtimer TRS’s terminal text, and an Eggtimer’s download saved as RTF.
- AltimeterCloud’s CSV.
- Entacore AIM’s CSV, its
.xtrafiles and raw memory dumps. - AerospaceNU’s SillyGoose logs, and AerospaceNU’s flight computer board’s CSV and its ground station’s text.
- Silicdyne Fluctus’s CSV.
- The ARTS2’s interpreted data, its
.odfand its raw CSV. - A phone app’s
launchCSV. - The Featherweight app’s flight summaries (the logger’s figures, no samples).
- The R-DAS’s raw text (its counts kept as written).
- An AltiMAX altimeter’s
.xlsexport and its own.ALSfile. - A MARSA altimeter’s download.
- A course’s Teensy data logger, and one team’s radio telemetry packets,
255:…:254. - GPS tracks from Featherweight’s GPS CSV, KML, NMEA and Missile Works’ RTx (its
.rtxfile and exports). - GPS tracks in GPX, checked on invented files only (evidence row G1).
- Tables from loggers no other reader knows, by the units their headers state.
- Binary records, from a raw file or a console capture, by a layout you state.
- Tables whose headers state too little, by a column mapping you state. Such a table may have a clock that turns over, rows written as lists or behind a date and time, or columns left out.
From any logger’s barometric altitude or pressure it reads liftoff, apogee, the top speed,
landing, the flight time and the descent under each canopy. From an accelerometer along the
rocket’s axis it reads the top acceleration and burnout. Each reading comes within a stated
bound, or is withheld with the reason. A top acceleration that clipped, or whose thrust the
accelerometer shows no end to, is a floor. Clip says why it clipped: at the
part’s range, or held flat at its top.
The Python package
hpr_py builds the builder’s environment, motor, rocket and flight from Python. It flies
a drag table and RocketPy’s example flight and takes
a drag and a wind written in Python. It reads designs from
files and returns a flight’s recording as NumPy arrays. Maturin builds it into one wheel per
operating system, and it’s on PyPI as fusionspace-hpr.
Design and data files
hpr_io reads and writes design files, and reads weather and elevation files:
- OpenRocket’s parts catalog: its 16
.orcfiles are bundled, every part found by maker and part number (the format page). - A
.orkfile’s container, design document and components are read into a design (the format page). So are its motors, when each lights, and its recovery settings. - A design is written back out as a
.orkwithhpr_io::ork::export(writing a.ork). - An ERA5 weather file (netCDF classic) gives the atmosphere over a launch site at launch time (ERA5 weather files).
- A GeoTIFF elevation file gives a site’s height (A launch site’s elevation).
Each powered separation in a .ork comes out as a
Staging, from the tail forward
(MotorConfiguration::stagings). A powered separation’s time is known before the flight. At that
time a motor ahead of it is still burning or yet to light. None behind it is, but at a stage’s
first burnout its own other motors may still burn, and they drop burning. A separation may have
nothing ahead of it left to burn, as when the sustainer has burnt out by the split. Such a
separation is read only when it’s the configuration’s only one. The other separations that could come before apogee
are refused. The configuration’s rocket doesn’t carry the Staging. These functions in hpr carry it,
and the recovery settings, into the flight:
hpr::ork::separationturns one into the flight’s separation, andhpr::ork::separationsa configuration’s list. You pass the list to the flight yourself, with a recovery device on each part, since the simulator refuses the flight without them (example).hpr::ork::recoveryturns a configuration’s parachutes and streamers into the flight’s recovery devices, as OpenRocket flies them (Recovery).hpr::ork::separated_recoveryputs each on its part when the configuration separates, ashpr simflies it.
Online data
hpr_net’s cache, offline mode and HTTP work today; HTTPS is checked by hand but not in CI
(Online data and the cache). It has five sources:
- Open-Meteo’s weather (Launch-day weather).
- Weather-balloon soundings (Weather-balloon soundings).
- NOAA’s GFS and RAP forecasts (NOAA forecasts: GFS and RAP).
- Open-Meteo’s ground elevation (A launch site’s elevation).
- motor.fusionspace.co’s motor stock and prices (Motor stock and prices).
Analysis
hpr_analysis holds:
- Monte Carlo dispersion (flying many copies of a flight with randomly scattered inputs), the spread of its results, and landing ellipses (Monte Carlo dispersion).
- Sensitivity analysis, Morris screening and Sobol’ indices (Sensitivity analysis).
- Optimization (Optimization). CMA-ES searches over numbers and choices such as a motor, within limits such as a minimum margin. NSGA-II takes two goals at once. EGO (efficient global optimization) is for models too slow for more than tens of evaluations. On a rocket, each gives answers only as good as the simulator’s flight models.
- Planned: competition rule files.
Using it from your own program
Release 0.1.0 is on crates.io, Rust’s public package registry. cargo add fusionspace-hpr adds
the front door, which your code calls hpr and which re-exports the crates under it. Its features
net, parquet and parallel add the online data sources, Parquet export and Monte Carlo on
worker threads (Install a release). Until 1.0, a
new minor version, such as 0.2, may change the API.
To follow main instead of a release, a program outside this repository can depend on a crate
straight from GitHub. Pin it to a commit, since anything can change between commits. Take its hash from
the history of main, and change it only on
purpose:
[dependencies]
fusionspace-hpr = { git = "https://github.com/nrdptel/fusionspace-eridanus", rev = "<commit>" }
Cargo finds the crate in the repository by its package name, fusionspace-hpr; your code still
says use hpr::….
Reading it
- Names. Code names a crate with underscores (
use hpr_sim::Simulation;), andCargo.tomlandcargo -pname its package with hyphens and thefusionspace-prefix (fusionspace-hpr-sim). They’re the same crate. - Search. The search box at the top of every reference page, or the S key, finds a type or function in any crate.
- Source. Each item’s Source link shows the code it documents.
- Links to the guide on the crates’ front pages go to the published site,
https://hpr.fusionspace.co/; the same pages are in the repository’s
docs/folder.
How a release is built
See what a FusionSpace HPR release holds, which license files come with it, how each is checked, and how to check one yourself.
Release 0.1.0 came out on October 8, 2026. One workflow builds each release, every file of it from
one commit. It tests each file as you would get it, and publishes nothing until Neer Patel, who
owns the project, approves. The building and checking run when the workflow is started by hand.
They also run on every pull request that changes the workflow or its scripts (scripts/release/).
The publishing steps first ran for 0.1.0, on October 8, 2026.
What a release holds
A release has one version for everything in it, and its title is FusionSpace HPR <version>.
Release 0.1 is the simulator: the library, the hpr command line and the Python package
(the release plan).
The changelog has each version’s
entry: what it holds, what works, how far to trust it, and its known gaps.
Install a release says how to install each file.
| File | What it is | Where it goes |
|---|---|---|
fusionspace-hpr-<version>-x86_64-unknown-linux-gnu.tar.gz | the hpr command line for Linux on x86-64 | the GitHub release |
fusionspace-hpr-<version>-aarch64-unknown-linux-gnu.tar.gz | the command line for Linux on 64-bit ARM, such as a Raspberry Pi 4 or 5 on a 64-bit system | the GitHub release |
fusionspace-hpr-<version>-aarch64-apple-darwin.tar.gz | the command line for Macs with Apple silicon | the GitHub release |
fusionspace-hpr-<version>-x86_64-pc-windows-msvc.zip | the command line for Windows on x86-64 | the GitHub release |
fusionspace-hpr-<version>-aarch64-pc-windows-msvc.zip | the command line for Windows on ARM | the GitHub release |
fusionspace_hpr-<version>-cp310-abi3-<platform>.whl | the Python package, one wheel per platform, for CPython 3.10 and later (3.11 on Windows on ARM, its oldest); it imports as fusionspace.hpr | PyPI, as fusionspace-hpr, and the GitHub release |
fusionspace_hpr-<version>.tar.gz | the Python package’s source; installing it compiles it, so it needs Rust | PyPI and the GitHub release |
fusionspace-hpr.rb | the Homebrew formula for the Mac and Linux archives, from release 0.2; 0.1’s was written afterwards by the same script and put in the tap by hand | the GitHub release, then the tap |
fusionspace-hpr.json | the Scoop manifest for the Windows archives, from release 0.2; 0.1’s was written afterwards by the same script and put in the bucket by hand | the GitHub release, then the bucket |
| 14 crates | fusionspace-hpr, the library’s front door, the 12 fusionspace-hpr-* crates under it, and fusionspace-hpr-cli, the command line | crates.io |
Each file is built and tested on the platform it’s for, on that platform’s own CPU
(the six platforms).
Five of the six run now: Linux and Windows, each on x86-64 and on 64-bit ARM, and Macs with Apple silicon. Release
0.1 had the x86-64 Linux, Apple silicon and x86-64 Windows files only. The ARM Linux and ARM
Windows files start with release 0.2. Intel Macs follow
(issue #438). Anywhere else,
pip install builds the Python package from its source package, which needs
Rust.
The Linux files run on the GNU C library (glibc) 2.17 or later. That’s the floor of the
manylinux2014 wheel standard and of Rust’s own Linux target:
RHEL and CentOS 7, Debian 8, Ubuntu 14.04 and anything newer. A program built the usual way asks
for the build machine’s own glibc. So the Linux archive and wheel are linked by
Zig instead, which carries the old library’s list of functions. The
command line is built by cargo-zigbuild, and the
wheel by maturin’s --zig option, tagged manylinux_2_17. A wheel that
calls a newer function is refused by maturin. The versions are pinned in
scripts/release/linux.sh: cargo-zigbuild 0.23.4 and Zig 0.16.0, both fetched from PyPI by uv.
Four crates and the repository’s own tool stay unpublished. hpr-py reaches Python users as the
wheels. hpr-ffi and hpr-wasm wait for their milestone. hpr-validate, the validation harness,
needs a copy of the repository, its cases and their references. To re-run its check, clone the
repository and run cargo xtask validate --check (Accuracy).
The license files
Each archive, wheel and source package carries four license files. LICENSE-MIT and
LICENSE-APACHE are the project’s two licenses, either at your option. THIRD-PARTY-NOTICES.md
lists every outside source the project uses, such as bundled data. THIRD-PARTY-LICENSES.txt holds
the license texts of the Rust crates compiled in. An archive has them beside hpr. A wheel has them
in its metadata folder, fusionspace_hpr-<version>.dist-info/licenses/, where
pip show -f fusionspace-hpr lists them.
Each crate on crates.io carries LICENSE-MIT and LICENSE-APACHE, since the Apache license
asks that everyone who gets the code gets its text. Cargo packs only the files in a crate’s own
folder, so each published crate’s folder holds a copy of the two. cargo test -p xtask fails if a
copy differs from the repository’s by a byte.
THIRD-PARTY-LICENSES.txt is written for each build by
cargo-about from the crates’ own license files. It
lists each license once, with its text and the crates that use it. Built on October 6, 2026, the
command line’s file listed 114 crates under 7 licenses, 100 of them from outside the project. The
Python package’s listed 90 under 5, 77 from outside. A crate may appear under several texts, as
ring does under 18 ISC notices. The licenses cargo-about accepts are the ones the project’s
dependency check allows, all permissive. So a crate under any other license stops the build.
How each file is checked
Each file is unpacked or installed in an empty folder and run, as a user would get it. A copy of the repository provides the example design:
- An archive must hold
hpr, the README and the four license files, with the texts namingclap, a crate the command line is built on.hpr --versionmust name the release’s version, andhpr motors show H54must read the bundled motor catalog.hpr sim validation/fixtures/ork/pod-flights/pods-none.ork --motor H54must reach 846.1 m (2,776 ft) above the site, within a meter. That’s the apogee the command line’s page prints for that example. - A wheel or the source package is installed into fresh environments on Python 3.10 (3.11 on
Windows on ARM) and 3.13. It must carry the four license files and the release’s version, with
the texts naming
pyo3, the crate that binds Rust to Python. The first example on the Python page must reach 1,118.3 m (3,669 ft), within a meter, as that page prints. - The Windows archive’s
hpr.exemust need no Visual C++ runtime, which a clean Windows may lack.scripts/release/check_windows_runtime.pyreads the program’s import tables. It fails if one namesVCRUNTIME140.dllor another DLL that only Microsoft’s Visual C++ Redistributable installs.- From release 0.2,
scripts/release/archive.shlinks the C runtime into the Windows program (-C target-feature=+crt-static, for the Windows targets only). - Release 0.1.0’s
hpr.exeimportedVCRUNTIME140.dll. Run once by hand on the published 0.1.0 program, the check exits with an error naming that DLL. That was a one-off measurement; the repository’s tests run the check on small invented programs instead. - The wheels keep the C runtime as a DLL, and their imports aren’t checked. The Windows
installer from python.org puts
vcruntime140.dllbesidepython.exe(CPython’sTools/msi/exe/exe_files.wxs, andPC/layoutfor its other packages).python.exehas loaded it before it loads the module.
- From release 0.2,
- The Linux archive and wheel are then checked against the glibc floor twice.
scripts/release/check-glibc.shreads each program and library in them withobjdump. It fails if one asks for a glibc function newer than 2.17, or if the wheel’s name lacks themanylinux_2_17tag.scripts/release/smoke-manylinux.shruns the same smoke test inside pypa’s manylinux2014 image, a CentOS 7 with glibc 2.17. It installs the wheel with pip on CPython 3.10 and 3.13. - The Homebrew formula must pass
brew styleandbrew audit --strict. Then it must install withbrew installand pass its ownbrew test(hpr --versionnames the version). Each check runs on a Mac with Apple silicon and on Linux on x86-64 and on 64-bit ARM. The release the formula names doesn’t exist yet, so the install uses a copy whose addresses point at the run’s own archives. The hashes stay as written (scripts/release/smoke-homebrew.sh). - The Scoop manifest must install with
scoop installon Windows on x86-64 and on ARM, each taking its own archive. It’s installed the same way, from a copy whose addresses point at the run’s own archive, served from the runner. The hash and folder stay as written. The installedhpr --versionmust name the version (scripts/release/smoke-scoop.ps1). - The crates must each package, and build from their packaged files alone
(
cargo publish --workspace --dry-run).scripts/release/publish-crates.sh --dry-runmust read crates.io’s index as expected and print the order it would publish in.
These smoke tests show a file installs and runs as built. They don’t check the physics: the test suite and the validation cases do that, on every change (Accuracy).
Publishing
Neer publishes in two steps. He starts the workflow with publish ticked, then approves its
release environment,
a GitHub setting whose required reviewer is him. The workflow is started with publish ticked only
with that setting in place. The crates then go to crates.io, and the wheels and source package to
PyPI. A draft GitHub release gets the archives, the Homebrew formula and the Scoop manifest, and the
wheels and source package too. Publishing the draft makes the version’s tag.
The first publish of the crates takes about two hours, because crates.io paces new names.
It lets one account publish 5 new crates at once, then one every 10 minutes
(crates.io’s rate limits, read October 8, 2026). Release 0.1
publishes 14, so 9 of them wait. scripts/release/publish-crates.sh publishes the crates one at a
time, each after the crates it depends on. Once the first five new names are out, it waits 10.5
minutes before each next one. That’s 9 waits, about 95 minutes, plus the time to build each crate.
A name already on crates.io that nrdptel doesn’t own stops the run. A later release adds versions
to crates that exist. crates.io allows 30 new versions at once, so it doesn’t wait.
Later releases publish without a stored token. The release workflow uses crates.io’s
trusted publishing. Each crate’s settings on crates.io
name this repository, release.yml and the release environment. After you approve the
environment, the job trades GitHub’s identity token for a crates.io token. That token lasts 30
minutes and is revoked when the job ends. It can add versions but can’t create a crate. So the
workflow runs the script with --versions-only, which stops before publishing anything if a
crate’s name is new. A new crate goes up once from your machine (cargo publish --package <name>
with an API token). Then it gets the same trusted-publishing entry on crates.io: the crate’s
Settings, then Trusted Publishing, with owner nrdptel, repository fusionspace-eridanus,
workflow release.yml and environment release.
A publish that stops partway can be run again. A published version can’t be withdrawn, only yanked (marked as not for new use). So a second run must not start over. The script asks crates.io’s index which versions are there and skips those. If crates.io still answers that the limit is reached, it waits until the time crates.io names and tries again.
Homebrew, Scoop and cargo binstall
Each release brings its own Homebrew formula and Scoop manifest, and the tap and the bucket copy them from it. A formula is the Ruby file that tells Homebrew where to download a program, its SHA-256 hash and how to install it. A tap is a Git repository of formulas outside Homebrew’s own. Scoop’s equivalents are a manifest, a JSON file, and a bucket, a repository of manifests.
scripts/release/package_managers.py writes both files from the archives’ names and hashes. Each
has an entry for each of its archives the release has, and none for a system it lacks. So release 0.1’s
formula refuses an Intel Mac rather than install a program it can’t run. cargo test -p xtask
runs the script on invented archives. It compares the formula with the expected one byte for byte,
and the manifest as parsed JSON, written with Unix line ends. The release attaches both files, and
publishing the draft makes them the latest release’s.
The formula and the manifest both state the program’s license as
(MIT OR Apache-2.0) AND Apache-2.0. That’s the project’s two licenses, either at your option,
and Apache-2.0 for OpenRocket’s parts catalog, which the program carries
(the release workflow’s decision record).
It’s an SPDX license expression, the standard way to write which licenses apply, and the one the
Python package states. The formula writes it in Homebrew’s form, one term a line,
license all_of: [{ any_of: ["MIT", "Apache-2.0"] }, "Apache-2.0"]. That’s what brew style,
Homebrew’s checker for a formula’s layout, asks for. Scoop’s own form has no parentheses to group
a choice inside a requirement. So the manifest gives the SPDX expression as its license
identifier, with a url to the README’s license section.
The manifest suggests no Visual C++ runtime, since from release 0.2 the Windows program needs none.
The formula and manifest checks hold up every publishing job, on purpose. The crates, the
Python package and the draft release all wait for them, so a release goes out on every channel or
on none. The cost is that a new check in Homebrew’s brew audit or brew style, or a change in
Scoop, can stop a release that changed nothing here. If the cause was passing, such as a download
that timed out, rerun the failed job. Otherwise fix the generator or the formula it writes, and
start the workflow again.
The tap, nrdptel/homebrew-tap, and the bucket,
nrdptel/scoop-bucket, each run a workflow once a day.
It downloads the latest release’s file and commits it when it changed. A new release reaches
brew upgrade and scoop update within a day. It reaches them at once if you run that workflow
by hand from its repository’s Actions tab (Run workflow). Each workflow reads the public release
and pushes with its own repository’s token. So neither repository holds a credential for the
other, nor this one for them. Release 0.1 came out before the formula and manifest existed. The
tap and the bucket were given files written by the same script from its archives.
GitHub turns off a public repository’s scheduled workflows after 60 days with no activity.
Releases further apart than that leave the tap or the bucket on the old version, and GitHub shows
the workflow as disabled. Turn it back on with Enable workflow on its Actions page, or with
gh workflow enable homebrew-update.yml --repo nrdptel/homebrew-tap (and scoop-update.yml,
nrdptel/scoop-bucket). Then run it once by hand.
cargo binstall fusionspace-hpr-cli reads where the archives are from the crate’s own
manifest ([package.metadata.binstall] in crates/hpr-cli/Cargo.toml). Those lines give the release’s
tag, the archive’s name, and hpr in the folder inside it. QuickInstall, a
third-party service that builds and hosts crates’ programs, is binstall’s fallback, and it’s turned
off. So binstall takes only this repository’s archives, or compiles. The crate on crates.io carries those lines from release 0.2.
Release 0.1.0’s doesn’t, so binstall finds no archive for it.
Packages for winget and conda-forge are planned (issue #434).
Checking a file yourself
From a copy of the repository at the release’s commit, with cargo and uv installed:
scripts/release/smoke-cli.sh fusionspace-hpr-0.1.0-aarch64-apple-darwin.tar.gz
scripts/release/smoke-python.sh fusionspace_hpr-0.1.0-cp310-abi3-macosx_11_0_arm64.whl
Each prints what it checked and ends with passed, or stops at the first check that fails. To
build the files yourself, scripts/release/archive.sh dist and scripts/release/python.sh wheel dist need cargo-about 0.9.2 (cargo install cargo-about --locked --version 0.9.2 --features cli).
They also need uv, which fetches maturin and, on Linux, cargo-zigbuild and Zig. On Linux,
scripts/release/check-glibc.sh <file> checks a file against the glibc floor.
scripts/release/smoke-manylinux.sh <file>, which needs Docker, runs its smoke test on that glibc.
How the workflow was chosen is in its
decision record.
Glossary
Look up any term these pages use, with a short definition and a link to the page that models or uses it most.
Terms are listed alphabetically in six groups by first letter. Each term has its own heading, so any page can link straight to one; a site search jumps to it. Headings show as written, in each name’s own spelling. Where HPR Sim uses a term in a particular way (a sign, a frame, a reference point), the entry says so.
Digits and A to C
6-DOF (six degrees of freedom)
A simulation that follows all six ways a rigid body can move: its position along three axes and its rotation about three. HPR Sim flies a rocket in 6-DOF from rail exit on. On the rail it has one degree of freedom, along the rail. Under an open parachute it is a point mass whose attitude is frozen. See Rigid-body flight.
Accuracy census
The count of the numbers the validation reports hold HPR Sim to, one row each, kept as it was last accepted. CI fails when a row moves by more than its slack, a small share of the bound it is judged by. It fails too when a row changes its standing (pass, within target, not flown and so on), or comes or goes. CI fails until the change is accepted with a written reason. It holds a number to where it was, not to the truth. See Accuracy: the census.
Adaptive time step
A time step the integrator (the part that steps the equations forward in time) chooses for itself.
It estimates each step’s error, and shrinks or grows the next step to keep that error within a
tolerance. HPR Sim’s default method, Dormand-Prince 5(4) at rtol = atol = 1e-8, puts
Valetudo’s apogee (one of RocketPy’s example rockets) within 1.1e-6 m of a far tighter run. See
Time integration and events.
Added mass
The air a canopy pushes along as it speeds up or slows down relative to the air, counted as extra mass with no weight. In steady descent it changes nothing. RocketPy includes it in its parachute descent and HPR Sim doesn’t. For NDRT 2020’s main, one of the example rockets, RocketPy’s added mass is 15.9 kg against the rocket’s 20.8 kg. That makes it the likely cause of the largest difference between the two codes’ descents. See Recovery. A stage’s added mass, next, is something else.
Added mass (a stage’s)
Mass a stage carries beyond what its parts weigh, such as glue and paint weighed on the finished rocket. HPR Sim adds it to the stage’s parts as a point: at the parts’ center, or at a station the design gives. It is how an OpenRocket stage’s mass override is read when its override for all subcomponents box is unticked. Boosters strapped beside the core (a parallel stage) carry one for the set, not one each. Not the air a canopy pushes along, above. See A stage’s added mass.
AGL (above ground level)
Height above the launch site. A recovery device’s altitude trigger is a height above the launch site. A flight ends when the center of mass comes back down to the site’s height. See Recovery and Rigid-body flight.
Air start
A motor lit in flight, some time after launch, rather than on the pad. It can be in the same stage as a motor lit at launch. OpenRocket’s Airstart timing example has a K550W lit at launch beside a 3-ring of I211W motors. They light 1, 2, 4 or 6 s after launch, or in one configuration at launch. In HPR Sim each motor has an ignition. It lights at launch, at a time, a delay after another motor’s burnout, or a delay after its stage separates. A .ork file’s ignitions are read into these (.ork design files). Each flight of OpenRocket’s air-start example is within 5% of OpenRocket’s apogee and largest speed (M1.9c, a two-stage and a cluster design against OpenRocket). See Staging.
Angle of attack
The angle between the rocket’s axis and the airflow it meets. In HPR Sim it is the total angle between the body axis, pointing to the nose, and the rocket’s velocity relative to the air. It runs from 0 to (180°). The simulator’s aerodynamics are small-angle models, so results at large angles, off the rail in a strong crosswind and near apogee, are the least trustworthy. See Frames and Aerodynamics.
API reference
The documentation of FusionSpace HPR’s code: every public type, function and constant, generated from the source by rustdoc, Rust’s documentation tool. It is part of this site, and on GitHub it has to be built; see The API reference.
Apogee
The highest point of a flight, where the rocket stops climbing. HPR Sim finds it as the moment the center of mass’s rate of climb above the WGS 84 ellipsoid falls through zero. It does not use the launch frame’s up axis, whose flat plane rises above the curved Earth with distance. The rise is 7.8 m (26 ft) at 10 km (6.2 mi). See Rigid-body flight.
Average thrust
A motor’s total impulse divided by its burn time, in newtons (N), as ThrustCurve.org defines it. It is the number in a motor designation. See Solid motors.
Barometric altimeter
A flight computer that finds its height from the air pressure it measures. It converts the pressure to an altitude with the standard atmosphere and subtracts the pad’s. The air of the day is rarely standard. On a hot day a column of air is taller and pressure falls more slowly with height. The altimeter then reads less than the height climbed, 6.5% on a day 20 K warmer than the standard (worked example). On a cold day it reads more. HPR Sim reads its own flight the same way when it compares with a log; see Accuracy: real flights.
Barrowman’s method
J. S. Barrowman’s 1966–67 method for the normal-force slope and center of pressure of a slender finned rocket. It works out each nose, transition and fin set on its own and sums the results. HPR Sim follows it, with extensions from Niskanen’s 2009 thesis. Four of Barrowman’s five printed examples agree within 1%, and the six-fin Recruiter’s slope is 2.87% high. See Aerodynamics.
Base drag
The drag on a rocket’s flat aft end, its base. HPR Sim works it out on the base’s area, with a coefficient of below Mach 1 and above it ( the Mach number). While a motor burns, the simulator subtracts the burning motors’ cross-section from that area (power-on drag). This follows Niskanen, who takes from Fleeman that a base the size of the motor has no base drag. OpenRocket 24.12 keeps the whole base’s drag, and HPR Sim can fly that rule for a comparison. OpenRocket’s development line takes out the nozzle exit only when an exit diameter is entered. On a NACA missile model’s measured flight below Mach 0.8, whose motor case is wider than its base, HPR Sim’s rule leaves no base drag under power and reads low, so the apogee reads high (which error flatters); the whole base reads high, and the jet more than doubled the base drag, which neither rule does (the base under power, against a measured flight). On one private design’s supersonic flight, C06/1, the choice moves HPR Sim’s apogee difference from OpenRocket’s by about 24 percentage points. That is more than any other known cause (#222). Behind a boattail the base’s pressure is higher and the simulator lowers the base drag to match: below Mach 0.8 the base keeps the base’s diameter over the boattail’s fore diameter of the flat-base value, from a wind-tunnel rule held to one measured flight (the base under power, against a measured flight); faster than sound by the supersonic rule (Boattails faster than sound). See Aerodynamics.
Baseline
A logger’s reading of a sensor at rest on the pad, which it takes as zero for later readings.
Ozark Aerospace’s ARTS2 altimeter keeps two: its barometer’s, the “Zero Altitude baseline”, and its
accelerometer’s, the “Zero G baseline”. HPR Sim reads both from the flight’s .odf file. See
Flight logs.
BATES grain
A cylindrical propellant grain with a hole along its axis (the bore), which burns on the bore and, unless inhibited, on both ends. HPR Sim can place a motor’s propellant as a stack of identical BATES grains. That sets how the motor’s center of mass and inertia change as it burns. See Solid motors.
Bearing
A direction on the ground, measured clockwise from true north: 0° is north, 90° east, 180° south and 270° west. Getting started gives the landing point as a distance and a bearing from the pad. A wind direction is a bearing too: the one the wind blows from. A compass gives a magnetic bearing; add the declination to make it true.
Boattail
A transition at the tail that narrows toward the aft end. Its normal-force slope is negative, so it moves the center of pressure forward. Below Mach 0.8 HPR Sim counts its pressure drag as a share of the base drag on the area it removes. The share is all of it for a short, steep boattail and none for a long, gentle one. Faster than sound a boattail has its own wave drag, which the simulator takes from a handbook chart. The chart matches measured boattails of 3° to 10° within about a quarter, and reads high for steeper ones. See Boattails faster than sound.
Body frame
The axes fixed to the rocket. The origin is the nose tip, on the axis. points along the axis toward the nose, so every part lies at . is the design’s zero direction around the body (the one fins and rail buttons are placed from), and completes a right-handed set. See Frames.
Body lift
A sideways force on the body itself, not the fins, when the rocket flies at an angle to the airflow. It grows with the square of the sine of the angle of attack. So it is nothing at small angles and large at steep ones, such as a slow rocket leaving the rail into a crosswind. HPR Sim sizes it by Jorgensen’s crossflow drag, which depends on the body’s length over its diameter and on how fast the air crosses it. Before M1.8e6 it used Galejs’s constant. RocketPy leaves it out. See Aerodynamics.
Booster
The aft part of a staged rocket: the stages behind the separation, whose motor lights first and
which are dropped when the stack separates. After a powered separation HPR Sim flies it as a point
mass under its own recovery devices. One of them must be open from the separation: hpr sim
tumbles it from the split until its own parachute opens. Its motors must have burned out by then. See Staging.
Boosters can also be strapped beside the core instead of behind it, a
parallel stage.
Boundary layer
The thin layer of air next to the rocket’s skin, slowed by friction with it. It grows thicker toward the tail: on a model rocket a meter long it can be a centimeter or more thick at the base. Skin friction comes from it, and where it is thick it softens what the outer flow does, such as the expansion around a boattail. HPR Sim takes it as turbulent everywhere. See Aerodynamics.
Burn time
How long a motor burns, in seconds, by the NFPA 1125 rule that ThrustCurve.org uses. It runs from the moment the thrust first reaches 5% of its peak to the moment it last falls to 5% of its peak. It is not the time of the thrust curve’s last point, which is burnout. See Solid motors.
Burnout
The moment a motor stops producing thrust. In HPR Sim it is the time of the thrust curve’s last point. From then on the thrust, the propellant flow and the propellant left are all zero. A flight records a burnout event and steps exactly to it, because the equations change there. See Solid motors.
Caliber
A length measured in body diameters. A stability margin is usually quoted in calibers, and a nose cone three calibers long is three times as long as its base diameter. See Shapes.
Canard
A fin set near the nose, ahead of the main fins. Its normal force acts well forward, so it moves the center of pressure forward, and as speed rises its slope grows too. See Aerodynamics.
Cant
The small angle at which fins are set to the rocket’s axis, turning each about its own span. The air then pushes each sideways and the rocket spins. HPR Sim measures it in radians, positive turning fin 0’s leading edge toward (Body frame). Fin 0 is the one along . A positive cant spins the rocket clockwise seen from ahead of the nose, looking aft. See Roll: forcing and damping.
Center of dry mass
The center of mass of the rocket with its motor’s propellant gone: the empty rocket, motor casing included. It does not move during the flight, so RocketPy follows this point, and the comparisons with RocketPy measure speeds and drifts there. The center of gravity of the loaded rocket lies aft of it while the motor burns. See Accuracy.
Center of gravity (CG)
The point where the rocket’s mass balances. The model pages call it the center of mass, which in uniform gravity is the same point. It moves as the propellant burns, and HPR Sim recomputes it at every instant from the parts and the motors. See The design tree and Mass properties.
Center of pressure (CP)
The point along the rocket where the normal force acts, given as a station aft of the nose tip. HPR Sim finds it by averaging each component’s own center of pressure, weighted by its normal-force slope, at small angles of attack. A rocket is statically stable when its CP is behind its center of gravity. See Aerodynamics.
CIPM-2007
The formula for moist air’s density, from its temperature, pressure and humidity, that the International Committee for Weights and Measures (CIPM) adopted in 2007. HPR Sim’s humid-air density is checked against it, within 0.047% over 15 to 27 °C. See Atmosphere.
Closed form
An answer written as an exact formula, such as the parabola a body follows in a vacuum, rather than one computed step by step. HPR Sim’s analytic tests compare the code with closed forms, the first of the four kinds of evidence on Accuracy.
Cluster
Several motors in one rocket, burning side by side. They share one mount of several like tubes (an OpenRocket 3-ring, say), or each has its own mount. HPR Sim lights each motor at its own ignition (at launch unless told otherwise). It sums their thrusts and masses. It adds the turning moment of any motor set off the axis, as when one motor of a cluster fails to light (a “motor out”). Tests check this against hand calculations. OpenRocket’s cluster example, read from its .ork file with a motor in every tube, flies within 5% of OpenRocket’s apogee and largest speed. Three of its apogees are compared with OpenRocket’s flight with no parachute, since its parachute opened before apogee. See M1.9c, a two-stage and a cluster design against OpenRocket, and Clusters.
CMA-ES
The covariance matrix adaptation evolution strategy, N. Hansen’s optimization method. It samples designs from a cloud (a normal distribution) and moves the cloud toward the better ones. From them it learns which way and how far to step next. It needs only the order of the results, not their slopes. See Optimization.
Code-to-code comparison
Flying the same rocket or the same part of a flight in HPR Sim and another simulator, from the same inputs, and comparing the numbers. It is the third of four kinds of evidence, and it shows that two codes agree, not that either matches a real flight. HPR Sim’s parachute descents match RocketPy’s within 3% on all 30 numbers compared. Whole flights are in Accuracy. See Recovery.
Configuration
One choice of motors for a rocket design, at most one in each motor mount, named by an id such as h54. A design can hold several, such as the same rocket on different motors, and a flight names the one it flies. Each motor lights at launch unless its ignition says otherwise (Staging). See Your own rocket and The design tree.
Coriolis acceleration
The sideways acceleration that anything moving over the rotating Earth appears to have, . Here is the Earth’s rotation (7.292115e-5 rad/s) and the velocity in the Earth-fixed launch frame. It is the only rotating-Earth term HPR Sim adds, since the centrifugal part is already inside normal gravity, and it is on by default. It is small: in one test it moves the landing point of a 3 km (9,843 ft) parachute descent 0.37 m (1.2 ft) east. See Gravity.
COTS motor
A commercial off-the-shelf motor: a solid rocket motor bought from a manufacturer, single-use or as a reload for a reusable case. HPR Sim covers only these for now. It carries ThrustCurve.org’s whole catalog of them, and flies each with a curve file by name (The bundled motors). See Solid motors and Start here.
Covariance
How two quantities vary together. It is positive when both tend to be high together and negative when one tends to be high while the other is low. It is zero when neither says anything about the other. For distances on the ground it is in square meters (m²). A spread of points on the ground has three numbers: the variance east (the square of the standard deviation), the variance north, and their covariance. Together they give the shape and the turn of a landing ellipse. See Monte Carlo dispersion.
Crate
A Rust package: the unit that Rust code is built, versioned and shared in. FusionSpace HPR is split
into crates, so a program takes only the ones it needs. Two are hpr_core, for the maths and the
Earth, and hpr_sim, for the flight. Their published names add a fusionspace- prefix
(fusionspace-hpr-core); code keeps the short name. See The API reference.
CRS (coordinate reference system)
The definition that turns a file’s coordinates into places on Earth. It holds an ellipsoid and its datum (where the ellipsoid sits), and either latitude and longitude or a map projection such as UTM. Most have an EPSG code. HPR Sim’s elevation-file reader takes latitude and longitude on a datum within a few meters of WGS 84. See A launch site’s elevation.
D to F
Decision record (ADR)
A short record of a significant choice, the alternatives considered and why one was picked, labeled like ADR-011 (the rigid-body flight decision). All of them are in the decision log. See Decisions and the roadmap.
Declination (magnetic)
The angle from true north to the north a compass shows, positive when magnetic north lies east of true north. A compass bearing becomes a true one by adding it: at Spaceport America in 2026 it is about +7.75°. HPR Sim computes it from the World Magnetic Model. See The magnetic field.
DEM (digital elevation model)
A grid of ground heights, one per cell. An example is the US Geological Survey’s (USGS) 1-arc-second map of the United States, whose cells are about 30 m (98 ft) across. Most DEMs are published as GeoTIFF files. See A launch site’s elevation.
Deployment
The moment a recovery device, such as a parachute, comes out to its full line length (line stretch) and starts to fill. In HPR Sim it follows the device’s trigger (apogee, a height above the ground, a time, or a motor’s ejection delay) after a set lag. The flight’s first deployment switches the rocket to the descent, as a point mass. See Recovery.
Descent rate
How fast a rocket falls under its recovery device, in m/s. Once drag balances weight it settles at the equilibrium descent speed
with the mass, gravity, the air density and the drag area. Take a 1.1 kg rocket under a 1 m (39 in) flat canopy with 0.8, in air of 1.225 kg/m³. It falls at 5.294 m/s (17.37 ft/s). See Recovery.
Design file
A rocket design saved as text, so it can be kept, shared and read back. HPR Sim’s own is the HPR design format, in a .hpr file. That is one JSON document with a versioned header, the rocket, its motor configurations, recovery and stored simulations. A .hprz is the same document in a zip archive, with other files beside it, such as flight logs. hpr sim flies both, and hpr convert writes them from a .ork. The rocket inside it is the JSON of the simulator’s Rocket type, which hpr sim also reads on its own. Each key is a Rust field’s name, with its unit in the name (length_m). A mounted motor is written out in full, thrust curve included. The format is version 0.2, a draft until FusionSpace HPR’s first release. An older document is migrated when it is read, but keep the source file too. See Your own rocket.
Digest
OpenRocket’s fingerprint (a hash) of a motor’s thrust-curve data. A .ork file records it for each
motor, and OpenRocket uses it to find that curve in the motor database it ships. HPR Sim uses it to
find a curve the file embeds, or one a caller supplies. Two different motors can, rarely, share a
digest. See the .ork format.
Dispersion
The uncertainty given to one input of a Monte Carlo run, as a standard deviation. It says how far the rocket’s mass, its motor’s impulse or the wind’s speed may differ from the plan from one flight to the next. See Monte Carlo dispersion.
Dormand-Prince and RK4
Two ways of stepping the equations of motion through time. Dormand-Prince 5(4), also called
DOPRI5, makes two estimates on each step and shrinks or grows the step to keep their difference
under a tolerance. It is HPR Sim’s default. RK4, the classic fourth-order Runge-Kutta
method, takes steps of a fixed size. See Time integration.
Drag area
A recovery device’s drag coefficient times the area that coefficient is measured on, , in m².
The drag force is the dynamic pressure times it. HPR Sim takes it directly
(RocketPy’s cd_s) or from a canopy’s diameter and its coefficient on the
nominal area. HPR Sim adds up the drag areas of every open device. See
Recovery.
Drag coefficient
Drag divided by dynamic pressure and an area: a number without units that says how draggy a shape is. For the rocket, is the coefficient at zero angle of attack on the reference area. It is built up from skin friction, pressure, base and fin terms, or read from a table instead. For a parachute, Knacke’s is on the canopy’s nominal area, a different convention. See Aerodynamics and Recovery, and Drag through the speed of sound for how it changes with speed.
Drag crisis
A sudden fall in a blunt body’s drag coefficient over a narrow range of Reynolds number. It comes as the flow along its surface turns turbulent and stays attached further round. For a cylinder lying across the flow it comes at a Reynolds number of a few hundred thousand. For streamers, Carruthers and Filippone report a sudden drop near 7.2e5, which they put down to a change in how the streamer oscillates. HPR Sim’s recovery models include none. See Recovery.
Drift
How far the wind carries a rocket sideways while it descends, in meters. In the comparison with RocketPy it is the horizontal distance from where the descent starts to the landing point. It has an east and a north part. In still air a small drift remains from the Coriolis acceleration: 0.19 m (0.6 ft) for Valetudo’s descent. See Recovery.
Drogue and main
The two parachutes of a dual-deployment recovery. The small drogue opens at or near apogee, so the rocket falls fast but steadily. The large main opens lower down for a slow landing. In HPR Sim it can release (cut away) the drogue once it is fully open. RocketPy’s Calisto example flies a drogue of 1.0 m² drag area and a 10 m² main that opens at 800 m (2,625 ft). See Recovery.
Dynamic pressure
The pressure of the oncoming air due to its motion, , with the air density and the airspeed, in pascals (Pa). Every aerodynamic force is times a reference area times a coefficient, so forces grow with the square of airspeed. Near apogee, where the rocket is slow, is small. See Frames and Rigid-body flight.
ECEF (Earth-centered, Earth-fixed)
The , , frame that turns with the Earth. Its origin is the Earth’s center of mass. points along the rotation axis to the north pole, through the prime meridian at the equator, and to 90° east. HPR Sim converts between it and latitude, longitude and height on the WGS 84 ellipsoid. See Frames and Geodesy.
Effective exhaust velocity
A motor’s thrust divided by its propellant mass flow, , in m/s. HPR Sim holds it constant through the burn, (total impulse over propellant mass), so propellant burns in proportion to the impulse delivered. It also refuses a motor whose falls outside 200 to 5,000 m/s (656 to 16,404 ft/s). That catches a propellant mass given in the wrong unit, such as grams for kilograms. ThrustCurve.org’s catalog has a median of 1,866 m/s (6,122 ft/s). See Solid motors.
Ejection
A piece of the airframe leaving the rest on a trigger, at a joint you choose rather than only at a stage boundary. It can be a nose cone pushed off its airframe, a body section, or a payload carried inside. Each piece then comes down on its own under its own recovery device. Pieces tied together by a shock cord fly as one, so they are not an ejection. Compare separation, which parts the rocket at a stage boundary. In hobby use “ejection” often means the charge firing. In HPR Sim that is a recovery device’s trigger (see ejection delay). The charge’s push on the pieces can be given to the ejection as an impulse in newton-seconds. See Recovery: ejected pieces.
Ejection delay
The time from a motor’s burnout to its ejection charge, in seconds. Motor files list
the delays available, and P means plugged, with no ejection charge. HPR Sim reads a 0 as “zero
or plugged” rather than as ejection at burnout, because most files mean plugged. A .ork design
says none for plugged, so its 0 is a charge at burnout
(.ork files). A recovery device can use a motor’s delay as
its trigger. See Solid motors and
Recovery.
Elementary effect
In Morris’s screening, the change in a result when one input steps part of its range, the others held, scaled to the input’s whole range. The mean of their sizes, , ranks the inputs. See Sensitivity analysis.
Ellipsoidal height
Height above the WGS 84 ellipsoid, measured along the ellipsoid’s normal, in meters. It is HPR Sim’s internal height, and it is not height above sea level: the two differ by up to about 100 m (328 ft). See Frames.
EPSG code
A number naming a CRS, a datum or a unit in the EPSG Geodetic Parameter Dataset, which most mapping software shares. Code 4326 is latitude and longitude on WGS 84, code 4269 on NAD83, code 5703 heights above NAVD88 in meters, code 9001 the meter. See A launch site’s elevation.
ERA5
The European Centre for Medium-Range Weather Forecasts’ reanalysis of the whole Earth’s weather, every hour since 1940, on a quarter-degree grid. It comes from the Copernicus Climate Data Store. Its pressure-level files give the temperature, wind and geopotential height at each pressure level. See ERA5 weather files.
Evidence register
The list of the gaps these pages state in what backs a file reader, a model or a check, one row each. A row gives the kind of evidence behind it (a real file, another program’s answer, a published layout, an argument). It also gives the kind that would settle it, and the open issue that waits for it. A page that states a gap links its row. The build fails a gap stated in one of the check’s phrases with no row; a gap worded otherwise isn’t caught. See What backs each claim.
Event
A moment the simulator locates exactly and records, such as liftoff, rail exit, burnout, apogee and ground hit. In recovery it can be a trigger, a deployment, a release or a separation. The integrator finds each as the zero of a function of the state, adding at most about 2e-12 s of error to the solution’s own. It stops there so the flight can change phase. See Time integration and events and Rigid-body flight.
Example rockets
The rockets HPR Sim is compared on. Calisto, Valetudo, NDRT 2020, Prometheus, Juno III, Cavour and
Bella Lui come from RocketPy’s own examples. Their designs, as the simulator reads them, are in the
repository’s validation/designs/ folder. The Recruiter and Barrowman’s other rockets
are worked examples from his papers, with their printed values in
barrowman-worked-examples.json. See Accuracy.
Fillet
A fin fillet: the rounded glue joint along a fin’s root, filling the corner between the fin and the body tube on each side. Its face is a circle of the fillet’s radius. HPR Sim weighs fillets as OpenRocket does, as a prism of that corner’s section along the root chord, in their own material. The aerodynamics leaves them out. See Mass properties.
Fineness ratio
A nose cone’s length divided by its base diameter. A 3:1 tangent ogive has a fineness ratio of 3, which the pages also write as “fineness 3”. For a shoulder, a transition that widens toward the tail, the drag pages use its length over its rise in diameter. So a conical shoulder has the fineness of the cone with the same surface angle. See Aerodynamics.
Flare
A transition that widens toward the aft end, the opposite of a boattail. It can be a conical skirt at the tail, or the step up onto a wider aft section. Its normal-force slope is positive, so it moves the center of pressure aft, which is why one is sometimes added for stability. Faster than sound, HPR Sim marches a conical flare through the shock-expansion method while the shock at its corner stays attached. It reads a steeper one as a flare of the same radii drawn out to that angle. What that is worth against the one measured flare in the sources is What a marched flare is worth. How the model works is A flare through the method. Where the march itself stops, which is not where that shock detaches, is in Where a flare’s march stops. A flare shallow enough that its element is reduced is read by the older generalized method instead: A near-flat flare.
Flow separation
Air leaving a surface it can’t follow, such as the aft end of a steep boattail, and leaving a slow, recirculating region behind it. There the pressure is about the base’s, not what the attached flow would give. HPR Sim blends a boattail’s drag toward that value between 16° and 30°, where measured boattails separate. Not the same as a separation of stages or recovery bodies. See Boattails faster than sound.
Flight log
The record an altimeter or flight computer writes during a flight. It has a
row per sample, each with its time and what the logger measured then, such as its altitude. Its
format is the logger maker’s. hpr analyze reads one and prints what it says, with no design file
(Reading a flight log).
Floor
A reading that holds one way only. It has up to three numbers: the reading, where the rule lands; the
floor itself, that reading less its bound; and, for a burnout or a clipped top acceleration, a
tighter lower end, the figure the truth stayed above in about 19 of 20 synthetic flights
(lower_end_s, lower_end_m_s2). The truth is at or above the floor (or, for a time, at
or after it), and may lie beyond it by any amount. Take burnout from the top speed on the
invented PerfectFlite flight. The reading is the top speed’s time, 2.20 s, which the JSON gives as
time_s. The floor is 2.20 s less its 1.32 s bound, 0.88 s, which hpr analyze prints as
“no sooner than 0.88 s”. The errors the tuning set reports for a floor are the reading’s, not the
floor’s. hpr analyze gives a floor where the log can’t show the other side:
- a top acceleration clipped at the part’s range or held flat at its top, or one whose thrust the accelerometer shows no end to;
- an apogee close to the log’s end; that log’s top speed and smoothed apogee are floors too, and none of the three gives a lower end;
- burnout taken from the top speed.
The JSON marks one is_floor. See Flight-log readings.
Flutter
A fin shaking itself apart. Above a certain speed, the air’s push twists the fin and the twist changes the push. The fin’s bending and twisting then feed each other instead of dying out. How fast that happens depends on the fin’s outline and thickness, its shear modulus and the air. HPR Sim screens for it with NACA TN 4197’s criterion. See Fin flutter, and When fins flutter for what its speed means.
Forebody
Everything of a rocket but its flat aft end, the base: the nose, the body tube, the fins and any boattail. A wind-tunnel model sits on a sting that disturbs the air behind its base. So tunnel reports often give the forebody’s drag alone, as NASA’s Arcas Robin reports do. HPR Sim is compared with them on its drag without the base drag. See Aerodynamics.
Forecast run (cycle)
One start of a weather model: it begins from the weather observed at one hour, the run’s cycle, and steps forward. Each forecast hour is the forecast for that many hours after the cycle. NOAA’s GFS starts a run every 6 hours and its RAP every hour. See NOAA forecasts: GFS and RAP.
G to L
Gate and target
Two ways a validation result is held to a bound. A gate fails the test suite when a number falls outside it, so a change that breaks agreement cannot merge. A target is the same kind of bound, but a miss is only reported, with its explanation in the case file. A target never fails the suite, and is used where neither side of the comparison is known to be right. That is the case for HPR Sim’s own drag against the drag RocketPy’s examples ship. Either way the report is committed, so any number that moves shows up in review. See Accuracy. Separately from both, the accuracy census fails CI when any number it counts moves, whether or not it is inside its gate or target.
Geodesic
The shortest path between two places on the WGS 84 ellipsoid: the true distance between them over ground that curves. Its length is the distance, and its direction where it leaves is the bearing to the second place. HPR Sim’s flight output still measures the landing on a flat map round the pad. See Geodesy.
Geodetic latitude
Latitude as maps and GPS give it: the angle between the equator’s plane and the WGS 84 ellipsoid’s normal through the point, positive north. Gravity depends on it: at the surface it runs from 9.780 m/s² at the equator to 9.832 m/s² at the poles. See Frames and Gravity.
Geopotential height
A height measured by the work done lifting a unit of mass against gravity, divided by standard gravity , in geopotential meters. Weather data give heights this way. Where gravity is stronger than , a geopotential meter is a little shorter than a meter. HPR Sim turns it into height above sea level with the site’s own gravity. See Atmosphere and ERA5 weather files.
GeoTIFF
A TIFF image whose tags say where on Earth its pixels lie (the OGC GeoTIFF Standard 1.1). In a DEM each pixel is a height. See A launch site’s elevation.
GRIB2
GRIdded Binary, edition 2: the World Meteorological Organization’s binary format for weather on a grid (WMO-No. 306, code FM 92). A file is a run of messages, each holding one variable on one level over the grid. The values are packed as whole numbers, with a formula to turn them back. See NOAA forecasts: GFS and RAP.
Grid point
A place where a weather model gives its values. Between grid points HPR Sim blends the four around a site, weighting each more as the site nears it (bilinear interpolation). See NOAA forecasts: GFS and RAP.
Height above sea level (MSL)
Height above mean sea level, as field elevations and soundings give it. HPR Sim queries the atmosphere and the wind with it. HPR Sim gets it from ellipsoidal height by subtracting the geoid undulation . That is the height of sea level above the ellipsoid, up to about 100 m (328 ft). The simulator has no geoid model, so a flight takes at the site as an input. See Atmosphere and Frames.
Hypsometric equation
How thick a layer of air is between two pressures: the geopotential thickness is
with and the pressures at its bottom and top, and dry air’s gas constant (287.05 J/(kg·K)). is standard gravity and the layer’s mean virtual temperature (WMO-No. 8, the Guide to Instruments and Methods of Observation, eqs. 12.17 and 12.18). Warm air makes a thicker layer. HPR Sim checks each row of a weather-balloon sounding against it; see Weather-balloon soundings.
Impulse class
The letter that ranks a motor by its total impulse, also called its motor class. Class C covers 5.01 to 10.0 N·s, each letter after it doubles the top of the range, and the upper limits are inclusive. See Solid motors.
Inflation and filling time
How a parachute opens: from deployment, its drag area grows over the filling time to its full value. HPR Sim can open it at once (RocketPy’s model), over a fixed time, or over Knacke’s . Here is the canopy’s fill constant, its nominal diameter and the airspeed. The simulator leaves out the drag’s overshoot as a canopy fills. Opening at once, it ignores how a light rocket slows while the canopy fills. So the opening load it reports is no safe bound either way. See Recovery.
Internal momentum
The momentum of the propellant and gas moving inside a burning motor. A thrust curve measured on a test stand already includes its effect. HPR Sim’s equations of motion, like RocketPy’s, add it again, so it is counted twice. HPR Sim keeps it that way so the two codes can be compared like for like. On Valetudo it adds 21 N to the push at liftoff and changes the burnout speed by at most 0.05 m/s (0.2 ft/s). See Rigid-body flight.
Jet damping
The damping of a rocket’s turning by its own exhaust: gas leaving the nozzle carries away some of the rocket’s rotation. HPR Sim includes it through RocketPy’s equations of motion, so it acts only while a motor burns. See Rigid-body flight.
Lambert conformal projection
A map made by wrapping a cone around the Earth, touching it along one latitude, and unrolling it flat. It keeps shapes true locally, so weather models over the mid-latitudes use it for their grids. Its “up” points true north along one line of longitude only, so winds given along the map must be turned to east and north. See NOAA forecasts: GFS and RAP.
Landing ellipse
An ellipse on the ground drawn around the landings of a Monte Carlo run so that it holds a chosen share of them, its level. A 95% ellipse holds about 19 landings in 20. It is centered on their mean, and its axes lie along the directions the landings spread most and least. Its size comes from the normal distribution. It is used to judge how likely a rocket is to come down inside a field. See Monte Carlo dispersion.
Launch frame (ENU)
The frame fixed at the launch pad, which the flight’s position and velocity are kept in. Its axes are east, north and up along the ellipsoid’s normal at the pad, hence East-North-Up (ENU). It turns with the Earth, so the equations add the Coriolis acceleration. It is a flat plane, so is not altitude. At 10 km (6.2 mi) east of the pad the plane is 7.8 m (26 ft) higher above the ellipsoid than the pad. See Frames.
Lay out
To turn a design’s parts into a rocket: check how they fit together, fill in the automatic dimensions, place every part, and weigh each stage with its overrides. A design that can’t be laid out is refused, and the message says where and why. See Building the tree.
Liftoff
The moment the rocket starts to move up the rail. It is when the push up the rail, mostly the thrust, first beats the weight’s pull down it and the rail’s friction. The motor ignites a little earlier, at time zero. If the motors burn out first, the flight ends on the pad. See Rigid-body flight.
Loft lesson
A mistake found in Loft, the project that came before FusionSpace HPR. An example is Loft lesson L15 (a shoulder’s drag as its length goes to zero). A test here guards against each one, or will once its milestone ships. See Start here and Lessons from Loft.
Lip
A short flare at the very base of a rocket, rising from the end of a boattail or a step down. The Arcas Robin wind-tunnel models end in one, and a motor retainer ring is another. Sitting in the wake of what narrows ahead of it, a lip sees slow, turned air. So HPR Sim takes its drag away there and gives it no normal force faster than sound. See Aerodynamics.
M to P
Mach cone
Faster than sound, a disturbance such as a fin’s tip can only affect the air downstream of it inside a cone. The cone opens backward at the Mach angle, : 30° at Mach 2. HPR Sim halves the fin’s lift inside the cone from each tip. See Aerodynamics.
Mach number
Airspeed divided by the local speed of sound, which the atmosphere gives from the air’s temperature. HPR Sim’s normal force and drag both cover Mach 0 to 5, and a flight that reaches Mach 5 stops with an error. Both were checked against a wind tunnel from Mach 0.6 to 4.63, where the drag reads high at most speeds. The drag was also checked at Mach 0.3 against other programs’ curves. See Aerodynamics and Aerodynamics.
Mean aerodynamic chord (MAC)
An average of a fin’s chords (its lengths along the airflow, root to tip), weighted so that the long chords count more. It is over the span, being one fin’s area. HPR Sim puts each fin set’s center of pressure a quarter of the way back along it up to Mach 0.8. From there it moves aft, to the center of the load supersonic linear theory gives. See Aerodynamics.
Metric
One number a validation case compares between HPR Sim and its reference, such as the descent time or the drift to the north. Each metric has its own tolerance, also called its gate. See Accuracy.
MIL-HDBK-762
Design of Aerodynamically Stabilized Free Rockets, a 1990 U.S. Army handbook for designing unguided rockets, and a U.S. Government work. HPR Sim takes its fin-count factor from it. The simulator’s drag is compared with the handbook’s worked example, a rocket whose drag it calculates term by term from Mach 0.5 to 3.2. That is a calculation by the handbook’s methods, not a measurement. See Aerodynamics.
Milestone
A step of the roadmap, the ordered plan of work, labeled like M1.8 (transonic and supersonic aerodynamics). The pages link a milestone where they say what it will add. See Decisions and the roadmap.
Monte Carlo
Flying the same rocket many times, its uncertain inputs drawn at random each time, to see how far the results spread: the apogee, the landing. Named after the casino, for the random draws. See Monte Carlo dispersion.
Motor designation
A motor’s name, such as F32 or L1150R: the impulse class letter, then the
average thrust in newtons. Makers add their own codes around it, such as a
propellant letter (the R of L1150R). Others are the total impulse in N·s in front (411I175) or a delay
after a dash. A RASP .eng file’s name field is meant to hold only the class and average thrust,
but often holds the full designation. See RASP .eng files.
netCDF
A file format for gridded data, such as weather over a map at several heights and times, from Unidata. HPR Sim reads its two classic kinds; the newer netCDF-4 kind is HDF5 inside and is converted first. See ERA5 weather files.
Newtonian theory
A simple rule for the pressure on the front of a body in fast flow. The air hits the surface and loses the speed it had toward it. So the pressure rises with the square of the sine of the angle between the surface and the wind, . is the pressure coefficient at the nose’s stagnation point, where the air comes to rest behind a normal shock. It suits the steep, blunt front of a body better than its shallow sides. HPR Sim uses it on the cap of a blunt or vertical nose tip faster than sound, ahead of the shock-expansion method. See Aerodynamics.
NFPA 1125
The US National Fire Protection Association’s code for making model and high-power rocket motors. ThrustCurve.org measures a motor’s burn time by its rule, and HPR Sim does the same. See Solid motors.
Nominal area
A parachute canopy’s reference area, , from its nominal diameter ; it includes the vent and every other opening. Knacke’s canopy drag coefficients, which HPR Sim uses, are on this area. For a flat circular canopy they run 0.75 to 0.80, and the middle, 0.775, is HPR Sim’s default. RocketPy’s default parachute coefficient of 1.4 is on a different area, so the two can’t be compared directly. See Recovery.
Normal distribution
The bell-shaped spread of a quantity that is the sum of many small, independent effects, described by its mean and its standard deviation. A standard normal number has mean 0 and standard deviation 1. HPR Sim’s Monte Carlo runs scatter each uncertain input by a standard deviation times such a number. Not to be confused with the normal force. See Monte Carlo dispersion.
Normal force
The sideways aerodynamic force on a rocket flying at an angle of attack, square to its axis and in the plane of the airflow. It acts at the center of pressure, and its coefficient is positive in the direction the crossing air pushes the body. It is what makes a stable rocket weathercock. See Aerodynamics and Frames.
Normal gravity
The gravity of a smooth, spinning model Earth: the pull of the WGS 84 ellipsoid plus the centrifugal effect of the Earth’s rotation. It changes with latitude and height. By default HPR Sim applies the full normal-gravity vector at the rocket’s position, leaving out the real Earth’s local anomalies, typically within ±1e-4 of it. The standard gravity 9.80665 m/s² is a unit convention, not a model of local gravity. See Gravity.
Normal-force slope
How fast the normal force coefficient grows with angle of attack at small angles, , per radian. Each nose, transition and fin set has its own, and the rocket’s is their sum; a pointed nose cone’s is 2. The center of pressure is the components’ positions averaged with these slopes as weights. See Aerodynamics.
NSGA-II
The non-dominated sorting genetic algorithm II, K. Deb and co-authors’ optimization method for several goals at once. It breeds a population of designs and sorts parents and children into fronts by which designs beat which. It keeps the best half, spread out along the front. It finds a Pareto front rather than one design. See Trade-offs.
Octave band
A range of frequencies, or of wavelengths, whose top is twice its bottom. The turbulence test splits the gust spectrum into octave bands and checks each against the Dryden formula. See Turbulence.
Opening load
The peak force a parachute puts on the rocket as it opens. Knacke writes it as : the steady drag at the dynamic pressure at line stretch, times two factors. is for the canopy’s overshoot when the load doesn’t slow (1.7 for a flat circular canopy). is for how much the rocket slows while the canopy fills. HPR Sim leaves out the overshoot. With a filling time it already includes the slowing, so must not be applied on top; a canopy that opens at once has none. So the opening load it reports is no safe bound either way: don’t size recovery hardware from it. See Recovery.
OpenRocket
A widely used open-source rocket design and simulation program. FusionSpace HPR may run it as an external program to compare results. It never reads or copies its source code, whose license (GPL) is incompatible with FusionSpace HPR’s. The comparison with it is M2.2, the OpenRocket milestone. Its mass comparison (M2.2a) and its flights (M2.2d) are done.
Optimization
Searching for the design that makes a chosen number as small (or as large) as it can be. An example is the squared miss from a target apogee. HPR Sim’s optimizer is CMA-ES. See Optimization.
Oracle
An independent program run to produce reference values for HPR Sim’s
tests. Usually it is another simulator: RocketPy 1.13.0, and OpenRocket 24.12. OpenRocket serves so far for mass,
flights, and the reading of .ork design files and .orc parts catalogs. Other oracles are scripts that
evaluate a published formula in high precision, ThrustCurve.org’s own statistics code, and GDAL
(through rasterio) for elevation files. All the oracles live under validation/oracles/. See
Recovery and the list of simulator oracles.
Override
A measured mass, center of mass or inertia that replaces the value HPR Sim computes. It can be for one part, a part with everything attached to it, or a whole stage. Motors are never covered by one. See The design tree.
A part or a stage can also state its own drag coefficient, in place of the drag its shape gives, as OpenRocket’s Override tab does. See A part’s stated drag coefficient.
Aerodynamic override tables are separate: another program’s drag, or its normal force and center of pressure, flown in place of HPR Sim’s own. See Aerodynamics.
Parallel stage
A stage strapped beside the rocket instead of stacked behind it, such as a set of boosters around a sustainer. The stage’s copies are placed around a body tube, like pods. The copies burn with the core and drop at a separation of their own. OpenRocket calls it a parallel stage or booster set. See The design tree: Parallel stages and Staging: Boosters beside the core.
Parallel-axis theorem
The rule for moving a moment of inertia from an axis through a part’s own center of mass to a parallel axis. Add the part’s mass times the square of the perpendicular distance between the two axes. A part on the rocket’s center line adds nothing to the roll inertia this way, only to pitch and yaw. HPR Sim uses its tensor form to add up the inertias of a rocket’s parts. See Mass properties.
Pareto front
The designs that trade two or more goals off against each other. No design on the front can improve one goal without giving up some of another. A design dominates another when it is no worse in any goal and better in at least one. The front is the designs nothing dominates. Higher apogee against a larger stability margin is one such trade-off. See Trade-offs.
Parquet data page
A Parquet file stores a table column by column, and each column in pieces called data pages. Each has a small header saying how many values it holds and how they are stored. A reader decodes a page at a time. HPR Sim’s pages hold up to 1,024 numbers of 8 bytes each: 8 KiB, the page size the format’s specification recommends. See Exporting a flight.
Percentile
The value below which a given share of a sample falls. The 5th percentile of 200 apogees is the height that about 10 of them didn’t reach. The 50th is the median. HPR Sim computes them by linear interpolation between the sorted values (Hyndman and Fan’s definition 7, as R and NumPy do). See Monte Carlo dispersion.
Pod
A body mounted beside the airframe rather than on its axis: a side pod, or an outboard pod that holds a motor. HPR Sim repeats one pod, and everything in it, evenly around the axis. It turns each copy with its pod as a fin set’s fins turn. It weighs each copy where it sits, so the pods’ inertia is mostly the parallel-axis term. Each pod’s parts fly with their own normal force and drag, once per pod (aerodynamics: Pods). That leaves out the pods’ and the body’s effect on each other’s flow. See Pods.
Power-on and power-off drag
Drag while a motor burns, and while the rocket coasts. Under power, HPR Sim subtracts the burning
motors’ cross-section from the base area, as Niskanen does (a rule no measurement has checked; see
base drag). A drag table can carry separate power-on and power-off curves. A flight uses
power-on drag while any motor burns. OpenRocket 24.12 keeps the whole base under power;
with_full_base_drag_under_power flies its rule, for comparisons with OpenRocket. See Aerodynamics.
Prandtl-Meyer expansion
What happens to a flow faster than sound when its path turns away from itself, as around the shoulder of a boattail. It speeds up and its pressure falls, by an amount that depends only on the Mach number and the angle turned (the Prandtl-Meyer function). HPR Sim uses the pressure after such a turn as the upper limit of a boattail’s wave drag. See Boattails faster than sound.
Probe design
A small design made only to ask an oracle one question, such as “what radius does
OpenRocket give four tubes written auto?”. It is usually a single body tube carrying the one part
being asked about. A probe can be a small file of another kind too: the
parts catalog probes are small .orc files, most
with one part. The project’s probe designs for OpenRocket are written by scripts under
validation/oracles/openrocket/. OpenRocket’s answers are committed under
validation/fixtures/ork/, where tests hold HPR Sim to them. See
.ork design files for one set of them.
Product of inertia
An off-diagonal term of the inertia tensor, such as . It is zero when the mass is balanced about the axes, as in a rocket that is symmetric about its center line. It is not zero when mass sits off the axis on one side, like a single side pod. Its sign follows the positive convention in Mass properties. A rocket with products of inertia turns a little about one axis when pushed about another.
Property test
A test that checks a rule on many randomly generated inputs rather than a few chosen ones. One such rule is that every interpolation table passes exactly through its own points. The project writes them with the proptest library. See Interpolation tables.
Q to S
QUADPACK
A library of routines for computing integrals numerically, published by Piessens and others in 1983 and in the public domain. HPR Sim’s adaptive quadrature uses its 15-point Gauss-Kronrod rule, without its extrapolation. See Adaptive quadrature.
Rail button, launch lug and guide
A rail button is a small flanged knob on the airframe that slides in the launch rail’s slot. A launch lug is a short tube that slides along a launch rod. Both are guides: the parts that hold the rocket on its rod or rail until it leaves. The flight page says guide for either, and button where it follows RocketPy, which models buttons. See Rigid-body flight.
Rail exit and rail-exit velocity
Rail exit is the moment the rocket leaves the launch rail and starts to fly free; the rail-exit velocity is its speed then. HPR Sim keeps the rocket guided until the aft edge of its aft-most rail button or launch lug passes the top of the rail. RocketPy stops guiding it at the forward button. The rocket leaves with no rotation, since tip-off is left out unless a flight asks for it; with it, the rocket leaves turning slightly. Against RocketPy’s tip-off phase, leaving tip-off out moves the landing point by up to 3.765% of the apogee (what leaving tip-off out costs). The slower the exit in a crosswind, the larger the angle of attack just after it, where HPR Sim’s models are least trustworthy. See Rigid-body flight.
Radiosonde
The instrument package a weather balloon carries. It measures pressure, temperature and humidity on the way up, and its drift, tracked by GPS, gives the wind. About 800 stations release one at 00 and 12 UTC each day. What it records is a sounding. See Weather-balloon soundings.
RASAero II
A rocket aerodynamics and flight program. Several of RocketPy’s example rockets carry drag curves labeled as RASAero’s, though only Calisto’s traces to an export. HPR Sim’s drag is compared with those curves from Mach 0.1 to 2.0. The fin shapes and surface finish are guessed, because the curves don’t record them. See Aerodynamics. HPR Sim can also fly the normal force and center of pressure from RASAero II’s exported table (The normal force from RASAero II).
RASP and RockSim files
The two thrust-curve file formats ThrustCurve.org serves. A RASP .eng file is plain text, named after RASP, the rocket simulation program it comes from. A RockSim .rse file is XML, from the RockSim simulator. HPR Sim reads and writes both, and converts one to the other with hpr convert. See Solid motors.
Reanalysis
A record of past weather made by running a weather model over the past, held at each step to the observations of the time. They come from weather balloons, aircraft, satellites and ground stations. It gives the weather everywhere, not just where it was measured. ERA5 is one. See ERA5 weather files.
Reference area
The area every aerodynamic coefficient of the rocket is divided by, . By default is the largest body diameter. It can be set to the nose’s base diameter or to a given value. A drag table with its own reference diameter is rescaled to the rocket’s. A drag model of your own is not (Models of your own). Coefficients from two programs compare only on the same reference area. See The design tree.
Reference value and fixture
A reference value is a number HPR Sim’s result is checked against. It can be a value printed in a source, a
worked example, a closed-form answer or an oracle’s output. A fixture is a committed
file under validation/fixtures/ holding reference values and where they came from. It is written by a
generator under validation/oracles/ or transcribed from print. Tests read fixtures and never
write them: a reference changes only when its generator runs again. See
the validation harness.
Relative and absolute difference
Two ways to say how far a result is from its reference. An absolute difference carries a unit, such as 2e-8 m. A relative difference is the gap as a fraction of the reference value. So 2e-14 relative means two parts in a hundred million million. A percentage is a relative difference in hundredths. These pages mark relative differences with the word relative or a percent sign. See Accuracy.
Reynolds number
The ratio of the air’s inertia to its viscosity over a length, (often written ), without units. Here is the airspeed, a length and the air’s kinematic viscosity. For skin friction HPR Sim takes as the whole rocket, nose tip to the aft end of the last body component. It treats the flow as fully turbulent. See Aerodynamics.
RocketPy
An open-source (MIT) rocket flight simulator written in Python, and HPR Sim’s main partner for code-to-code comparisons. The project runs RocketPy 1.13.0, pinned to one commit, to produce its reference values. See Checking a claim.
Roll damping and roll forcing
Roll forcing is the twist that canted fins put on a rocket about its own axis: each fin pushes sideways off the axis. Roll damping is the air’s resistance to the spin: a rolling fin moves sideways through the air and is pushed back. They balance at a steady roll rate that grows with the airspeed. See Roll: forcing and damping.
Roughness length
The height above the ground at which the logarithmic wind law’s wind falls to zero, written . Rougher ground has a larger one: 0.03 m (1.2 in) for open flat terrain with grass, and 0.001–0.01 m (0.04–0.39 in) for mown grass. HPR Sim’s LogLawWind takes it as roughness_length_m. See Wind.
Running median
A filter that replaces each sample of a series with the median of the samples around it: the middle value once they are sorted. A short spike, fewer samples wide than half the window, is outvoted by its neighbors and disappears. A steady climb or fall passes through unchanged. HPR Sim reads a flight log’s altitude after a 0.3 s running median, which removes the pressure pulse of an ejection charge (Flight-log readings).
Same-drag and predicted mode
Two ways of comparing HPR Sim’s whole flights with another simulator’s. In same-drag mode both codes fly one drag coefficient that the comparison declares. A difference then comes from the equations of motion, the motor or the air, not the drag. In predicted mode HPR Sim works out its own aerodynamics from the rocket’s shape. The other code flies the drag its example ships (from RASAero, OpenRocket or the team). A difference is then mostly the two drags. Neither drag is known to be right, so those results are held to a target, not a gate. See Accuracy and Accuracy.
Scientific notation
Writing a very small or very large number as a power of ten, the way programs print it. 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, and 1e6 is a million. is 2 multiplied by itself 20 times, about a million. See Accuracy.
Seed
A number that starts a random-number generator. The same seed gives the same sequence of numbers. So a run that uses random numbers, such as turbulence or a Monte Carlo run, repeats exactly on the same platform (operating system and processor). The program that runs it chooses the seed. On another platform each random draw can differ in its last binary digit, and over a whole flight such differences can grow. See Turbulence.
Sensitivity analysis
Finding which uncertain inputs move a result most, so you know which to measure carefully and which don’t matter. HPR Sim has Morris’s screening, which ranks inputs from a few runs each through their elementary effects. It also has Sobol’ indices, which share out the result’s variance. See Sensitivity analysis.
Separation
A stack coming apart for recovery. At its trigger HPR Sim splits the rocket into bodies (body 0 keeps the nose). Each descends on its own under its own recovery devices, which it must have. It adds no impulse, and the aft part’s motors must have burned out. When the forward part still has a motor to burn, it flies on as a sustainer and only the aft part descends. A part leaving at any other joint is an ejection. See Recovery and Staging.
Shear modulus
How hard a material resists being twisted or sheared, , in pascals (Pa): the shear stress over the shear strain it causes. Aluminum’s is about 26 GPa, birch plywood’s 0.75 GPa. A fin twists in its own plane, so its flutter speed needs the shear modulus in that plane. See Fin flutter.
Shoulder
The sleeve at the end of a nose cone or transition that slides into the next body tube. It counts toward the rocket’s mass, but it is inside the body, so it adds no aerodynamic force. The drag buildup also uses the word for a transition that widens toward the tail, whose pressure drag is counted like a nose’s. See Aerodynamics.
SI units
The International System of Units: meters, kilograms and seconds, and units built from them, such as newtons for force and pascals for pressure. HPR Sim works in SI throughout, with angles in radians. Degrees appear only where values come in or go out, as in Geodetic::from_degrees. In the code, a quantity’s name ends in its unit, such as mass_kg or vertical_speed_m_s. See Frames.
Slender-body theory
A way to work out the air’s forces on a long, thin body from how fast its cross-section grows along its length. At any Mach number, it gives a nose as wide as the reference a normal-force slope of 2 per radian, whatever its shape. A transition gets and a plain tube nothing, at any Mach number too. Barrowman’s method uses it for every body part. HPR Sim uses it below Mach 1.2, and at every speed for bodies the shock-expansion method can’t take. These are steps and a nose too blunt for its cap. A third is a widening shape that isn’t a cone, isn’t flush with the part ahead of it, or rides in a boattail’s wake. NASA’s wind tunnel shows a real body lifting more past Mach 3. See Aerodynamics.
Sobol’ index
The share of a result’s variance that one uncertain input causes: alone (its first-order index), or alone and together with the others (its total index). Named after I. M. Sobol’, who defined them. See Sensitivity analysis.
Sounding
A measured or forecast profile of the air against height: pressure, temperature and wind, and sometimes humidity. A sounding comes from a weather balloon (a radiosonde) or a forecast service. HPR Sim can fly one in place of the standard atmosphere, which carries on above its top level. Flights above a few kilometers need one, because an offset to the standard for field conditions holds all the way up. See Atmosphere.
Specific force
What an accelerometer reads: every force on the rocket but gravity, over its mass, in m/s² or g.
Standing on the pad it reads +1 g, the pad’s push against gravity. In the climb it reads the thrust
less the drag over the mass; coasting, the drag’s pull back, below zero; falling in vacuum, 0. Less 1 g,
the specific force along the axis of a rocket climbing straight up is its own acceleration.
hpr analyze’s top acceleration is a specific force, with the 1 g in; hpr sim’s
max_acceleration_m_s2 is the rocket’s own acceleration, and its opening shock,
max_descent_acceleration_m_s2, a specific force. See
Flight-log readings.
Specific impulse
Impulse per unit weight of propellant, , in seconds, with :
the effective exhaust velocity divided by . RockSim .rse files
carry it as Isp; HPR Sim works with the exhaust velocity instead. See
Solid motors and
RockSim .rse files.
Stability margin
How far the center of pressure lies behind the center of gravity, usually in calibers. A positive margin turns the rocket’s nose back into the oncoming air when it is disturbed. In a crosswind that direction is not quite its flight path (weathercocking). It changes through a flight as propellant burns and speed changes. HPR Sim gives it from the rail exit to apogee or the first deployment, with the air along the axis. It gives two, at Mach 0 (the static margin) and at the flight’s Mach number (the flight margin). Where the parts’ normal forces all but cancel, it gives none. A rocket with a fin set of one or two fins has a different margin for each direction the air crosses it. The simulator gives the least. See Flight metrics.
Stage
A section of a rocket’s stack in the design tree, listed forward to aft. A separation splits the rocket at the boundary between two stages, so a rocket that stays in one piece needs only one stage. Each motor lights at its own time, so stages can fire in sequence. See The design tree and Staging.
Stall
The pages use the word in two ways. In aerodynamics it is the loss of lift at a large
angle of attack. HPR Sim models none, so it overstates forces at large angles.
In the flight engine it is the rocket’s speed along the rail falling to zero. After burnout, that
ends a flight as StalledOnRail. See
Aerodynamics and
Rigid-body flight.
Standard atmosphere
An agreed model of the air’s temperature, pressure and density against height. HPR Sim uses the 1976 U.S. Standard Atmosphere from −5 km (−16,404 ft) to 86 km (282,152 ft). At sea level it has 288.15 K and 101,325 Pa. It can be offset to match conditions at the field, or replaced by a sounding. See Atmosphere.
Standard deviation
How widely a set of numbers spreads about its mean: the square root of the mean squared difference from the mean. For a sample, it divides by one less than the count. For a normal distribution about two values in three lie within one standard deviation of the mean, and 95% within two. See Monte Carlo dispersion.
Standard error
The scatter expected by chance in an average taken from a random sample; it shrinks as the sample grows. HPR Sim’s turbulence test requires each band’s average to lie within 4 standard errors of the Dryden formula. See Turbulence.
Station
A position along the rocket, in meters aft of the nose tip, the way design files give positions. Station is in the body frame. See The design tree.
Sting
The rod that holds a wind-tunnel model from behind, entering its base. It changes the air pressure on the base, so a tunnel can’t measure a free-flying rocket’s base drag, only the forebody’s. See Aerodynamics.
Stiff problem
A problem with some motion so fast, and so strongly damped, that a method such as Dormand-Prince must take tiny steps to stay stable. HPR Sim doesn’t detect stiffness: the run stops with an error when its steps get too small or too many. See Time integration.
Stop time
A time the integrator steps to exactly rather than across, because the equations change there. Stop times include thrust-curve points, burnouts, deployments and the end of a canopy’s filling. A Runge-Kutta step across such a jump loses most of its accuracy. See Time integration and events.
Streamer
A long strip of fabric used instead of a parachute to slow a rocket’s fall. Its drag is taken on its one-side area, length times width. HPR Sim’s default model reads 9% fast on the one flat streamer in Kidwell’s drop tests. It models no pleats, so it predicts a faster descent for a pleated one. See Recovery.
Supersonic linear theory
The small-angle theory of thin surfaces faster than sound. A flat plate at an angle feels a pressure proportional to , the same all along its chord. HPR Sim uses it for fins from the speed where it holds (about Mach 1.2 or later, set by each fin’s sweep and shape). See Aerodynamics.
Surface layer
The air nearest the ground, where friction with the ground sets how fast the wind grows with height. HPR Sim’s power-law and log-law winds describe it, but keep growing above it, so winds aloft should come from a table of levels. See Wind.
Sustainer
The forward part of a staged rocket, with the nose, that flies on after the booster is dropped and lights its own motor. In HPR Sim a separation whose forward part still has a motor to burn makes it a sustainer. It is flown in six degrees of freedom with its own shape and mass. See Staging.
T to W
Tangent cone
The cone that touches a body along one short element of it: the same half-angle, with its apex on the axis. HPR Sim’s supersonic body method works element by element. Each element’s pressure relaxes toward the pressure on its own tangent cone, looked up in tables that stop at 30°. A cylinder’s tangent cone is the free stream. See Bodies faster than sound.
Tangent ogive
A nose cone whose sides are a circular arc that meets the body tube without a kink: its slope is zero at the base. A 3:1 tangent ogive is three times as long as its base is wide, a fineness ratio of 3. HPR Sim models it as the secant ogive whose arc radius equals the tangent radius. See Shapes.
Thrust curve
A motor’s thrust against time since ignition: (time, thrust) points joined by straight lines, read
from a RASP .eng or RockSim .rse file. HPR Sim starts it from zero thrust at ignition and takes the
thrust as zero from the last point on. It treats two points at the same time as a sudden step. See
Solid motors.
ThrustCurve.org
A public database of motor thrust curves and data. HPR Sim carries a copy of its whole solid catalog
(the whole catalog), flies its motors by name,
and runs its statistics code to check its own. A file downloaded from it can be read and flown
(A motor from a file). The library can search it and
download a motor’s files itself
(matching motors).
hpr sim and hpr motors fetch fetch a motor the bundled catalog lacks into the simulator’s cache
(the command line). See
Solid motors.
Tip-off
The unwanted turn a rocket picks up as it is let go. Leaving a launch rail, it pivots about its last guide, the aft-most rail button or launch lug. The recovery page uses the word for a separation too. By default HPR Sim models neither: a rocket leaves the rail with no rotation, and a separated body starts with no spin of its own. RocketPy’s tip-off phase puts the cost of leaving the first out at up to 3.765% of the apogee in the landing point. That is one code against another, and no flight checks it (what leaving tip-off out costs). The Rust library flies a tip-off phase when a flight asks for it. It is held to RocketPy’s in still air, and in a crosswind on RocketPy’s normal force. No milestone plans the second yet. See Rigid-body flight and Recovery.
Title block
The box in an engineering drawing’s corner that says what the drawing is, who issued it,
when, in which units and from which sources. ISO 7200 is the standard that lists its fields.
This site’s is on Start here, and the printed guide ends with it,
with the guide’s own title added after the site’s. Every other page ends with one line taken from it: the
version, the date and the status. A hpr sim --plot figure ends with a title block too.
Tolerance
How far a result may be from its reference and still pass, such as the 0.1% a landing speed is held
to. Each test and each validation case states its own, next to
the reason for its size. The integrator’s rtol and atol are tolerances in a second sense: how
much error each adaptive time step may make. See the
validation report and Time integration and events.
Total impulse
A motor’s total push, the area under its thrust curve, , in newton-seconds (N·s). It sets the impulse class. HPR Sim integrates the straight-line curve exactly. See Solid motors.
Transonic and supersonic
Flight near the speed of sound (transonic) and above it (supersonic), where shock waves change the drag and the lift. Since M1.8a HPR Sim carries the normal force and center of pressure through both, to Mach 5. For the fins it uses supersonic linear theory, joined to the subsonic method between Mach 0.8 and the speed where that theory holds. Since M1.8b1 (drag through Mach 1) its drag goes to Mach 5 too. It is Niskanen’s semi-empirical method, with the wave drag of noses and shoulders from closed forms and from Stoney’s 1961 NASA measurements. See Aerodynamics and Aerodynamics.
Tube fin
A short open tube glued along the airframe in place of a flat fin. A tube fin set is a ring of
them around the body. HPR Sim weighs each tube as a hollow cylinder beside the body. A .ork file
can leave the tubes’ radius to OpenRocket. With three tubes or more, OpenRocket makes them just wide
enough to touch the body and each other; one or two take the body’s radius. HPR Sim reads that
radius as OpenRocket does. The aerodynamics flies each tube as a ring wing, below Mach 0.8
(M2.2e9). See
.ork design files,
Mass properties and Aerodynamics.
Tumble recovery
Recovery with nothing deployed: the body falls broadside, tumbling, and its own drag slows it. HPR Sim takes its drag area from the OpenRocket technical documentation’s fit to the fin and side-profile areas. The fit comes out −10% to +19% off that source’s own drop tests. The simulator doesn’t decide by itself when a body tumbles: you give the tumble a trigger. See Recovery.
Turbulence (Dryden)
Random gusts on top of the steady wind. HPR Sim models them with the Dryden spectra of MIL-F-8785C, a military aircraft specification. They come from a seeded generator that repeats bit for bit for the same seed on one platform. No flight uses turbulence yet, none is planned (issue #39), and Dryden is unvalidated for rockets (evidence row G12). See Turbulence.
Validation case
One comparison the validation suite runs: what to fly, which numbers (metrics) to compare, each
with its own tolerance, and against which
reference values. cargo xtask validate runs every case and writes
the committed validation report, with every number and its verdict. See
the validation harness.
Verification and validation
Verification checks that the code does what its model says, against closed-form answers, printed tables and worked examples. Validation checks that the model matches the real world. This project ranks its evidence in four kinds, named as on Accuracy. They are analytic (exact answers), published source (printed tables and worked examples), another code (code-to-code comparison), and real flights. See Accuracy.
Variance
The square of the standard deviation: the mean squared distance of a quantity from its mean. Unlike standard deviations, the variances that independent causes contribute add up, which is why Sobol’ indices share out the variance. See Sensitivity analysis.
Vertical datum
The surface heights are measured from. NAVD88, the North American Vertical Datum of 1988, is within a meter or two of the geoid. EGM2008, a worldwide model of the geoid, is too. So HPR Sim takes heights above them as heights above sea level. NAVD88, set by leveling, is about half a meter off the geoid and tilted about a meter coast to coast (NGS). An ellipsoidal height is measured from the ellipsoid instead. See A launch site’s elevation.
Virtual temperature
The temperature dry air would need to have the density of a humid parcel at the same pressure:
with the water vapor’s pressure and the ratio of the molar masses of water and dry air (WMO-No. 8, eq. 12.18). Water vapor is lighter than air, so is a little above : about 1.6% at 30 °C, saturation and sea-level pressure. See Atmosphere.
Wave drag
The drag from the shock waves that form on a rocket at and above the speed of sound. Air meeting a nose, a shoulder that widens or a fin’s leading edge passes through a shock. That raises the pressure pushing back on the surface. Behind a boattail the opposite happens: the air expands around it, its pressure falls, and that pulls back on the boattail. It is much of the steep rise in drag near Mach 1. HPR Sim has no separate term for it. It is part of the pressure drag of each nose, shoulder and step, which Niskanen’s 2009 method carries through Mach 1. It is also part of each boattail’s pressure drag (Boattails faster than sound). For fins, the simulator uses a blunt leading edge’s formula, which reads far high for thin, sharp fins (Drag limits). See Aerodynamics.
Weathercocking
A stable rocket turning into the wind it feels. Off the rail in a crosswind, the airflow meets the rocket partly from the side. The normal force, acting behind the center of gravity, swings the nose toward it, so the rocket climbs upwind. In HPR Sim’s test, a 5 m/s (11 mph) wind from the west puts Valetudo’s apogee 86 m (282 ft) upwind. See Rigid-body flight.
WGS 84
The World Geodetic System 1984: the model of the Earth’s shape and gravity that GPS uses. Its ellipsoid has an equatorial radius and a flattening . HPR Sim’s latitudes, heights and normal gravity are all on it. See Geodesy.
Wind direction
HPR Sim gives the wind’s direction the meteorological way: where it blows from, clockwise from true north. So a wind from the west (, 270°) blows toward the east. RocketPy’s wind heading is where it blows toward, 180° from this. The wind itself is the air’s velocity in the launch frame’s east and north axes. See Wind.
World Magnetic Model (WMM)
The model of the Earth’s main magnetic field that NOAA and the British Geological Survey publish every five years. GPS receivers and phones use it to give compass headings. HPR Sim bundles WMM2025, valid from 2025.0 to 2030.0, and gives the field’s strength, dip and declination anywhere in that time. See The magnetic field.
Writing these pages
Learn the house style that every page and doc comment on this site follows, for its words, its layout and its design.
This page is the house style for FusionSpace HPR’s documentation. It’s for anyone who writes or edits a page of this site, a model page, or a doc comment. It applies to every new page and to every page a change touches. Older pages move to it as they’re edited, not all at once.
The aim is simple. A hobby rocketeer who knows some physics and some code, but not this project, reads a page once and knows what it says. They also know how far to trust it.
cargo xtask spelling reads each page’s words and names, and counts its exceptions on every
run. cargo xtask voice fails a stock phrase and counts the voice section’s patterns against
its limits. cargo xtask guides reads every number in a guide’s text from a committed report.
cargo xtask site counts each page’s parts and fails one outside two to six. It also fails a
trust note or an alert off its shape, a hyphen for a minus sign, a column of numbers not
right-aligned or without a label and a unit, a note or table cell over 120 words, a figure of
four or more digits without its commas, and an ISO date in prose.
The rules
- Bottom line first. The first sentence of a page, a section or a paragraph says what it concludes. The detail and the reasoning come after. On a page where a person is talking, the reasoning is in the maintainer’s own words (Voice).
- One idea a sentence. Aim for about 20 words a sentence on average. A sentence over 25 words is flagged for a second look; it is not forbidden.
- Short paragraphs. Five sentences at most.
- Numbers carry their meaning. Every number has a unit, and says what it is compared with: “apogee 1.2% above RocketPy’s”, not “1.2% error”.
- One fact, one precision. The same fact is written with the same precision everywhere it appears. If one page gives the real-flight apogee error as 9.00%, no other page rounds it to 9%.
- Labels are links. An internal label, such as a milestone or a decision record, is a link with a few words of meaning, never bare. The site’s checks enforce this one (the documentation site decision record).
- Words before equations. Say in words what an equation does, give the equation, then work an example with real numbers.
- Honesty comes first. These standing rules still apply. A page opens by saying how far to trust it. Anything unvalidated says so in its first paragraph. Example code runs in CI, and an accuracy number comes from the committed validation report (Checking a claim).
Equations
Equations are typeset, as a textbook sets them. You write them in LaTeX between dollar signs, and they become MathML when the site builds. They’re drawn in New Computer Modern Math, the face of LaTeX’s own textbooks (the product system’s Type rule; the decision).
GitHub shows the same source as math too. A formula the converter can’t read fails the build, with
its page and line. cargo xtask site-math --check docs/<page>.md converts a page’s formulas as the
build does. It notes any formula long enough to risk a phone’s column.
-
In a sentence,
$…$: “the drag force grows as ”. A symbol the text names is math too, so the sentence and the equation match: , not ρ orrho. Keep an inline formula short, a few symbols. It can’t wrap, and one wider than a phone’s column fails the page check. Inline, write a fraction with a slash, ; only a number’s fraction is stacked, . -
On its own,
$$…$$as its own paragraph, with a blank line above and below. Use it for an equation the page is about, or anything longer than a few symbols. It is centered, unnumbered; the text names it.It must fit a 320 px phone, about 30 characters of math. Write a longer one on several lines with
\begin{aligned}, each line broken before=or an operator and aligned at&=. A product written side by side breaks with no operator, never an invented\times. Never shrink or scroll one.In a list item, indent the
$$lines to the item’s text. A line right under a display fails the build, since it would show as raw text.$$ \begin{aligned} q &= \tfrac12 \rho v^2, \\ D &= q\, C_D A \end{aligned} $$ -
Notation, after ISO 80000-2. One-letter variables are italic (the default). Words, names of more than one letter, units and the differential d are upright:
\mathrm{Re},\mathrm{d}t,9.81\,\mathrm{m/s^2}. Vectors are bold,\mathbf{v}, never\vec, whose arrow browsers misplace (the build refuses it).A one-letter subscript that labels stays italic, as these pages have always written it (, ). A word or an abbreviation is upright (, ). A script inside a script would be under 12 px: write , not
C_{D_0}, and , note^{-x^2/2}. -
Numbers: a value tied to a symbol goes in the math, its unit upright, . A value in a sentence stays in words and plain units, as every other number does. A power of ten is in math, and 1e-6 only where a program reads or prints it.
-
Never in a heading or an image’s description: the build refuses math there.
-
Not math: code, field names, file names, command lines and program output stay in code,
mass_kg,hpr sim. A quoted reading keeps its unit in words, “a top speed of 355 m/s (1,165 ft/s)”. Doc comments and terminal output keep plain Unicode,F = ½ ρ v² C_D A, which reads better there than LaTeX source. A dollar sign that isn’t math is written\$.
Voice
Write as one person explaining their own work to another flyer: plain words, short sentences, each thing said once. These pages are one maintainer’s project, and they should read that way.
A read-through on October 18, 2026 found them correct but generic. Bullets opened with a bold label, lists of three all looked alike and caveats were stacked on caveats. Pages opened with “FusionSpace HPR is a …” where a person would say why they built it (the decision record).
Each rule here comes from that read-through or from a survey of plain technical writing. Each shows a passage from these pages as it stood when its rule was written, then the same passage in this voice. The Before passages in the two sections after Honest, once are the pages as of November 20, 2026, and the rest as of October 19.
Where “I” goes
Use “I” where a person is talking: the README, the landing pages, the pages that say why something exists, the guides and the release notes. It’s one person’s project, so there’s no company “we”. The bottom line still comes first (rule 1), and the why follows it, in the maintainer’s words.
Reference pages stay impersonal: a model’s equations, a file format, a command’s options, the glossary. There the program is the subject, and “you” gives the steps, as it does in a tutorial or a how-to.
Before, in the contributing guide: “Publishing packages, creating releases and tags, and changing repository settings are the maintainer’s to do.”
After: “Only I publish packages, create releases and tags, or change the repository’s settings.”
Plain words
Use the plain word. Leave out the words that tell a reader something is “easy” or “quick”: what’s “quick” for you may not be for them. Never use a stock phrase. The check holds a list of them and fails the build on one (the check).
Before, in Pick a motor: “Flying a few more motors is quick: change --motor
and --delay and run again.”
After: “To fly a few more motors, change --motor and --delay and run it again.”
Short sentences
Aim for about 20 words a sentence (rule 2), and use contractions where you’d say them: “isn’t”, “doesn’t”, “it’s”. A sentence that carries five things is better as a few sentences, or as a list.
Before, in the README: “Flight in six degrees of freedom (6-DOF: three of position, three of rotation), with variable mass: aerodynamics from subsonic to supersonic, the standard atmosphere or a measured one, winds that change with height, staging, clusters and air starts, and recovery with drift.”
After: “It flies a rocket in six degrees of freedom (6-DOF), three of position and three of rotation, with its mass changing in flight. The aerodynamics run from subsonic to supersonic. The air is the standard atmosphere or a measured one, with winds that change with height. It covers staging, clusters and air starts, and recovery with drift.”
Say it once
Say a thing once, where it belongs. Don’t announce what a section covers, point back to what was
said (“as mentioned”), or recap it at the end (In summary). The heading and the first sentence
already say what a section is about.
Before, in the OpenRocket format page: “This section compares HPR Sim’s whole flights with OpenRocket 24.12’s on the 54 configurations of OpenRocket’s example designs that HPR Sim can fly, in 15 of the examples.”
After: “HPR Sim’s whole flights are compared with OpenRocket 24.12’s on 54 configurations. They’re the configurations of OpenRocket’s example designs that HPR Sim can fly, in 15 of the examples.”
Paragraphs and lists
Write a thought as a paragraph. Use a list for what really is a list: steps, options, parts. Give a list as many items as there are, not three of the same shape because three sounds finished.
Open an item with a bold label only where a reader scans for it, as in a list of options. A model page’s In short box is another such place. Bold-label items count toward the limit, except the four labels of a model page’s In short box (below). A line that opens with a bold label reads like a form, as this pair shows.
Before, in the README: “Status: RELEASED. Version 0.1.0, released October 8, 2026; work toward 0.2 goes on here.”
After: “Version 0.1.0 came out on October 8, 2026, and work toward 0.2 goes on here.”
Labels
Say what a thing is before its label. Use a label (a milestone or a decision number) only where the reader needs to follow it. A sentence that opens with one sends the reader to look it up before they know why.
Before: “Neither set is held out: both were seen during development, so neither is a blind test until M2.7 holds flights out, predicted before their logs are read.”
After: “Neither set is held out. Both were seen during development, so neither is a blind test. That waits for the planned milestone that holds flights out, predicted before their logs are read (held-out flights).”
Honest, once
Honesty stays exactly as strict (rule 8): what was checked, against what, and where it stops. Say it once and plainly, like someone who checked. Put a hedge on the claim it qualifies, not on every clause around it.
Before, in the simulator’s tour: “Here the drag may read high, so the apogee may read low: for a field’s ceiling, the side that flatters (Trusting a simulation).”
After: “Here the drag may read high. If it does, the apogee reads low, the side that flatters a field’s ceiling (Trusting a simulation).”
A past mistake, owned
When a number or a behavior was wrong before, say so in one sentence, and give what it meant for a reader (the survey’s rules). The survey found this on SQLite’s pages: “Due to an historical oversight, the column values of a PRIMARY KEY are allowed to be NULL” (what personal-voice pages do).
Before, in When fins flutter: “Loft, HPR Sim’s predecessor, made the same mistake (a lesson from Loft).”
After: “Loft, my earlier project, made the same mistake, so its flutter speeds read 41% high, the side that flatters (a lesson from Loft).”
Numbers that go stale
A number that can change after it’s written carries the date or the version it was measured at (the survey’s rules). Examples are an accuracy figure, a rule’s value and a catalog’s count. Say which side it errs on too, as the survey found on SQLite’s pages: “The 100K hits/day figure is a conservative estimate, not a hard upper bound” (what personal-voice pages do).
Before, in Pick a motor: “hpr motors list filters the 1,004 motors built
into the simulator by diameter, impulse class or maker.”
After: “hpr motors list filters the simulator’s built-in motors by diameter, impulse class or
maker. There are 1,004, ThrustCurve.org’s catalog as of October 28, 2026. It errs by leaving out
newer motors: one ThrustCurve.org added since is missing until hpr motors update or
hpr motors fetch gets it.”
The limits
cargo xtask voice counts these on each page, per 100 words, and its report marks a page over a
limit. A page over one is where to look first. On a page that isn’t held, it doesn’t fail the
build (the check).
| Counted | What it counts | Limit, count per 100 words |
|---|---|---|
| Bold-label items | a list item that opens with bold text, less the four labels of a model page’s In short box | 0.5 |
| Labels | a milestone, decision or lesson number, linked or not | 0.5 |
| Sentences over 25 words | in paragraphs and list items | 0.5 |
| Hedges | may, might, could, possibly, perhaps, probably, likely, seems, appears and the like | 1.0 |
| Stacked hedges | a sentence holding two or more hedges | 0.1 |
| Minimizers | simply, just, easy, easily, quick, quickly | 0.1 |
| Signposts | “in this section”, “as mentioned”, “let’s”, “in short,” and the like | 0.1 |
| First person on a reference page | “I”, “me”, “my” and their forms (I’m, mine, myself) on a model, format, command or glossary page | 0 |
Hedges leave out a capital “May” and “could not”. Minimizers leave out “just” before one of sixteen words of place or time (“just below”, “just after”). They also leave out “how quick” and “how quickly”, which measure something here.
First person counts a capital I before a lower-case word other than “is”. It doesn’t count one after a word that makes it a numeral or a name (“Type I”), or before a motor word (“an I motor”). So it leaves out “where I is the inertia”, and an I at a clause’s end or before a comma (“so did I”). It still counts a symbol I before another word (“the current I flowing”).
A quotation inside one sentence isn’t read for hedges, minimizers, signposts, first person or who’s talking, though the stock list reads it.
The sentence limit comes from the target this guide already set. That’s fewer than 10% of sentences over 25 words, at about 20 words a sentence, or 0.5 per 100 words. On a page of shorter sentences the limit is stricter than 10%. On a page with many words in headings and tables it’s looser, since those words count but hold no sentences. So the report prints each page’s share too.
A bold-label limit of 0.5 still allows a list of ten options on a 2,000-word page. It doesn’t allow a bold label on every item of every list. Labels get one every 200 words, because each one sends the reader off to look it up.
Hedges get 1.0, because a single hedge is often the honest word. That’s about the top of the range the survey measured on one writer’s blog: 2.2 to 11.9 per 1,000 words. That count used a mostly different list of hedges.
Stacked hedges, minimizers and signposts get one every 1,000 words. Each adds little: a second hedge, a word that calls a step easy, a sentence that points back at the page. Use one only on purpose.
First person on a reference page gets 0, because the program is the subject there. The other limits were set against these pages as they stood on October 19, 2026. Most of them were then over the sentence limit, and about half over the bold-label limit. The report gives the current counts.
Who’s talking (the report’s register) has no limit of its own, since the right amount depends on the kind of page. Only first person on a reference page is held to one, above. The report prints it per page: “I”, “we”, “you” and contractions per 100 words.
For scale, the survey found 1.0 to 3.5 contractions per 100 words on most personal pages. On reference pages it found 0 to 0.25. One author wrote about 3 “I” per 100 words on a blog and none on the project’s reference pages.
The check
cargo xtask voice reads this repository’s pages, prints the report, and fails on a stock
phrase. With no path, it also fails when a held page goes over a limit or misses a sentence target
(below). The site’s build runs the same check, and fails CI on either. It
also writes the report onto How the pages read from the pages. The report
isn’t committed, so it is never stale.
Give it paths, such as cargo xtask voice ../fusionspace-site/site, and it reads those instead
and prints the report. It reads Markdown, HTML and text, a command’s help in a .help file, and
a crate’s front page in a .rs file. That’s how
fusionspace.co’s pages and the design
system’s get checked. In the report, a rate in bold is over its limit, and ref marks a
reference page. With --long first, it lists each sentence over 25 words in the prose instead, with its file and line.
A change to prose alone can run cargo voice in place of cargo xtask voice. It’s the same check: it takes the same
paths and --long, and with no path prints the same report. Nothing is committed: the site’s
build writes the report onto its page. It builds only the check
and its Markdown reader. cargo xtask builds the simulator’s crates first. Then
scripts/gate.sh voice runs the check’s tests, without the simulator either. The gate runs most of CI’s commands locally, as
CONTRIBUTING.md
describes. This covers the voice check only. scripts/gate.sh docs pages runs the site’s other
checks on a page, and those build the simulator.
On any page, the stock-phrase list fails a build. It holds 41 entries in 9 groups. Each is named by a published list or by the design system’s own writing rules. The lists are style guides, studies, and Wikipedia’s pages on word choice and on signs of generated writing:
- puffery:
seamless,cutting-edge - inflated words:
pivotal,testament - words that spread with generated text:
delve,showcase - buzz verbs:
leverages,utilize - note-that phrases:
please note - vague sources:
research has shown - wordy phrases:
in order to,a number of - recaps:
in conclusion - chat residue:
I hope this helps
The list leaves out words that have a technical sense in this project. They are robust, deploy,
streamline (a streamlined body), boost and powerful (a more powerful motor). Terms such as
magic bytes and seamless tube pass. The list is in
xtask/voice/src/voice.rs,
each entry with its sources and a test that fails without it.
It reads the README, the changelog, the contributing guide, the pull request and issue templates
(less the guidance in their comments) and docs/. It leaves out:
- the decision records and the done-work archive, which are history;
- the records pages, written from the decision records and the roadmap, and the roadmap itself, the open work;
- the research notes, which keep their wording until they’re next edited;
- the site’s table of contents, which is links.
It counts what a program can count. Voice is partly taste, so a cold reader checks each rewritten page against these rules too.
Measured, not gated
Every site page is held: each page the site’s table of contents lists, and the README and the
404 page beside them. The one exception is the decisions and roadmap page, a record written from
the roadmap and the decision records. On a held page, one rate over its limit, or one sentence
target missed, fails the build. The report marks those pages held. A page added to the table of
contents is held from its first commit
(the plan that rewrote the site).
The command-line tool’s help is held the same way. A test pins each command’s --help in a
snapshot under crates/hpr-cli/tests/help/, and the check holds every snapshot. It reads only the
help’s prose: option names, notes such as [default: 0] and example commands are code to it, so a
default that needs words goes in a sentence. Change a command’s help and the test fails until you
regenerate the snapshots with
HPR_BLESS=1 cargo test -p fusionspace-hpr-cli --test help
(the plan for the program’s words).
Every command’s messages are held too: what hpr sim, weather, analyze and the others
print. The source doesn’t say which string ends up in a message, so the check reads a census
of the code. It reads hpr-cli, hpr, the twelve crates under it and the Python package’s
hpr-py: every #[error] text and every other string that reads as prose, less tests and
markup. Each crate is one held reference page. A
placeholder such as {path} is one code word. A joined message is read in pieces, so a long one
can pass. cargo xtask voice --long --messages lists each long sentence with its file and line, and
--messages the whole census; the voice report counts what it read.
The Python package’s docs and the crates’ front pages are held too. A test of the package writes
its docstrings, as help() shows them, to crates/hpr-py/tests/docstrings.md. The check holds
that snapshot as a reference page, and the package’s README beside it. Change a docstring and
the test fails until you write the snapshot again with HPR_BLESS=1 scripts/python-tests.sh 3.13.
Each crate’s front page is the //! docs at the top of its src/lib.rs, the page docs.rs shows.
The check holds each one as a reference page, and refuses a crate that has none.
On the other pages the check reads, such as the changelog and the vision, readability is measured, not used to fail a build. The counts show where to look, and a person decides what to change.
The site also holds a model page’s In short box to its shape. It’s four bulleted items, each
opening with its label in bold: **What it models:**, **Sources:**, **How well it is validated:** and **What it leaves out:**, in that order. A reader scans the box, and on a short
page its four labels alone would exceed the limit. So on a box of that shape the check doesn’t
count those four labels as bold-label items. A box the site refuses keeps them in the count, and
any other bold label on a model page counts.
A cap of about 150 words on the box was planned and isn’t built yet.
The targets for user pages are at most 20 words a sentence on average and fewer than 10% of sentences over 25 words. The report prints both for every page.
The FusionSpace rules
FusionSpace HPR · Sim is a FusionSpace product, FS-ACHERNAR · SW · TOOL 001 (Achernar, a star
of project Eridanus).
Its pages also follow the product system’s writing rules
and number rules
(the product system decision record).
They don’t conflict with the rules above; they add these:
-
US English: color, center, meter, catalog, license, analyze, gray. A product or command name keeps the spelling it shipped with, and a quotation or a source’s title keeps its own.
-
No em dashes. Use a colon, a comma or a period. An en dash only in ranges: 5,100–5,500 ft.
-
Both are checked.
cargo xtask spellingflags each British spelling on its list and names the US word to write. Since M0.6d3, that’s center, meter, catalog, license, color, analyze, behavior and modeling. Since M0.9e (the words to the design), it’s also:- caliber, fiber, liter and maneuver;
- labeled, traveled, signaled, fueled and the other doubled l’s;
- favor, neighbor, vapor, honor and the other -our words;
- defense, aluminum, gray, judgment, sulfur, aging and program;
- the endings -ize, -izing and -ization for -ise, -ising and -isation, on the stems on its list (normalize, optimization, summarizing).
It flags every em dash, in the pages and their code blocks, the crates,
xtaskand the schema alike. It reads the pages, the README, the scripts, the crates,xtaskand the schema. In a page it reads the prose, and each code block as its language reads: arustblock’s comments and strings, atextblock whole. In a source file it reads the comments and strings. It skips addresses, the frozen decision records and its own word list. -
Names are checked too (since M0.6e). The check reads every name in the code, and a string that is one bare key such as
"center_x". It reads each name in the writing too: in backticks, joined by_, or in a format string. It reportscentre_of_pressure_mas “call itcenter_of_pressure_m”.The check keeps a short list of exceptions, which it counts on every run. An exception is a quotation, a source’s title or a name that keeps its spelling. It can also be a key held by files saved before the rename, or by another program’s format.
--fixreplaces words but not names. A renamed name that is saved to a file keeps its old key as a serde alias, which HPR Sim reads and never writes. An em dash needs its sentence rewritten. CI runs the check in the site step. -
Numbers on the site are checked (since M0.9e). Outside code,
cargo xtask sitefails a hyphen-minus written for a minus sign,-7.28%. The page should have the real one,−7.28%(U+2212).It also fails a table column whose cells are all numbers, unless its delimiter right-aligns it,
---:. A number here is a figure with its units, sign, spread or range, such as1,400 m (4,593 ft),−7.28%or−29 to −34%. A cell in code, a date or a version is a label, and so is any cell under a head that says “version”. A cell with any other word makes its column a text column. An empty cell, a dash, “n/a” or “none” doesn’t count.Since M0.9f2,
cargo xtask sitealso reads the head of each right-aligned column, on the site and in both READMEs, as a label and then a unit:- The label is a word of two or more letters outside code and math that isn’t a unit, in the
head outside its brackets and before its first comma,
·or;. A code identifier alone (apogee_agl_m), a figure or a unit alone ((kg)) is no label. - The unit goes where a unit goes: the first word in brackets, after a comma,
·or;, or after “in” (time (s),Worst time, s,CP, calibers aft of the tip,Offset in bytes), or “per” and a unit or a counted plural (slope, per rad,per 100 words;Time per stepgives none). A unit word elsewhere gives none (Error in apogee), nor doesinwith words after it (Apogee, in flight), andCandFneed their degree sign (°C). - A pure number names its kind as the label’s last word: a coefficient, ratio, fraction,
share, factor, number, count, code, or Mach (
drag coefficient,Reynolds number). The first five also serve where a unit goes ((coefficient)). One of no kind says(no unit). - Or each value carries its unit right after its figure (
0.4 m,+1.2%); a bracket there,3.80 (+73.2%), is another quantity’s. - A count has whole numbers and a head that names what it counts, with a plural,
countornumber, in its label or where a unit goes (Flights,Files differing). A measured quantity’s plural (Masses,Burn times) is no count, nor is a label that ends in a measured quantity (Motors mass).
A head that ends in a figure (
| Mach 0.9 |) names no kind and no unit, so it fails unless each value carries its unit. It is a value, so the table is on its side: turn it. The unit words the check knows areUNITSandSPELLED_UNITSinxtask/src/site/numbers.rs, and the measured quantitiesQUANTITIES. It reads words, not meaning: a unit word it can’t tell from another, or a plural of a quantity it doesn’t list, can still pass, and reviews hold the rest. - The label is a word of two or more letters outside code and math that isn’t a unit, in the
head outside its brackets and before its first comma,
-
Short notes and cells (since M0.9f2).
cargo xtask sitefails a note (a whole quote block) or a table cell over 120 words, on the site and in both READMEs. Code, link text and HTML’s text count. A note keeps what the reader must know first: for a trust note, its kind of figure, what it was checked against with numbers, and what to rely on instead. The supporting detail goes in the page’s own text, below the note. A cell holds a value or a phrase, and its explanation goes under the table. A table or a quote block written in raw HTML fails too, as the checks read only Markdown’s. A footnote is neither, and isn’t read. -
Grouped figures and dates in words (since M0.9f3). If a figure of four or more digits is a quantity, give it its commas:
1,500 m, not1500 m. If it is a name or a number from a file, leave it as it is, or put it in code. Outside code and math, on the site and in both READMEs,cargo xtask sitefails a figure of four or more digits before its decimal point written without its commas. Digits after the point aren’t grouped. It passes these, which aren’t quantities:- A part number or another name made of letters and figures: a figure with a letter,
_or#against it, or with a/,\,@,+,&or=before it (131G84,L1150R,#1000). Also a figure after a hyphen that follows a letter (D-4014), or after a colon or a point that follows a letter or a)(arXiv:1109.4448,NGA.STND.0036). Also a figure after a hyphen or a)in a name that holds a letter (NASA/TM-2008-215633). Figures a hyphen joins otherwise (1000-2000 ft,3005-row) are read. - A figure right after a name that numbers documents or things. The names are
ISO,NFPA,RFC,NMEA,ESDU,datum,Code,code,NACA,TN,TR,TP,Report,NTRS,arXiv,Aluminum,Al,Hexcel,HexPly,station,thread,Threadandpp.(NFPA 1125,NACA TN 3527,station 72364), as written. The second figure of a range after one passes too (pp. 1509–1518). Give each figure its name:NFPA 1125 and NFPA 1127. For a name the list doesn’t hold, put the figure in code, or add the name toIDENTIFIERSin the same change. - A year: four digits from 1600 to 2100 with no unit or
%after them or after their decimals (in 1997,2025.0; but2000 mand1749.8 mfail). Also the year in a date written out (December 31, 9999).
A value read from a file, such as a fill value or a raw word, goes in code:
-32767. The check reads figures, not meaning. A count from 1600 to 2100 passes without its commas: write them anyway (1,712 files). Text in a block of raw HTML isn’t read.It also fails an ISO date,
2026-10-04, in the text outside tables: prose writesOctober 4, 2026. A table, a file’s name in code and a link’s address keep the ISO form. The lists areIDENTIFIERSandUNIT_WORDSinxtask/src/site/figures.rs. - A part number or another name made of letters and figures: a figure with a letter,
-
A trust note, in one fixed shape, goes on every result someone might fly on. It’s a quote block that opens with
**How far to trust it.**. Then it says what kind of figure it is (estimate, measurement, copied value) and what it was checked against, with numbers. Last, it says what to rely on instead when it matters. Never a go/no-go verdict.The label appears nowhere else: a heading says what its section covers (“Accuracy of the margin”), and a qualifier goes in the note’s first sentence. The site check fails any other use of the label, and a quote block that opens with a bold “not validated” sentence.
-
Signal words are those of ANSI Z535, the US safety-sign standard, and no others: DANGER, WARNING, CAUTION, NOTICE, NOTE. Each is a panel above the text with the hazard, the consequence and how to avoid it. NOTE carries a statement with no hazard.
On the site, write one as a GitHub alert: a quote block whose first line is
[!NOTE],[!CAUTION]or[!WARNING]. DANGER and NOTICE have none yet, and[!TIP]and[!IMPORTANT]fail the build.cargo xtask sitedraws every alert and trust note as the product system’s note, the signal word in a strip above the message. It fails any other>quote block: quote a source inside a sentence instead.mdbook serveshows plain quote blocks;cargo xtask sitebuilds the pages as published. -
Numbers and dates:
rule write a space before the unit, except degrees and percent 21.5 °C,45°,7.0%on the site, in the READMEs and in SVG figures, that space is non-breaking (U+00A0), so a line never ends between a number and its unit; in terminal, JSON and CSV output it is a plain space, which copying and grepneed (data.md)21.5 °Cin a page’s source, which the build joins;0.2 calibersin a README; in an SVG;21.5 °Cinhpr’s outputcommas in groups of three in prose; none in terminal output or anything copied 5,104 ft;1280 ftprecision that matches what is known 5,104 ftfrom a barometer, not5,103.87 ftheights, distances and speeds in SI, then the US units in brackets, converted from the SI as written: feet for heights, rails and distances, inches for a part’s size in millimeters or centimeters, miles for long distances across the ground; ft/s, or mph for the wind. A motor’s or a mount’s nominal size (the motor size a mount takes) stays in millimeters alone, as motors are named ( a 54 mm motor), but a measured bore gives inches (a 28.956 mm (1.140 in) bore). Exempt: worked arithmetic, e-notation, and SI written as the conversion of a US figure before it (1.52 in (38 mm)); the site check fails the rest, on every page (M0.9c16, US units on the model pages, ADR-219)1,400 m (4,593 ft),16.2 m/s (53 ft/s),5 m/s (11 mph),0.6 m (24 in)dates in prose; in tables and files October 4, 2026; 2026-10-04 How the no-break space gets there (
xtask/src/site/joins.rs):- On the site, the build adds it.
cargo xtask sitejoins each figure to the unit symbol after it in the pages it builds (not the API reference), so a page’s source keeps a plain space. The units are symbols: lengths, times, masses, forces, pressures,°C,calibersandpx, among others. A word that counts, like “flights”, isn’t one. It joins the groups of a figure written with spaces too (22 632 Pa,9.806 65), so a line doesn’t end inside the number. It reads digits, not meaning, so two counts side by side (12 100) are held together too, which does no harm. The build fails either kind of split it leaves. - After an equation, the unit goes inside it:
$x = 4593\,\mathrm{ft}$, not$x = 4593$ ft. A line can end between an equation and the space after it, even a no-break one, so the build fails a unit left after an equation that ends in a number. - An inch with a word after it is yours to join. The build can’t tell
2.6 in rocketfrom “0.5 in both”, so write2.6 in rocket. Nothing fails if you forget. - In a README, write
yourself between every figure and its unit symbol, and between the groups of a figure written with spaces (22 632 Pa), because GitHub, crates.io and PyPI show the file as written.cargo xtask sitefails a README figure split from its unit or inside its groups by a breaking space or a line break, and names the line.
- On the site, the build adds it.
-
FusionSpace is one word.
-
The product’s name (ADR-199, the public name §1): “FusionSpace HPR” is the suite. “FusionSpace HPR · Sim” or “HPR Sim” is the simulator at its first mention on a page, and “HPR Sim” or “the simulator” after it. Write “HPR Sim” wherever “the simulator” could mean OpenRocket, RocketPy or RASAero too: in comparisons, tables and column headers. “This project” or “FusionSpace HPR” is the project, its tests or its licenses.
hpr, in code formatting, is the command and the Rust library, never the product in prose. Call the design format “the HPR design format”. A heading someone links to says “the simulator”, since “HPR Sim” in a heading makes an anchor that spells the old name. -
The name is checked (since M0.9a1, the packages’ text).
cargo xtask names, whichcargo test -p xtaskruns, fails on the old name,hpr-sim, in any case and with a non-breaking hyphen too. It also fails on a lowercasehprstanding for the product in prose.It reads the text that ships in a package. That’s the README, and the crates’ descriptions, READMEs, rustdoc and messages. It’s also the Python package, the schemas and their bindings, the licenses, the notices and the CHANGELOG. Since M0.9a2, the site’s pages, it also reads every page of this site and its table of contents.
A word joined to the name (
hpr-core,.hpr,hpr.fusionspace.co) is another name, and in a messagehprfollowed by a subcommand is the command. Two names are never mentions. One is a decision record’s file name, which keeps the name it was written under. The other is the flight engine’s folder in a path,crates/hpr-sim/. Each problem prints as its file, line and rule, such asREADME.md:14: a bare `hpr` for the product: ….A mention that must stay (history, an old stamp files still carry, an anchor) goes on the allowlist,
ALLOWinxtask/src/names.rs. An entry gives the file and the exact text around the mention: one line, at most 120 bytes, at least 8 beyond the mention. It also gives how many mentions it covers, and why it stays. An entry that matches nothing, or a different number of mentions, fails.No page of this site may be allowed whole. Only a decision record or the roadmap’s archive may be. On the records page, a decision record’s row, which gives the record’s summary as it was written, inherits that record’s allowance. A record up to ADR-205, the decision that set the rule may be allowed whole, and its row with it. No other row or line there inherits anything.
Older pages move to these rules as they are edited. The product system milestone,
M0.6, added the check for the first two. Since
M0.9f4, units held to their figures, the site’s build joins each
figure to its unit symbol with the non-breaking space and fails a pair it leaves apart, and the
READMEs fail one written with a breaking space (xtask/src/site/joins.rs). hpr sim --plot’s
SVG figure, which the rule covers, joins each number to its unit with one, and a test holds it
(a_number_keeps_its_unit_on_its_line in crates/hpr-cli/src/plot/tests.rs).
Many of the product system’s rules are not met yet. The design audit checks each of its sections against the site, the command line, the exports and the plot. Of the 65 sections that apply to them today, 33 are met and 25 are not.
Each gap has an issue and the milestone that closes it. The command line, exports and plot came first, then the site’s look. Then came the spelling, minus signs, number columns and READMEs. The rest of the words (M0.9f) comes before release 0.2 (ADR-208, the design audit). None of these rules changes a number the simulator computes.
Four kinds of page
Pages follow Diátaxis, a common way to sort documentation by what the reader is doing. Each page is one kind. A page that mixes them is split when it’s next touched.
| kind | the reader wants to | example on this site |
|---|---|---|
| Tutorial | learn by doing, start to finish | Getting started |
| How-to guide | get one task done | Launch-day weather |
| Reference | look a fact up | The command line |
| Explanation | understand why | How a flight is simulated |
The guides’ format
Rocketry explained’s guides are explanation pages about the physics behind HPR Sim’s numbers, such as Trusting a simulation. Each follows one format (the guides’ decision record), and the build holds the parts marked as checked:
-
It opens with what it covers, who it is for and how far to trust it. That’s the one-sentence lead, a paragraph that names its reader, then the trust note.
-
Words come before equations, then a worked example. Its numbers are printed by a program run in CI: a block that
cargo xtask cliregenerates, or heights and misses quoted from a committed report. -
Every number in its text is read from a committed report, or sits in a regenerated block (checked). A quote in
xtask/src/guides.rsfills its numbers from a report.cargo xtask guidesfails a page that doesn’t hold the quote word for word. It also fails any number in the page’s text that no quote reads. Its tests move each value every quote reads and fail unless the page check then fails: a mutation probe for every number.Titles and image descriptions count as text, and a decision record’s label doesn’t count. Inline code may hold a number only where a regenerated block on the page shows the same text, such as a command’s flag. A code block that isn’t regenerated holds none. HTML other than a comment fails. Write small numbers in digits, so the check sees them.
-
Each figure shows one idea, in the system’s drawing language.
cargo xtask guidesdraws it from the reports (checked: a test fails a committed figure the reports no longer draw). -
Uncertainty is drawn as a band, and the flattering side is marked. The marked side is tied to the test that pins which way the quantity errs, and the guide names that test.
-
Nothing is clipped (checked, by the three checks in Nothing cut off).
-
No verdicts, and nothing copied. No guide says a rocket is safe or will pass: the safety code and the range safety officer decide. A charge size appears only as a range, after “ground test first”.
The NFPA’s codes, the certification exams’ question pools, the magazines and OpenRocket’s share-alike documentation are cited and linked, never copied. No exam question is answered. NASA’s public-domain figures may be reused with credit.
A new guide goes in SUMMARY.md under Rocketry explained, and in guides() in
xtask/src/guides.rs with its quotes and figures. One with a regenerated block also goes in the
list of guides in xtask/src/cli.rs.
The product guides, under Product guides, are a product’s landing page and its tour, such as
A tour of HPR Sim. They follow the same format and join the same lists:
SUMMARY.md under Product guides, guides(), and the list of guides in xtask/src/cli.rs.
Their pictures of the command line are terminal figures. cargo xtask cli draws each from the
run of an example on the same page, long lines wrapped and never cut. Lettered balloons mark the
lines the text explains. The same command fails a committed figure the run no longer draws.
Each is named, with its balloons, in SHOTS in xtask/src/cli.rs. The example’s text block
stays on the page beside it, for a reader to copy or search
(the simulator’s guide’s decision record).
Nothing cut off
Nothing on this site may be clipped by an edge or a corner. That means no text, number, mark or button, in a figure or on a page, at any window width. Three checks fail the build when something is (the decision record has the rules in full):
-
Figures stay in their frame.
cargo xtask figuresreads every SVG underdocs/, andcargo xtask cli --checkdraws eachhpr sim --plotfigure and checks it. Each line, shape, stroke, arrowhead and label must lie inside the figure’s frame and inside any clip it sits in. The frame is itsviewBox, the area the SVG file says it draws in.A label is measured as if drawn in the widest of the common system fonts, character by character. That’s because a figure shown as an image draws in whatever font the reader’s computer has.
-
No text over text. In a figure, two labels’ boxes may not overlap by more than rounding. On a page, two runs of text fail when they overlap by more than 2 px sideways and a quarter of the shorter one’s height. Two lines set tightly, or two runs that touch, pass.
-
No page wider than the window.
cargo xtask siteopens every page in headless Chrome at each width from 320 to 1,920 px, 40 px apart. A page fails if it scrolls sideways, or if text or a box passes the window’s left or right edge. It also fails if a box cuts its own text short. A code block wraps its long lines at any character, at every width, and the check fails one that scrolls sideways (the decision on the restyle’s acceptance pass). A wrapped line breaks where it reaches the box’s side, which spoils code laid out in columns, so keep lines short where you can. Atext,wrapfence wraps the same way;cargo xtask clifences a command’s exampletext,wrapwhen a line passes 80 characters. -
No table scrolling sideways (ADR-297). Under 720 px the theme gives a table’s cells 8 px a side and none at its edges. A table still too wide for its column stacks its rows (
theme/hpr.js): each cell is labeled by a copy of its column’s head, beside its value, or above it when the value holds a formula. The check fails a table that still scrolls, which only a cell wider than the page’s column can make: a formula, an image or a long run of code. The failure names the table’s box, not the cell, so look in that table for the widest one, and shorten it or move it into the text.
CI runs the figure check in the tests on every system, and cargo xtask site in its site job.
scripts/gate.sh test site runs both locally. The gate’s site step adds --cache. It keeps the
layout and vitals results of each passing run in target/site-check-cache and checks again only the
pages whose built HTML changed since its last passing run, a page’s date of issue left out. It checks every page if the checker,
Chrome, the part (--widths), the operating system or the processor changed, or any built file
other than the pages, the search index and api/. A run that reuses pages skips the canaries, and
its lines say how many pages it checked now and how many it reused. CI never uses the cache and
checks every page. To check every page locally, delete target/site-check-cache or run cargo xtask site without --cache. A
failure names the page or figure, the widths, and the label or element with how far it reaches.
cargo xtask site also loads pages built to fail, and fails if it stops finding them. The figure
check’s tests do the same with a committed figure’s label moved out or laid over another. Not
covered: the API reference under api/, and a reader whose system font is wider than every font
the figure check measures.
When a check fails, change the layout: wrap the line, shorten the label, give it a row of its
own, or make the figure taller. Never crop, hide or shrink the frame to pass. The page check
needs Chrome or Chromium. If it isn’t where the system usually keeps it, set HPR_CHROME to the
program’s path.
Figures in the system’s colors and fonts
The same figure check holds figures to the FusionSpace product system’s
foundations.
It reads every SVG under docs/ and theme/, and each figure hpr sim --plot draws (see
the command line).
Every color a figure paints is one of the system’s color tokens, the named colors it lists by
job (Semantic roles). They’re the light theme’s, such as ink (#0B0F1C) for text and
predicted (#A22488) for a simulated line. They’re also the state colors for chips and badges
(ok-fill, caution-fill, danger-fill, info-fill), with the text that goes on them.
A figure shown as an image can’t follow the page’s dark theme, so it is drawn on the light one, its own background included. Four things fail:
- a color that isn’t a token, written by name, as
currentColor, or in astyle; - an opacity below 1 or a gradient, which blend tokens into colors none of them is;
- a shape or a line of text with no
fillset on it or around it, which draws in black; - text whose
font-familydoesn’t start with Cascadia Mono (labels and numbers) or Archivo (prose).
An image can’t load the site’s fonts. A reader without Cascadia Mono installed sees the next family in the list, and the frame check measures every one of those. It can’t measure Archivo yet, so for now every figure sets its text in Cascadia Mono.
The check can’t tell whether a line type is the right one, so the author picks it from the system’s table (Lines and shape):
- dashed (
8 4), 2 px, for anything simulated; - a chain line, a long dash and a dot as on a drawing (
24 3 1 3), 1 px, for a reference such as the ground; - dotted (
1 3), 1 px, for an event.
The figure on How a flight is simulated draws the dashed and
chain lines, with a sample of each in its key. The plot from hpr sim --plot draws all three.
The pages in the system’s look
cargo xtask site’s page check, the one that opens every page at every width, also reads each
page’s computed style. That’s the colors, sizes and outlines the browser ends up drawing. So the
site keeps the product system’s look where mdBook, the program that builds the site, would draw
its own. It reads the light, navy and field themes (the switch’s Light, Dark and Field), and
the light one with scripts off.
Colors off the system’s palette, rounded corners, shadows, motion off its timings and type off its sizes all fail it. Body text is 16 px up to a 1,024 px window, grows with the window, and is 18 px from 1,600 px. The check reads each size against the one the window’s width gives. Prose takes its column’s whole width, and the column stops at 1,120 px, so a line is as long as its column allows.
It also fails prose held narrower than the box that holds it, by a max-width, a width or margins set to auto. It fails a column allowed wider or narrower than 1,120 px, or off center beside the sidebar. Gutters off 16 or 32 px fail it too (the decision on the column and the reading scale), and so do:
- text under the contrast that WCAG 2.2 AA asks for against the background it is drawn on. WCAG is the W3C’s Web Content Accessibility Guidelines, and AA its level. The contrast is 4.5 : 1, or 3 : 1 for text of 24 px and over (18.66 px in bold). It’s measured after any opacity between the text and that background fades the text;
- one control of each kind the keyboard reaches without the system’s focus ring. That’s the
outline drawn round a link or button when Tab reaches it. It’s 2 px wide in the action color
(
#3350D6on the light theme) and 2 px clear of its edge; - any control the keyboard reaches whose ring is cut by the window’s side, or by the side of a box around it that clips what passes it, where the control itself shows whole. A box that scrolls sideways cuts it too once it can scroll no further that way, as a ring adds nothing to what a box scrolls. While the page is at its top, a ring cut by the window’s top, or by the strip fixed along it, fails too, and so does a page whose scroll padding at the bottom is under a ring’s 4 px, as a control the keyboard scrolls in there would have its ring cut;
- what Windows’ high-contrast mode would erase. That mode, forced colors, repaints the page in a few colors of the reader’s own. It would erase a box set apart from what is behind it only by its fill, with no border there. It would also erase an icon not drawn in its text’s color. The check can’t switch the mode on; it applies the stylesheets’ rules for it and judges from the page’s own colors;
- a bar stuck to the top of the window reaching further down than the page’s
scroll-padding-top. That’s the room the browser leaves at the top when it scrolls to what a reader tabs to, so the bar never hides it; - something fixed to the window inside a box whose
transformorwill-changewould carry it with the page instead. The page’s own layer on a phone would too; - a
>quote block left on a page; - a note not drawn as the system’s. The system’s note has a head, then the message. The head says its kind’s name in Archivo 13 px on 16 px lines at weight 600, in sentence case, across the note’s top. A caution’s and a warning’s say their signal word in capitals instead, in Archivo’s wide cut at weight 640: CAUTION, WARNING. A rule or a fill sets it apart (a caution’s in the caution fill, a warning’s in the danger fill). The note sits inside a border on every side, 2 px on a warning;
- a font list without its metric-matched fallback second. That’s a stand-in, Arial or Menlo, scaled to the real font’s size, so text doesn’t jump when the real font arrives;
- a page whose Cascadia Mono fallback sets a line more than 0.1% longer or shorter than Cascadia
Mono does, regular or semibold. The fallback is the family
'Cascadia Mono Fallback', drawn until Cascadia Mono arrives. The site scales Menlo, DejaVu Sans Mono, Courier New, Liberation Mono, Cousine, Droid Sans Mono and Noto Sans Mono to it. It can, since all of a monospace font’s letters share one width (#468). The check measures the font that the browser running it picks, so a machine checks only its own fonts; CI’s Linux runners check theirs. A page that declares no Cascadia Mono face, as most of the check’s test pages, is skipped; - a smooth scroll a script asks for when the menu bar’s title is clicked;
- an icon that isn’t square at one of the system’s icon sizes, 16, 20 or 24 px. That covers the icons in the menu bar, the page arrows, the search field and a code block’s buttons. The site draws them at 16, 20 and 24 px. A note’s icon, 14 px as the system’s note draws it, isn’t read;
- selected text not drawn on the action color at 22 % opacity.
A file check fails a page whose head doesn’t declare light and dark color schemes. It fails one
that doesn’t set the browser bar to the system’s light canvas (#F3F4F7) on a light system. The
same goes for its dark canvas (#0B0F1C) on a dark system. It also fails a fonts.css that
isn’t the system’s.
mdBook draws its buttons with Font Awesome, the icon set it ships, and names the book in an h1
above each page’s own title. After mdBook builds the site, cargo xtask site draws each icon as
the system’s icon of the same meaning. It also turns the book’s name into a paragraph. A file
check then fails:
- a page with a Font Awesome icon, or an icon that isn’t the system’s;
- a page with a second
h1(the print page, which holds every chapter, keeps one per chapter); - a favicon that isn’t the system’s.
mdBook also names the book in text in its menu bar. It shows the table of contents beside the page only from 1,080 px, with a menu button below that. It ends a page with its arrows. The build redraws that frame:
- the menu bar becomes the system’s header. It holds the FusionSpace lockup, 24 px tall in the text’s color, then HPR, one link to the landing page. The lockup is the logo’s mark with the FusionSpace name beside it;
- the menu button stays at every width. From 720 px it puts the table of contents away and brings it back. Dragging the table’s edge to the window’s side puts it away too. The choice is kept from page to page, and a first visit shows the table from 720 px. With scripts off, the table stays open from 720 px and the button goes;
- the arrows under the page name the pages they lead to: “Previous” or “Next”, then the page’s title. They stand under the text, inside the column;
- every page but the print page ends with one line: the FusionSpace mark, 24 px tall, and “FusionSpace HPR”, the version, the date of issue, the site’s status chip and a link to Start here, the page about the project. A docs site is a tool, in the product system’s three levels, and a tool ends this way (M0.17a, the frame off). The line’s entries come from the site’s title block, the box of facts about a document an engineering drawing ends with (title block), written once at the end of Start here. That table stays on Start here as the site’s about box. The print page, the whole guide on paper, is a record: it ends with the whole title block instead, its own title added after the site’s.
A file check fails a page:
- without one
headerholding the lockup, or without the table of contents, its box or its menu button; - with mdBook’s script that opens the table of contents only from 1,080 px, or with one that forgets that the reader put it away;
- with an arrow under the page that doesn’t name the page it leads to;
- without one
footerafter the page’s text. On the print page that’s the title block, with its fields in order and the page’s own title. On every other page it’s the line: the mark and the name, thenVersionand the version,Issuedand a date, the site’s status chip, and the link to Start here, in that order; - other than Start here, with the title block in its text (the print page holds that chapter).
The page check fails, at every width:
- a lockup not 24 px tall, not in the text’s color, or cut by its box;
- a lockup closer to another icon or text in the header, or to the window’s side, than a quarter of its height. That’s the logo’s clear space, the brand’s rule;
- no menu button, with scripts on; with scripts off, a menu button at 720 px or wider, or none below 720 px;
- once a run, at the narrowest width, a menu button out of the tab order, or one that Enter or
Space doesn’t press. mdBook’s is a label that no key reaches;
theme/hpr.jsmakes it a button; - a header not stuck to the window’s top that takes the
topmdBook’s script gives it. Where the table of contents is shut (under 720 px, or put away at any width) the script lets the header scroll away and sticks it to the window when the reader scrolls up; turning down again, it left the header where the page was, over the text.theme/hpr.cssholds it at the page’s top, so it goes at once and comes back when the reader scrolls up; - a table of contents hidden at 720 px or wider on a first visit. That’s read with scripts on and off, and after a narrower window is widened past 720 px;
- a table of contents hidden but still reached by the keyboard or a screen reader, or one shown but not reached. Hidden, none of its links may be in the tab order, nor a box of it that scrolls: Chrome lets the keyboard focus a box that scrolls and holds nothing it can reach;
- once a run, a menu button that doesn’t put the table of contents away or bring it back;
- once a run, a drag of the table’s edge to the window’s side that doesn’t put it away;
- wherever the table of contents shows, the current page’s entry in it not wholly in view and
clear of the table’s faded edges as the page loads.
theme/hpr.jskeeps it so: while the page loads, it centers the entry in the table, again each time the page’s section links (which mdBook adds under the entry) or the theme switch change the table’s size. After a click on another page’s entry in the table, the entry stays put if it shows whole and clear of the fades. Once the page has loaded, or the reader first uses the table (a wheel, touch, press, key or focus), it stops, but for the rule that no entry is cut by the table’s top edge or left under its top fade; - a table of contents that scrolls without a fade at its edges; or, wherever it fades, less room after its last entry than its bottom fade, or less scroll padding than each fade. The site’s stylesheet fades the table over its first 10 px and its last 24, and pads its scrolling as deep as each fade so an entry the keyboard focuses scrolls clear of it. It leaves 32 px after the last entry: the 24 px the check asks for, so the list ends whole above the fade, and 8 px to spare. Under forced colors the fade is dropped (ADR-343, the restyle’s decisions, decision 14);
- arrows under the page outside the column or off its edges, under 44 px tall, or naming no page;
- a footer line without its 1 px rule on top, its mark other than 24 px tall, or its name not in the text’s color;
- a status chip not in Archivo 13 px on 16 px lines at weight 600 in sentence case, under 24 px tall, with its icon other than 14 px, or in other colors than its status’s. It’s In preparation, outlined in the link color with a square icon, or Released, filled in green with a circle;
- the print page’s title block without its 2 px border in the text’s color, or with entries not in Cascadia Mono;
- a footer or a title block off the column’s edges (it is centered as the column is), or with anything below it.
Inside that frame the build lays each page out as the product system lays out a tool. It keeps what a drawing means (rules, trust notes, signal colors and units) and leaves off the drawing’s frame: no tag over a title and no sheet numbers (M0.17a, the frame off). Headings, labels and the navigation are in Archivo, in sentence case; titles and section names in its wide cut. Code and numbers in code stay in Cascadia Mono.
- nothing stands over a page’s title;
- the paragraph right under the title is the page’s lead, set larger and in gray. It’s one
sentence, of at most 25 words, ending in a period, that says what the page covers and what a
reader gets from it. Write it as the first paragraph of every page, under the
#title and before anything else (on a model page, before In short). A sentence ends at a period, question mark or exclamation mark followed by a space. So a lead can’t name an abbreviation with a period in it: write “the 1976 US Standard Atmosphere”, not “the U.S. Standard Atmosphere”; - each
##section is a part. It has a 2 px rule in the text’s color across its top, then its name. Write each##heading in the page’s text, not inside another element, or the build fails; - the header holds a theme switch, four buttons: Auto (the theme your system asks for), Light, Dark and Field, the chosen one filled in. From 960 px it stands in the header. Narrower, the header has no room for it, and it stands at the top of the table of contents. The menu button opens that below 720 px. The switch needs scripts, so without them it isn’t drawn;
- mdBook’s own theme menu, with six themes for three looks, is gone. A reader who had saved Coal or Ayu is put back on Auto; mdBook’s Rust theme, which the site now draws as Field, is kept.
A file check fails a page:
- whose title doesn’t open its intro;
- without a lead of one sentence and at most 25 words under it;
- with a
##heading that doesn’t open a part; - with a designation tag or a sheet number in it, a record’s frame;
- without the switch in place of mdBook’s theme menu;
- with a heading that skips a level going down (a
####right after a##; headings go in order).
The page check fails, at every width:
- anything over a title;
- a lead not in Archivo 20 px on 28 px lines at weight 400, not in the muted ink, or not right under the title;
- a part without its 2 px rule in the text’s color, or its name not under it or not in Archivo;
- a
##heading that doesn’t open a part; - a designation tag or a sheet number drawn;
- a switch not in the header from 960 px, or not in the table of contents below it. Below 720 px, the check opens the table of contents to read it;
- a switch with buttons other than Auto, Light, Dark and Field, under 44 px tall or not in Archivo 15 px on 20 px lines;
- a switch with a button other than Auto chosen for a first-time reader, or the chosen one not filled in the text’s color;
- mdBook’s theme button drawn, the switch drawn with scripts off, or the page in one of mdBook’s themes the switch doesn’t offer.
Once a run, at the width it reads print at, the check presses Dark, Field and then Auto. It fails a page whose theme doesn’t follow. It also loads the page with mdBook’s Coal saved, and fails one that doesn’t forget it and press Auto; and with Field saved, and fails one that doesn’t keep it and press Field.
A page has two to six parts (its ## sections, above). The product system’s page anatomy asked
that of its sheets, and the site keeps it for its parts
(M0.17a, the frame off). cargo xtask site and a site test
fail a page outside that range, with no exceptions. A page with more to say groups its sections. A ## heading names the group, and the sections
under it move down one level. They keep their words, so every link to them still lands
(M0.9d13, the pages’ sheets and trust).
Every page opens with how far to trust it, as the product system asks of a docs site. That’s a
trust note in the shape above, between the title’s lead and the first part. A model page says
it in its first part, the In short box, whose How well it is validated item gives the
evidence. cargo xtask site and a site test fail a page that doesn’t. A page that states rules
or records rather than results, such as this one, says so in its note and names what checks it.
mdBook draws three icons as characters of text:
❱beside a heading that folds open in the table of contents;✓beside the chosen theme;»before a heading a link jumped to.
The build draws the fold toggle as the system’s chevron, and fills in the chosen theme on the theme switch. A heading jumped to takes no mark, since the page scrolls it to the top.
The page check fails a text made only of such marks outside a page’s main. It also fails one
drawn by a stylesheet before or after an element anywhere. Such marks are arrows, technical
symbols, shapes, dingbats, guillemets, emoji and the private characters icon fonts draw in. A
key’s name in the help popup (←) and a mark used as a word in prose (Mach → 0) pass.
The check also reads each page as it would print, once. It does so at the window width it tries nearest the printable width of a sheet of paper. That’s 720 px: an A4 or Letter sheet inside Chrome’s default margins. CI splits the widths over three machines, and each reads print at its own nearest. The stylesheets’ print rules are applied, and their screen-only rules set aside.
A headless browser can’t print from a page, so this reads the print rules, not a printed page. Where the browser would break the pages isn’t seen. In the light, navy and field themes, it fails:
- a color that isn’t the light theme’s, and on a page with all three themes, anything drawn in different colors from one theme to another;
- navigation or a control drawn: the table of contents, the menu bar, a button or a text field;
- a link to another page, in the text or the footer, without its address after it, in
parentheses. A page of this site shows its path from the page, such as
cli.html#units; - a table row, a note, the footer or the title block that can split across two sheets;
- a footer line or a title block not drawn, or drawn without its version and date of issue;
- anything fixed to the window, which a browser draws on every sheet over what stands there.
The print page, every chapter on one page, shows on screen only a cover. The cover says what it prints, holds a button that prints it, and says how to print from the browser. Its chapters wait in a template, which a browser reads but doesn’t draw. The site’s script places them in the page when the browser is about to print, and takes them away after.
Drawn on screen, all of them were too slow for a phone (below). The check places them as printing does before it reads the page on paper. It fails a page where they don’t all arrive, or don’t all leave again.
mdbook serve still shows mdBook’s icons, menu bar, theme menu and two h1, with no parts and
no footer line. Only cargo xtask site builds the pages as
published. Not read: text inside SVG images or over a picture, and hover
(#432).
How fast the pages load
This part of the check is a lab test of how fast each page loads and answers. It uses a simulated phone on a slow network, not measured visits by readers. So it says whether a page is likely to be quick, not how quick it is for you.
It loads every page of the guide, though not the API reference: rustdoc’s own pages under api/,
which the layout check leaves out too. It measures Google’s three
Core Web Vitals. Each is held to the bound the product system
sets, Google’s “good”:
- Largest Contentful Paint (LCP), when the largest text or picture on the first screen is drawn: at most 2.5 s;
- Cumulative Layout Shift (CLS), how far what is drawn moves afterwards, as a share of the screen: at most 0.1;
- Interaction to Next Paint (INP), how long the page takes to answer a key or a tap. The check presses Tab and taps the menu button twice; search, scrolling and the other buttons aren’t tried. The slowest of these must take at most 200 ms.
The phone and the network are the ones Google’s Lighthouse uses for a phone. That’s a screen 412 pixels wide, half a second’s wait on every request (562.5 ms) and 1.5 Mbit/s down. A fast computer is slowed to the phone’s speed.
The check first times two short loops as Lighthouse does. It slows the processor by the factor Lighthouse’s guide gives for that time. Then it times the loops again to make sure the slowdown took. On the Mac the check was built on, the factor is about 16. A slower machine gets a smaller one, and the guide puts a high-end desktop at about 4.
A machine that would need less than 2 is refused, since a slowdown that small can’t be told from none. Every page is loaded cold, nothing cached. A page over a bound is loaded three times and judged by the middle result.
The bounds are meant for real visits, and the site collects no numbers from them. Two things make the lab slower than a visit. First, its server speaks HTTP/1.1, where a browser opens at most six connections to one server. GitHub Pages, which serves the site, speaks HTTP/2 with no such limit. Second, each page is a first visit, though a reader’s second page finds the stylesheet, scripts and fonts already saved.
One could err either way: the slowdown for a fast machine carries Lighthouse’s guide past the machines it was fitted to. And a phone draws text in its own fonts until the site’s arrive. The fallback is matched to Arial and to the Linux and ChromeOS fonts made to Arial’s widths. So on a Mac or on CI’s Linux runners the largest CLS was 0.067. But an Android phone draws in Roboto, which isn’t matched and isn’t measured (#461).
In one run on October 11, 2026, the processor was slowed 16.4 times. The slowest LCP was 2.06 s and the slowest INP 96 ms, both on Aerodynamics. The largest CLS was 0.067 (How a flight is simulated). On CI’s Linux runners, slowed about 7 times, the worst INP was 136 ms, the worst LCP 2.19 s and the worst CLS 0.067. A runner slowed 12.1 times measured INP 200 ms on the aerodynamics page, at the bound (#462).
LCP moves by a tenth or more from one run to the next. The check loads one page at a time, as
Lighthouse asks, since pages loaded side by side slow each other down. Each run prints its own
figures in the line that starts page vitals:; with --cache, the line says how many pages it
measured now and the slowdown the reused ones were measured at, and marks a worst figure taken from
the cache. Three pages the check serves itself must each fail their own vital and pass the other
two, or the check fails. One page’s stylesheet arrives late, one moves its text after drawing it,
and one’s menu button keeps the page busy.
What it took to pass is recorded in ADR-232, the pages’ vitals measured:
- one stylesheet instead of ten, asked for first with mdBook’s sidebar script;
- five fonts asked for early so that text doesn’t move when they arrive. That’s three more than the product system allows: with its two, CLS reached 0.174 and 0.177 on two pages. The fifth is the wide cut that titles are drawn in (M0.17a, the frame off);
- the theme switch placed before the page is first drawn;
- the print page’s cover.
The search index
The search box reads one file, searchindex.js, which a page loads with a <script> tag when a
reader first opens the search. Since no fetch is involved, search also works in a copy of the site
opened from disk. Every page of the guide is in it, and a search lands on the page’s ## section.
A test fails if book.toml leaves a page out again.
mdBook 0.5.4 builds that file with elasticlunr-rs 3.0.2, its search library, and 3.0.2 files each
section’s heading words under its body too, and its heading and body words under its breadcrumbs
(the names of the page, its parent pages and the section). That made the file 56% larger before
compression, and nearly doubled its postings, a posting being one word filed under one section in
one field. Release 3.1.0 fixed it, but no mdBook release uses 3.1.0 yet. So cargo xtask site
builds the three fields again from the text mdBook stores, each with its own words. It fails if the
number of sections, or the words it counts in any field of any section, differs from mdBook’s; a
word only cut to a different root (its stem), with the same count, would pass. Once an mdBook
release ships elasticlunr-rs 3.1.0, the rebuild should change nothing, and
xtask/src/site/search.rs can go.
The build then holds the file to a limit, LIMIT_BYTES in xtask/src/site/search.rs:
- The limit is 10,000,000 bytes of the file as written, the size past which mdBook itself warns that an index is very large (the decision). mdBook counts a little less than the file holds, so this check trips first.
- Before November 17, 2026 the limit was what main’s file weighed at b7313b32, before the rebuild: 1,675,059 bytes compressed with gzip. That build left fifteen pages out to stay under mdBook’s warning. The file stores every section’s text, so that limit held the guide to the words it had, and a week of writing used its room up.
- What a reader downloads when they first open the search is the file compressed with gzip: about 1.68 MB when the limit changed, and about 2.08 MB if the file reaches the limit (the decision’s estimate). GitHub Pages compresses a little less well than the build’s own gzip.
- The line that starts
site search:prints the postings and bytes, mdBook’s and the rebuild’s, the limit and the rebuild’s compressed size, on every build that passes. - When a page’s words push the file past the limit, the build fails. Shorten the words the page added. Change the limit only with a decision record that measures the new one. #1522 decides how the index gets lighter before then.
Where this comes from
The rules follow the UK Government Digital Service’s style guide, and the sentence-length checks that Datadog and GitLab run with the Vale linter. The page kinds are Daniele Procida’s Diátaxis framework. The decision to adopt them is in the October 3, 2026 review’s decision record.
The voice rules come from a survey of plain technical writing. It drew on the style guides and studies that name stock phrases. It also drew on 28 pages, from nine sources of technical writing, that read as if one person wrote them.
How the pages read
How each page reads against the writing guide’s voice limits, written from the pages by the site’s build each time it runs.
cargo xtask voice prints the same report from a copy of the repository. The writing guide’s voice section says what the pattern columns count and why, and sets the limits.
Rates are per 100 words, rounded up to two decimals, so a page over a limit never shows a rate at or under it; a rate over its limit is in bold. Words a sentence and the share of sentences over 25 words are rounded up too, to 0.1 and to 1%, so neither shows a page inside a target it misses. A stock phrase fails the build, and so does a page marked held that’s over a limit or misses a sentence target. The 136 held pages are every page the site’s table of contents lists, with the README and the 404 page, less the records page (ADR-285), each snapshot of an hpr command’s --help, the census of what the commands say, a page for each crate’s src/ directory, the Python package’s README and its docstrings as help() shows them, and each crate’s front page, the //! docs of its src/lib.rs (ADR-292).
144 pages, 595084 words, 0 stock phrases. 140 pages are within every limit.
The limits
| Pattern | Limit per 100 words | Pages over it | Highest rate |
|---|---|---|---|
| Bold-label items | 0.50 | 4 | 1.76, docs/perf.md |
| Labels | 0.50 | 3 | 3.62, docs/VISION.md |
| Sentences over 25 words | 0.50 | 3 | 1.13, docs/perf.md |
| Hedges | 1.00 | 0 | 0.52, crates/hpr-sim/src/ |
| Stacked hedges | 0.10 | 0 | 0.03, crates/hpr-sim/src/ |
| Minimizers | 0.10 | 1 | 0.11, docs/ARCHITECTURE.md |
| Signposts | 0.10 | 0 | 0.01, docs/format/flight-logs.md |
| First person on a reference page | 0.00 | 0 | none |
The register has no limit of its own (first person on a reference page, above, is the one limit on it): “I”, “we”, “you” and contractions per 100 words, and the guide’s sentence targets (at most 20 words a sentence on average, fewer than 10% of sentences over 25 words). A reference page is marked ref.
Each page
| Page | Words | Words a sentence | Over 25 words | Bold-label items | Labels | Sentences over 25 words | Hedges | Stacked hedges | Minimizers | Signposts | First person on a reference page | I | We | You | Contractions |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
.github/ISSUE_TEMPLATE/an-idea.md | 28 | 0.0 | 0% | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | |
.github/ISSUE_TEMPLATE/something-wrong.md | 29 | 0.0 | 0% | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | |
.github/pull_request_template.md | 8 | 0.0 | 0% | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | |
CHANGELOG.md | 1810 | 20.9 | 31% | 0.94 | 0.00 | 0.89 | 0.06 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.06 | 0.23 | |
CONTRIBUTING.md | 715 | 14.1 | 5% | 0.00 | 0.00 | 0.28 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.98 | |
README.md (held) | 2637 | 14.3 | 5% | 0.16 | 0.12 | 0.23 | 0.04 | 0.00 | 0.00 | 0.00 | 0.16 | 0.00 | 0.76 | 0.65 | |
crates/hpr-cli/tests/help/hpr-analyze.help (ref, held) | 431 | 13.5 | 0% | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.47 | 0.00 |
crates/hpr-cli/tests/help/hpr-compare.help (ref, held) | 521 | 12.8 | 3% | 0.00 | 0.00 | 0.20 | 0.20 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.20 | 0.00 |
crates/hpr-cli/tests/help/hpr-completions.help (ref, held) | 78 | 7.8 | 0% | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 1.29 | 0.00 |
crates/hpr-cli/tests/help/hpr-convert.help (ref, held) | 174 | 13.4 | 0% | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.58 |
crates/hpr-cli/tests/help/hpr-diagnose.help (ref, held) | 53 | 7.6 | 0% | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 |
crates/hpr-cli/tests/help/hpr-mc.help (ref, held) | 613 | 13.1 | 0% | 0.00 | 0.00 | 0.00 | 0.17 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 |
crates/hpr-cli/tests/help/hpr-motors-fetch.help (ref, held) | 146 | 10.5 | 0% | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 |
crates/hpr-cli/tests/help/hpr-motors-list.help (ref, held) | 96 | 8.0 | 0% | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 |
crates/hpr-cli/tests/help/hpr-motors-search.help (ref, held) | 159 | 9.4 | 0% | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 |
crates/hpr-cli/tests/help/hpr-motors-show.help (ref, held) | 96 | 9.6 | 0% | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 |
crates/hpr-cli/tests/help/hpr-motors-update.help (ref, held) | 106 | 10.6 | 0% | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 |
crates/hpr-cli/tests/help/hpr-motors.help (ref, held) | 190 | 11.9 | 0% | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 |
crates/hpr-cli/tests/help/hpr-optimize.help (ref, held) | 50 | 7.2 | 0% | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 |
crates/hpr-cli/tests/help/hpr-sim.help (ref, held) | 441 | 12.6 | 0% | 0.00 | 0.00 | 0.00 | 0.23 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 |
crates/hpr-cli/tests/help/hpr-weather-era5.help (ref, held) | 132 | 8.8 | 0% | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 |
crates/hpr-cli/tests/help/hpr-weather-gfs.help (ref, held) | 158 | 9.9 | 0% | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 |
crates/hpr-cli/tests/help/hpr-weather-open-meteo.help (ref, held) | 189 | 10.0 | 0% | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 |
crates/hpr-cli/tests/help/hpr-weather-rap.help (ref, held) | 164 | 10.3 | 0% | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 |
crates/hpr-cli/tests/help/hpr-weather-wyoming.help (ref, held) | 182 | 10.8 | 0% | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 |
crates/hpr-cli/tests/help/hpr-weather.help (ref, held) | 199 | 11.8 | 0% | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 |
crates/hpr-cli/tests/help/hpr.help (ref, held) | 303 | 13.2 | 5% | 0.00 | 0.00 | 0.34 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 |
crates/hpr-py/README.md (held) | 346 | 12.2 | 0% | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.29 | 0.29 | |
crates/hpr-py/tests/docstrings.md (ref, held) | 4374 | 13.9 | 3% | 0.00 | 0.00 | 0.21 | 0.07 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.07 | 0.69 |
docs/404.md (held) | 51 | 12.0 | 0% | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 1.97 | 0.00 | |
docs/ARCHITECTURE.md | 1860 | 11.7 | 7% | 1.13 | 2.42 | 0.38 | 0.06 | 0.00 | 0.11 | 0.00 | 0.00 | 0.11 | 0.00 | 0.11 | |
docs/VALIDATION.md (held) | 14122 | 16.6 | 10% | 0.20 | 0.09 | 0.43 | 0.09 | 0.02 | 0.00 | 0.00 | 0.00 | 0.00 | 0.05 | 0.48 | |
docs/VISION.md | 3927 | 15.5 | 15% | 1.13 | 3.62 | 0.59 | 0.18 | 0.00 | 0.08 | 0.00 | 0.00 | 0.00 | 0.03 | 0.00 | |
docs/accuracy.md (held) | 25862 | 15.5 | 10% | 0.26 | 0.06 | 0.41 | 0.06 | 0.01 | 0.01 | 0.00 | 0.00 | 0.00 | 0.01 | 0.37 | |
docs/api.md (held) | 2515 | 13.2 | 0% | 0.16 | 0.00 | 0.00 | 0.20 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.40 | 0.36 | |
docs/checking-a-claim.md (held) | 1575 | 14.8 | 0% | 0.26 | 0.07 | 0.00 | 0.26 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.13 | 1.21 | |
docs/cli.md (ref, held) | 20370 | 14.4 | 4% | 0.20 | 0.02 | 0.24 | 0.09 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.21 | 0.61 |
docs/comparing-a-flight.md (held) | 1092 | 15.1 | 8% | 0.28 | 0.10 | 0.46 | 0.10 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.65 | 0.92 | |
docs/custom-models.md (held) | 1800 | 13.6 | 0% | 0.00 | 0.00 | 0.00 | 0.23 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.95 | 0.95 | |
docs/drag-through-mach-1.md (held) | 1957 | 15.0 | 3% | 0.36 | 0.00 | 0.16 | 0.11 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.06 | 0.82 | |
docs/elevation.md (held) | 4127 | 14.7 | 2% | 0.00 | 0.00 | 0.10 | 0.05 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.30 | 0.85 | |
docs/evidence.md (held) | 9115 | 12.5 | 4% | 0.00 | 0.00 | 0.18 | 0.03 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.02 | 0.26 | |
docs/exporting-a-flight.md (held) | 1931 | 14.6 | 0% | 0.00 | 0.00 | 0.00 | 0.06 | 0.00 | 0.00 | 0.00 | 0.06 | 0.00 | 0.21 | 0.94 | |
docs/fly-your-ork.md (held) | 2175 | 14.3 | 6% | 0.00 | 0.10 | 0.33 | 0.14 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.65 | 0.51 | |
docs/format/damaged-files.md (ref, held) | 844 | 15.6 | 6% | 0.00 | 0.00 | 0.36 | 0.12 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.36 | 1.31 |
docs/format/eng.md (ref, held) | 2468 | 13.9 | 3% | 0.37 | 0.21 | 0.17 | 0.13 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.05 | 0.21 |
docs/format/era5.md (ref, held) | 2681 | 13.6 | 2% | 0.38 | 0.15 | 0.08 | 0.04 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.49 | 0.27 |
docs/format/flight-logs.md (ref, held) | 44564 | 13.2 | 1% | 0.22 | 0.20 | 0.02 | 0.09 | 0.00 | 0.01 | 0.01 | 0.00 | 0.00 | 0.00 | 0.04 | 0.45 |
docs/format/ghost-files.md (ref, held) | 1974 | 15.1 | 8% | 0.00 | 0.00 | 0.46 | 0.06 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.16 | 0.61 |
docs/format/hpr.md (ref, held) | 5592 | 14.4 | 2% | 0.38 | 0.02 | 0.11 | 0.09 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.13 | 0.79 |
docs/format/orc.md (ref, held) | 2412 | 13.3 | 0% | 0.38 | 0.13 | 0.00 | 0.09 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.21 | 0.38 |
docs/format/ork.md (ref, held) | 41755 | 14.5 | 3% | 0.22 | 0.13 | 0.13 | 0.09 | 0.00 | 0.01 | 0.01 | 0.00 | 0.00 | 0.00 | 0.04 | 0.16 |
docs/format/pf2.md (ref, held) | 815 | 13.9 | 0% | 0.00 | 0.13 | 0.00 | 0.25 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 1.23 |
docs/format/rse.md (ref, held) | 2256 | 14.0 | 0% | 0.27 | 0.09 | 0.00 | 0.09 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.05 |
docs/getting-started.md (held) | 4160 | 13.7 | 2% | 0.27 | 0.00 | 0.10 | 0.10 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.87 | 0.73 | |
docs/glossary.md (ref, held) | 13677 | 13.4 | 1% | 0.00 | 0.09 | 0.06 | 0.06 | 0.00 | 0.02 | 0.00 | 0.00 | 0.00 | 0.00 | 0.06 | 0.13 |
docs/how-a-flight-is-simulated.md (held) | 2168 | 14.1 | 0% | 0.33 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.14 | 0.33 | |
docs/monte-carlo.md (held) | 3815 | 14.2 | 2% | 0.21 | 0.00 | 0.08 | 0.08 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.42 | 0.71 | |
docs/motor-stock.md (held) | 3606 | 14.2 | 3% | 0.00 | 0.00 | 0.17 | 0.12 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.37 | 1.06 | |
docs/nomads.md (held) | 4483 | 13.6 | 1% | 0.00 | 0.00 | 0.05 | 0.03 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.23 | 0.79 | |
docs/online-data.md (held) | 2165 | 14.6 | 0% | 0.10 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.14 | 1.02 | |
docs/optimization.md (held) | 7680 | 14.2 | 0% | 0.23 | 0.00 | 0.00 | 0.11 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.28 | 0.59 | |
docs/perf.md | 6493 | 17.1 | 23% | 1.76 | 0.65 | 1.13 | 0.04 | 0.00 | 0.02 | 0.00 | 0.00 | 0.00 | 0.00 | 0.16 | |
docs/physics/aero.md (ref, held) | 65496 | 14.9 | 3% | 0.35 | 0.32 | 0.17 | 0.07 | 0.01 | 0.01 | 0.01 | 0.00 | 0.00 | 0.00 | 0.02 | 0.12 |
docs/physics/atmosphere.md (ref, held) | 2349 | 12.5 | 1% | 0.13 | 0.30 | 0.05 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.18 |
docs/physics/design.md (ref, held) | 12294 | 15.2 | 6% | 0.12 | 0.18 | 0.32 | 0.08 | 0.01 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.01 | 0.48 |
docs/physics/flight-fit.md (ref, held) | 7709 | 16.1 | 9% | 0.16 | 0.25 | 0.50 | 0.15 | 0.03 | 0.02 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.81 |
docs/physics/flight.md (ref, held) | 12187 | 15.4 | 8% | 0.46 | 0.18 | 0.48 | 0.02 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.02 | 0.11 |
docs/physics/flutter.md (ref, held) | 3439 | 15.9 | 7% | 0.30 | 0.06 | 0.35 | 0.12 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.12 | 0.15 |
docs/physics/frames.md (ref, held) | 1634 | 13.7 | 6% | 0.00 | 0.00 | 0.37 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 |
docs/physics/geodesy.md (ref, held) | 1734 | 12.2 | 1% | 0.24 | 0.00 | 0.06 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.12 | 0.06 |
docs/physics/gravity.md (ref, held) | 1345 | 13.0 | 5% | 0.00 | 0.00 | 0.30 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 |
docs/physics/integration.md (ref, held) | 2271 | 13.1 | 4% | 0.18 | 0.23 | 0.27 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.23 |
docs/physics/interpolation.md (ref, held) | 547 | 11.3 | 0% | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 |
docs/physics/log-readings.md (ref, held) | 23988 | 16.6 | 10% | 0.25 | 0.12 | 0.49 | 0.17 | 0.00 | 0.01 | 0.01 | 0.00 | 0.00 | 0.00 | 0.02 | 0.33 |
docs/physics/magnetic.md (ref, held) | 2231 | 13.9 | 1% | 0.14 | 0.00 | 0.05 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.14 | 0.00 |
docs/physics/mass.md (ref, held) | 10022 | 13.1 | 2% | 0.20 | 0.03 | 0.08 | 0.06 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.09 | 0.36 |
docs/physics/metrics.md (ref, held) | 6560 | 14.8 | 3% | 0.04 | 0.19 | 0.14 | 0.04 | 0.00 | 0.02 | 0.00 | 0.00 | 0.00 | 0.00 | 0.02 | 0.13 |
docs/physics/motor.md (ref, held) | 7264 | 15.0 | 7% | 0.28 | 0.18 | 0.42 | 0.06 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.05 | 0.27 |
docs/physics/moving-mass.md (ref, held) | 2488 | 13.4 | 0% | 0.09 | 0.05 | 0.00 | 0.09 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.09 | 0.65 |
docs/physics/quadrature.md (ref, held) | 494 | 11.3 | 0% | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 |
docs/physics/recovery.md (ref, held) | 13724 | 14.5 | 2% | 0.22 | 0.21 | 0.09 | 0.10 | 0.00 | 0.01 | 0.01 | 0.00 | 0.00 | 0.00 | 0.06 | 0.15 |
docs/physics/released-mass.md (ref, held) | 2798 | 13.8 | 0% | 0.04 | 0.04 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.15 | 0.43 |
docs/physics/shapes.md (ref, held) | 2014 | 13.0 | 0% | 0.20 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.20 |
docs/physics/smoother.md (ref, held) | 2462 | 15.7 | 6% | 0.17 | 0.13 | 0.37 | 0.05 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.09 | 0.74 |
docs/physics/staging.md (ref, held) | 7201 | 14.3 | 0% | 0.46 | 0.24 | 0.00 | 0.20 | 0.00 | 0.02 | 0.00 | 0.00 | 0.00 | 0.00 | 0.06 | 0.10 |
docs/physics/synthetic-flights.md (ref, held) | 4589 | 15.2 | 2% | 0.40 | 0.09 | 0.11 | 0.05 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.24 |
docs/physics/turbulence.md (ref, held) | 1292 | 11.3 | 0% | 0.31 | 0.00 | 0.00 | 0.08 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.24 |
docs/physics/wind.md (ref, held) | 2992 | 14.7 | 0% | 0.37 | 0.07 | 0.00 | 0.04 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.31 | 0.27 |
docs/pick-a-motor.md (held) | 1671 | 14.1 | 3% | 0.00 | 0.00 | 0.18 | 0.12 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 1.14 | 0.48 | |
docs/plan.md (held) | 1076 | 10.4 | 0% | 0.00 | 0.28 | 0.00 | 0.10 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.56 | |
docs/python.md (held) | 5035 | 14.5 | 3% | 0.06 | 0.00 | 0.16 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.42 | 0.70 | |
docs/reading-a-flight-log.md (held) | 3989 | 15.2 | 8% | 0.36 | 0.00 | 0.48 | 0.26 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.33 | 0.66 | |
docs/recording-a-trajectory.md (held) | 821 | 14.0 | 0% | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.74 | |
docs/releasing.md (held) | 2595 | 14.2 | 0% | 0.27 | 0.00 | 0.00 | 0.08 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.35 | 0.74 | |
docs/sensitivity.md (held) | 2268 | 14.8 | 1% | 0.27 | 0.00 | 0.05 | 0.14 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.58 | 0.67 | |
docs/simulator-compared.md (held) | 2628 | 13.1 | 6% | 0.00 | 0.00 | 0.35 | 0.08 | 0.00 | 0.00 | 0.00 | 0.04 | 0.00 | 0.16 | 0.69 | |
docs/simulator-tour.md (held) | 1601 | 14.1 | 3% | 0.44 | 0.00 | 0.19 | 0.07 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.32 | 0.50 | |
docs/soundings.md (held) | 5069 | 14.3 | 1% | 0.18 | 0.00 | 0.04 | 0.08 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.02 | 0.87 | |
docs/stability-for-certification.md (held) | 2075 | 14.6 | 2% | 0.00 | 0.00 | 0.10 | 0.25 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.63 | 0.39 | |
docs/stability-in-flight.md (held) | 1838 | 15.3 | 3% | 0.22 | 0.00 | 0.17 | 0.11 | 0.00 | 0.00 | 0.00 | 0.06 | 0.00 | 0.00 | 0.98 | |
docs/start-here.md (held) | 9094 | 16.8 | 9% | 0.19 | 0.04 | 0.50 | 0.08 | 0.00 | 0.02 | 0.00 | 0.06 | 0.00 | 0.35 | 0.61 | |
docs/the-builder.md (held) | 4196 | 12.9 | 1% | 0.20 | 0.00 | 0.03 | 0.00 | 0.00 | 0.00 | 0.00 | 0.05 | 0.00 | 0.46 | 0.58 | |
docs/the-simulator.md (held) | 831 | 15.5 | 6% | 0.00 | 0.00 | 0.37 | 0.00 | 0.00 | 0.00 | 0.00 | 0.13 | 0.00 | 0.85 | 1.09 | |
docs/trusting-a-simulation.md (held) | 1701 | 15.4 | 5% | 0.00 | 0.00 | 0.30 | 0.18 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.06 | 0.95 | |
docs/voice-report.md (held) | 153 | 14.1 | 0% | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | |
docs/weather.md (held) | 2016 | 13.1 | 1% | 0.00 | 0.00 | 0.05 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.30 | 0.85 | |
docs/when-fins-flutter.md (held) | 1763 | 14.8 | 1% | 0.23 | 0.00 | 0.06 | 0.12 | 0.00 | 0.00 | 0.00 | 0.06 | 0.00 | 0.18 | 0.63 | |
docs/writing.md (held) | 12873 | 15.6 | 7% | 0.46 | 0.21 | 0.43 | 0.14 | 0.00 | 0.02 | 0.00 | 0.02 | 0.01 | 0.09 | 0.89 | |
docs/your-own-logger.md (held) | 2410 | 14.6 | 1% | 0.00 | 0.00 | 0.05 | 0.09 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.42 | 0.67 | |
docs/your-own-rocket.md (held) | 4518 | 14.7 | 1% | 0.36 | 0.00 | 0.05 | 0.09 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.38 | 0.69 | |
crates/hpr-cli/src/ (ref, held) | 9862 | 9.9 | 1% | 0.00 | 0.00 | 0.09 | 0.21 | 0.02 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.20 | 0.51 |
crates/hpr/src/ (ref, held) | 615 | 7.1 | 0% | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.98 |
crates/hpr-sim/src/ (ref, held) | 3919 | 13.0 | 3% | 0.00 | 0.00 | 0.21 | 0.52 | 0.03 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.80 |
crates/hpr-io/src/ (ref, held) | 6016 | 9.6 | 1% | 0.00 | 0.00 | 0.04 | 0.17 | 0.02 | 0.00 | 0.00 | 0.00 | 0.00 | 0.04 | 0.00 | 0.24 |
crates/hpr-motor/src/ (ref, held) | 1396 | 8.8 | 2% | 0.00 | 0.00 | 0.15 | 0.08 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.08 | 0.58 |
crates/hpr-design/src/ (ref, held) | 2683 | 10.1 | 1% | 0.00 | 0.00 | 0.08 | 0.04 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.45 |
crates/hpr-aero/src/ (ref, held) | 1615 | 7.7 | 0% | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.07 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.44 |
crates/hpr-core/src/ (ref, held) | 241 | 6.1 | 0% | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 |
crates/hpr-format/src/ (ref, held) | 538 | 9.8 | 0% | 0.00 | 0.00 | 0.00 | 0.19 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 2.42 |
crates/hpr-atmos/src/ (ref, held) | 244 | 4.3 | 0% | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 |
crates/hpr-net/src/ (ref, held) | 967 | 7.5 | 0% | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.32 |
crates/hpr-flightdata/src/ (ref, held) | 29144 | 11.7 | 1% | 0.00 | 0.00 | 0.04 | 0.14 | 0.02 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 1.44 |
crates/hpr-analysis/src/ (ref, held) | 449 | 5.2 | 0% | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 |
crates/hpr-forensics/src/ (ref, held) | 383 | 5.7 | 0% | 0.00 | 0.27 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 2.88 |
crates/hpr-py/src/ (ref, held) | 698 | 10.3 | 2% | 0.00 | 0.00 | 0.15 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 1.44 |
crates/hpr-aero/src/lib.rs (ref, held) | 494 | 16.0 | 0% | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.41 | 0.21 |
crates/hpr-analysis/src/lib.rs (ref, held) | 194 | 13.0 | 0% | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.52 |
crates/hpr-atmos/src/lib.rs (ref, held) | 119 | 11.9 | 0% | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 |
crates/hpr-cli/src/lib.rs (ref, held) | 204 | 18.6 | 0% | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.99 |
crates/hpr-core/src/lib.rs (ref, held) | 82 | 16.4 | 0% | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 |
crates/hpr-design/src/lib.rs (ref, held) | 147 | 11.4 | 0% | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 |
crates/hpr-ffi/src/lib.rs (ref, held) | 26 | 6.5 | 0% | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 |
crates/hpr-flightdata/src/lib.rs (ref, held) | 853 | 12.6 | 2% | 0.00 | 0.00 | 0.12 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.71 |
crates/hpr-forensics/src/lib.rs (ref, held) | 117 | 13.0 | 0% | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.86 |
crates/hpr-format/src/lib.rs (ref, held) | 328 | 15.7 | 0% | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.92 |
crates/hpr-io/src/lib.rs (ref, held) | 137 | 10.6 | 0% | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.73 |
crates/hpr-motor/src/lib.rs (ref, held) | 110 | 13.8 | 0% | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 |
crates/hpr-net/src/lib.rs (ref, held) | 212 | 12.5 | 0% | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.95 |
crates/hpr-py/src/lib.rs (ref, held) | 367 | 16.7 | 0% | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.28 |
crates/hpr-sim/src/lib.rs (ref, held) | 372 | 16.2 | 5% | 0.00 | 0.00 | 0.27 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 |
crates/hpr-validate/src/lib.rs (ref, held) | 220 | 13.8 | 0% | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 |
crates/hpr-wasm/src/lib.rs (ref, held) | 23 | 5.8 | 0% | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 |
crates/hpr/src/lib.rs (ref, held) | 449 | 10.7 | 0% | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.00 | 0.23 |
What the commands say
Each src/ page above is a crate’s message census (ADR-292, the plan for the program’s words): its #[error] texts and the other string literals in its code that read as prose, less its tests and its markup. A forwarded error passes on another’s text. A literal with a placeholder is read in pieces, and the census doesn’t see what fills it. cargo xtask voice --messages prints every line it read.
| Crate | Files | Literals read | #[error] texts | Forwarded | With a placeholder |
|---|---|---|---|---|---|
crates/hpr-cli/src/ | 28 | 899 | 0 | 0 | 465 |
crates/hpr/src/ | 9 | 84 | 30 | 8 | 19 |
crates/hpr-sim/src/ | 23 | 260 | 17 | 9 | 53 |
crates/hpr-io/src/ | 31 | 582 | 45 | 2 | 333 |
crates/hpr-motor/src/ | 15 | 147 | 7 | 0 | 81 |
crates/hpr-design/src/ | 13 | 249 | 6 | 3 | 64 |
crates/hpr-aero/src/ | 15 | 189 | 6 | 3 | 48 |
crates/hpr-core/src/ | 14 | 40 | 12 | 0 | 11 |
crates/hpr-format/src/ | 3 | 53 | 7 | 0 | 41 |
crates/hpr-atmos/src/ | 9 | 57 | 7 | 0 | 4 |
crates/hpr-net/src/ | 14 | 120 | 52 | 10 | 95 |
crates/hpr-flightdata/src/ | 56 | 2033 | 15 | 2 | 1331 |
crates/hpr-analysis/src/ | 17 | 87 | 10 | 3 | 17 |
crates/hpr-forensics/src/ | 16 | 68 | 11 | 3 | 17 |
crates/hpr-py/src/ | 6 | 64 | 0 | 0 | 44 |
Decisions and the roadmap
See why the simulator works as it does and what comes next, through the project’s decision log, roadmap and lessons from earlier work.
This page is the way into the project’s three records: the decision log, the roadmap and the
lessons from Loft. They are files in the repository, not pages of this site, because they are
written as the work happens. Every label you meet on the other pages, such as a decision record
(ADR- and a number), a milestone (M and a number) or a Loft lesson, links into one of them.
Decision records
A decision record, or ADR (architecture decision record), explains one significant choice: the
problem, the options that were considered, what was chosen and why, and what it costs. Records
are numbered in order and never renumbered. A record is not rewritten when a choice changes; a
new record replaces it and points back. Each record is a file of its own; the decision log
is their index, one row per record with its summary and status. The table below gives each one in
a line and is kept by a command (cargo xtask records), so a new record appears here as soon as
it is written. From the 126th record on, a row shows the record’s own summary, which is more technical,
until someone rewrites it in plainer words.
| record | what it decides | where it shows |
|---|---|---|
| ADR-000: Kickoff decisions | A Rust library first; physics and validation before interfaces; the license; a clean room (no GPL source is read); commercial solid motors only | Start here |
| ADR-001: License and workspace layout | MIT OR Apache-2.0, and how the code is split into crates | Start here |
| ADR-002: The reference library | How published sources and reference programs are pinned by hash, fetched and checked | Checking a claim |
| ADR-003: Frames, attitude, geodesy and gravity | The axes and sign conventions, WGS 84 gravity, and the Earth’s rotation | Frames, Gravity |
| ADR-004: Atmosphere, wind and turbulence | The standard atmosphere, wind by height above sea level, and seeded turbulence | Atmosphere, Wind, Turbulence |
| ADR-005: Solid motors | How a thrust curve becomes impulse, mass and inertia over the burn, and which curves are bundled | Solid motors |
| ADR-006: Component geometry and mass properties | How each part’s shape, walls, fins and material give its mass, center of gravity and inertia | Mass properties, Shapes |
| ADR-007: The design tree | Where parts sit, automatic sizes, overrides, motor mounts and design checks | Design tree |
| ADR-008: Subsonic normal force and centre of pressure | The body and fin lift models behind the center of pressure | Aerodynamics |
| ADR-009: Subsonic drag | The drag buildup, surface finishes and drag tables that override it | Aerodynamics |
| ADR-010: Time integration | The adaptive integrator, and how events such as burnout and apogee are found | Time integration |
| ADR-011: Rigid-body flight | The equations of motion, the launch rail, the phases of a flight and when it stops | Rigid-body flight |
| ADR-012: Recovery | Parachute drag areas, when devices open, how they fill, and the descent | Recovery |
| ADR-013: Streamer and tumble drag | Which published data sets give a streamer’s and a tumbling body’s drag | Recovery |
| ADR-014: Separation | How a rocket splits into bodies that each descend on their own | Recovery |
| ADR-015: The validation harness | How comparisons with other programs are run, gated and reported | Accuracy, Checking a claim |
| ADR-016: The documentation site | This site: how it is built, and the checks every page passes | Start here |
| ADR-017: In short, traced numbers and this page | How every model page opens, how Accuracy’s numbers are checked against their sources, and why these records are files rather than pages | Accuracy |
| ADR-018: Examples and quotes | Every example program runs in CI and must print its committed output, and a page’s quote of a file must match it line for line | Getting started |
| ADR-019: Publishing the site | How this site and the API reference are built together, link each other, and are published from main | The API reference |
| ADR-020: The reader test | How the site was tested on a new reader, and why every milestone and lesson label links a row of plain words on this page | Decisions and the roadmap |
| ADR-021: Whole flights against RocketPy | What a whole-flight comparison measures and how, why a sixth rocket was added, and how a case declares a limit of hpr’s as a known gap | Accuracy |
| ADR-022: Validation in CI, and regenerating references only by hand | How every pull request reruns the validation cases on three operating systems, and why the references change only when a person regenerates them and reviews the diff | Checking a claim |
| ADR-023: Predicted mode | How hpr’s own aerodynamics are compared with RocketPy flying each example’s own drag, and why those results are reported against a target rather than gated | Accuracy |
| ADR-024: The time-series RMS | How each whole flight’s height and speed over time are compared with RocketPy’s, on what clock, and why each is held to 3% of its apogee or max speed | Accuracy |
| ADR-025: The calm-air cases | Juno III, Calisto and Bella Lui flown with no wind, and why Juno III’s drifts were at first reported but not scored: the two codes free the rocket from the rail at different points | Accuracy |
| ADR-026: The path in wind | Why HPR Sim turned into the wind less than RocketPy: RocketPy’s equations took the turning moments about the wrong point during the burn (corrected upstream, and in the comparison), and hpr’s body lift, which RocketPy leaves out, pushes a slow rocket downwind | Accuracy |
| ADR-027: The normal force through Mach 1 | How the fins’ normal force and center of pressure carry through Mach 1: Barrowman’s subsonic method to Mach 0.8, supersonic linear theory once it holds, a straight-line join between, and how they compare with a wind tunnel and with RASAero II | Aerodynamics |
| ADR-028: Drag through Mach 1 | How noses, shoulders and steps drag through Mach 1: Niskanen’s method with Stoney’s measured nose curves, and how the drag compares with NASA’s wind tunnel | Aerodynamics |
| ADR-029: Drag against RASAero II through Mach 2 | How hpr’s drag compares with RASAero II’s curves by speed band, why it misses faster than sound, and a second reference with every input known: MIL-HDBK-762’s worked example | Aerodynamics |
| ADR-030: The afterbody faster than sound | A boattail’s supersonic wave drag from MIL-HDBK-762’s chart held to the Prandtl-Meyer limit, separation on steep boattails, the base pressure behind them, and a lip in a boattail’s wake; checked against measured boattails, and why its targets aren’t met | Aerodynamics |
| ADR-031: Roll from canted fins | Roll forcing from canted fins and roll damping by Barrowman’s strip theory with his body factors, the fin’s own slope in the damping, and the comparison with NASA’s measured roll effectiveness and the Basic Finner’s roll damping | Aerodynamics |
| ADR-032: Normal-force overrides | Flying RASAero II’s normal force and center of pressure: how its export is read, the slope at 0°, the angles past its last, and why the damping stays hpr’s | Aerodynamics |
| ADR-033: The body faster than sound | The lift a body’s cylinder carries behind its nose faster than sound, by the second-order shock-expansion method: the report’s tangent body, its limit, and the cone slopes read by hand | Aerodynamics |
| ADR-034: The body’s supersonic normal force in flight | How a flight uses that method: a table of each part’s share every 0.05 in Mach, joined in a straight line from slender-body theory over Mach 1.2 to 1.5 | Aerodynamics |
| ADR-035: Drop the orhelper dependency | The GPL-2.0 wrapper for the OpenRocket jar is removed from the oracle environment, unused; how the OpenRocket oracle milestone drives the jar is decided when it starts | How correctness is proven |
| ADR-036: The Arcas Robin’s supersonic body gap | How hpr’s body faster than sound is compared with NASA’s wind tunnel from now on (as the tunnel measures, at its angles), and why M1.8e6 takes the size of crossflow lift and the boattail’s share together | Aerodynamics |
| ADR-037: Body lift by Jorgensen’s crossflow | Body lift’s size at every speed from Jorgensen’s crossflow drag, how his two η figures are combined, a boattail’s share faster than sound from Washington and Pettis’s measurements, and why blunt tips moved to M1.8e7 | Aerodynamics |
| ADR-038: Blunt tips by a Newtonian cap | How a nose with a blunt or vertical tip (power-series, Haack, elliptical) flies the shock-expansion method faster than sound: NASA TN D-4865’s Newtonian cap and handover, the method started behind it from the tangent cone rather than the report’s own start, and how both were checked | Aerodynamics |
| ADR-039: A lip in a boattail’s wake carries nothing | Why a short flare at the very base, behind a boattail, gets no normal force faster than sound, what the tunnel’s pitching moment says about that, and how far the shelter reaches | Aerodynamics |
| ADR-040: A steep boattail’s correlation, and the 15% target judged | How steep a boattail hpr still reads its measured share for, how footnote 8 and the tube behind it were integrated by hand, and where the Arcas Robin’s body alone still misses its 15% target | Aerodynamics |
| ADR-041: A lip’s shelter weighed, not switched | Why a lip rising out of its boattail’s wake now moves a rocket between the two supersonic body models smoothly, and how big the switches that remain are | Aerodynamics |
| ADR-042: Cone slopes past Fig. 2’s edge, from Sims | Where the slopes for tangent cones of 24° to 30° come from, how they were checked against the chart they extend, and what a cone steeper than 30° still costs | Aerodynamics |
| ADR-043: The blunt tip’s handover cap | What moving a blunt tip’s handover from 24° to the cone tables’ 30° would be worth on the report’s own sphere-cone, what it does to the march on a nose that flattens fast, and why the cap stays where it is | Aerodynamics |
| ADR-044: What the answer follows when it follows the mesh | That it is the surface pressure crossing its tangent cone’s, not the method being reduced, that marks a reading whose answer moves with the element count: how far that goes, and what it re-aims issue #108 at | Aerodynamics |
| ADR-045: Where a flare’s march stops | That what stops the march is the corner’s isentropic turn, not the flare’s shock detaching; that the two limits cross near Mach 1.55, so neither bounds the other; and that above Mach 2.13 neither binds: the cone tables’ 30° does | Aerodynamics |
| ADR-046: Debrief folded in, and analysis that stands on its own | That a universal flight log analyzer becomes part of this project, and that reading a log never needs the simulator: hpr-flightdata may not depend on hpr-sim, a check enforces it, and comparing a flight with a simulation lives in hpr-forensics | Start here What the analyzer is being built from is written up in the log formats, the readings and what may be ported. |
| ADR-047: A flare flies the method where its corner’s shock is attached | That a flared body now flies the shock-expansion method; that the test for the corner’s shock is NACA 1135’s wedge limit read at the flow reaching it, the same one a blunt tip’s cap already uses; that a steeper flare is read as one of the same radii drawn out to that limit, so nothing jumps across the boundary; and what still switches: a band of flares a third of a millimeter tall the march refuses (read through since ADR-050) | Aerodynamics |
| ADR-048: What a marched flare is worth | That TN D-4865 model 2’s readings are committed and compared: an 18.5° flare read −1.9% and +7.0% against the wind tunnel at Mach 1.9 and 2.3, +13.4% at 2.96 and about +51% at 3.95 and 4.63, whose flare the report’s shadowgraphs show separated; with no reading at all below Mach 1.5289, where drawing the flare out to its shock’s limit lands past the march’s own | Aerodynamics |
| ADR-049: What a step in radius costs | That a step’s cost is measured and published rather than modeled: it takes the whole body off the shock-expansion method, worth −8.65% and 1.03 calibers at its threshold and −12.55% and 1.36 calibers at a 2 mm (0.079 in) step down, and −11.34% and 1.10 calibers on a boattailed body, whose threshold is 1.3e−13 m rather than 2.7e−11 m; and that stopping the march at the step instead was built, measured and rejected, because the mixed reading lands outside both pure models and misses the boattail’s band | Aerodynamics |
| ADR-050: A reduced element read by the generalized method | That where the second-order method’s exponential form cannot hold (the pressure behind a corner on the far side of its tangent cone’s from where its own gradient points), the element is read by the generalized method wherever it has a tangent cone of its own, so a near-flat flare no longer takes the whole body off the method; that the region’s two edges are solved from the corner’s own state, not bisected, reproducing all three published angles; and that what is left is the loading’s step at the crossing, +0.129% and 0.0051 calibers on the tests’ rocket but not bounded by it: +4.3% and 0.19 calibers on a body with a short shoulder, and −2.8% between two adjacent Mach rows | Aerodynamics |
ADR-051: M3.1 split, and a .ork document kept whole | That reading an OpenRocket file is split into four increments, the container and the document first; that the document is read into a tree and interpreted by nobody, because with no schema for .ork keeping the whole file is the only way to be sure nothing was dropped; that reading it, writing it and reading it again gives the same document, checked over generated trees and over all 76 corpus files that open; that nesting is counted before the text is parsed, since the XML parser underneath overflows the stack past 120 levels; and that the corpus survey names the two files that are not XML rather than skipping them quietly | OpenRocket .ork design files |
ADR-052: What a .ork value means | That an automatic dimension keeps both its flag and the number OpenRocket last worked out, rather than becoming a hand-typed one; that either name of the two pure renames may be read, because where OpenRocket writes both it agrees with itself on the number and the frame every time (642 and 109 elements), while two more pairs that look the same stay unread, their newer name carrying a frame the older never does; that a stated zero is a value, which an override to no drag at all needs; and that the single flag the three subcomponent-override flags replaced is read as setting all three, out loud (the warning since dropped by ADR-095, which measured OpenRocket’s reading) | .ork design files |
ADR-053: The parts on and inside a .ork body | That .ork angles are degrees, though nothing in the file says so: 178 of its 188 non-zero ones exceed a whole turn; that radialposition and radiusoffset are each read on the parts that carry them, so ADR-052’s open question need not be answered; that a part this reader cannot shape honestly is left out (5 in the corpus); that an inner tube’s automatic outer radius is its parent’s bore, resolved before any ring’s, so sibling order cannot matter; that the five surface-finish words take the roughness heights OpenRocket’s author published, polished possibly moved in a newer OpenRocket; and that a tube of no wall carries no mass (replaced by ADR-061: every part of no wall weighs nothing) | .ork design files |
| ADR-054: An automatic radius with nothing to take | That an automatic body radius with no fixed radius anywhere along its chain takes OpenRocket’s default radius, 25 mm (0.98 in), which OpenRocket’s maintainers call “the default radius” and OpenRocket 24.12 settles on in a committed oracle run, never the number cached after auto, which OpenRocket itself ignores; that hpr departs from OpenRocket only where OpenRocket answers −1 m (−3.3 ft), a radius no shape can have; that hpr is held to OpenRocket’s settled answer rather than its first reading, which settles the Dual parachute example’s odd cache in hpr’s favor (67 of 67 body radii agree over 18 designs); and that a <rocket> holding nothing is a document with no design rather than a design that fails | .ork design files |
ADR-055: M3.1c split, and the motors a .ork flies | That reading a .ork file’s motors, recovery, stored results and pods is split into four increments. That a motor’s thrust curve comes from the file first and hpr’s bundled catalog second, matched on manufacturer and designation both. That none is a plugged motor and 0 a charge at burnout. And that the rocket flies a configuration only when every motor in it has a curve and lights at launch, on a one-stage rocket read without a warning, because hpr lights every motor at launch and flies one body until staging arrives: 2 of the library’s 170 configurations do | .ork design files |
ADR-056: A .ork design’s recovery and separation | That when each parachute and streamer opens, and when each stage separates, is read as the file wrote it and not yet flown. That the words are OpenRocket’s own, measured by a committed probe. That a deploy height is above the ground. And that two choices are left open, in plain view, for the step that flies a .ork: a deploy height the rocket never reaches, which OpenRocket never opens, and an automatic drag coefficient | .ork design files |
ADR-057: A .ork design’s stored simulations | That the simulations OpenRocket last ran on a design are read back as it wrote them: the launch conditions, the summary, and each stage’s time series and events. That their units are measured by a committed probe: the rod’s angle and direction in degrees, a compass bearing; the wind’s direction in radians, where it blows from. And that they are OpenRocket’s answers to compare against, not flights hpr makes | .ork design files |
ADR-058: What a .ork holds that hpr does not model | That the parts and sections of a .ork hpr does not read (pods, parallel stages, OpenRocket’s 3D-view settings, a simulation’s plug-ins) are kept whole beside the design, in an extension called x-openrocket, at a path that leads back to where each was, so that writing the file back can put them back; that a design missing parts this way says it is reduced; and that the same goes for every tag and attribute no reader asks for, recorded as hpr reads | .ork design files |
| ADR-059: The RocketSerializer cross-check | That hpr’s reading of a design’s key geometry (the nose cone, transitions, fin sets, where each sits, and the body radius) is held to RocketSerializer’s, a second program that reads .ork files, with OpenRocket itself run on the same file to settle any difference; that “agrees” means no number of hpr’s is apart from both; that a cause is named only where the record proves it; and that an import error is a file that does not read or a design that does not lay out | .ork design files |
| ADR-060: M2.2 split, and the structure’s mass held to OpenRocket’s | The OpenRocket comparison goes mass first, then OpenRocket’s mass conventions, the motors OpenRocket flies, flights on public designs, and the corpus. Each design’s structure is held to OpenRocket’s within 1% in mass and 1% of length in center of mass, thresholds set before measuring, and every design outside is given its cause. Which of OpenRocket’s inertias is roll is measured on a tube worked out by hand | Mass properties |
ADR-061: What a .ork leaves unsaid, read as OpenRocket reads it | Probe designs measure what OpenRocket makes of a wall or shoulder of no thickness (nothing), a part with no thickness written (a 2 mm (0.079 in) wall) or no material (its default by kind), and which override wins. hpr reads each the same way. Two override rules stay hpr’s own, each pinned by a test: the center under a mass override that covers the parts inside, and inertia under an override | Mass properties |
| ADR-062: Fins and rail buttons against OpenRocket; roll inertia explained | Probes of one tube and one part find the fins behind the roll inertia’s gap: OpenRocket’s shortcut for a fin set, inferred from its output, accounts for the corpus’s 2.1%, and hpr keeps its exact integral. hpr keeps its rounded and airfoil sections and its exact ellipse, each pinned against OpenRocket’s; a .ork rail button now sits where OpenRocket puts it (issue #151). M2.2b2, the fins and rail buttons, split their remaining clusters, fillets and unread parts into M2.2b4 | Mass properties |
| ADR-063: Packed parts read and weighed as OpenRocket packs them | A parachute, streamer, shock cord or mass component whose file writes no packed size is 25 mm (0.98 in) long and 12.5 mm (0.49 in) in radius, as OpenRocket packs it, and a mass override on one that weighs nothing is spread over its packing, not put at a point; both measured on probe designs | Mass properties |
| ADR-064: Clusters, fillets and unread parts remain visible departures | A 3-ring cluster is read as one tube and pinned as a measured departure (superseded for clusters by ADR-075); 5 mm (0.20 in) and 10 mm (0.39 in) fin fillets are omitted and pinned (superseded for fillets by ADR-096); unread parts remain in x-openrocket and mark the design reduced. The 2026-09-23 scratch-excluding corpus rerun gives 58 of 71 within 1% in mass, 59 in center, 50 in pitch inertia and 56 in roll with OpenRocket’s fin rule | Mass properties |
| ADR-065: Stored results are references only when current and structurally plausible | Stored results remain readable, but only current runs with RK4Simulator and BarrowmanCalculator provenance markers and complete finite, internally consistent ascent summaries pass the stored-reference screen; the 2026-09-25 survey found 91 of 174 eligible and 83 excluded (47 inconsistent, 17 external, 11 outdated, 7 not-simulated and 1 missing simulator). Hpr reproduction is separate: 1 of those 91 is reproducible and 90 are not (40 reproducible once ADR-067 supplies OpenRocket’s motor database). | .ork stored simulations |
| ADR-066: Every curve hpr flies is integrated as OpenRocket integrates it | The oracle hands OpenRocket the same bytes hpr reads, so the comparison is of two integrations of one file: hpr’s total impulse, peak thrust, 5% burn-time window and curve duration are all bit for bit OpenRocket 24.12’s on all 32 bundled curves. The one real difference is the average thrust, hpr’s being +0.0107% to +0.3147% higher because its numerator is the whole curve’s impulse where OpenRocket’s is the window’s: a written departure, not held. The reference library’s own curves stay private, counted in M2.2c2. | Solid motors: validation |
| ADR-067: Curves come from OpenRocket’s own database by digest, each held to its impulse | Most designs name a motor’s curve by its digest and do not carry it. An oracle records the motor database OpenRocket 24.12 ships, and cargo xtask ork supplies each solid curve for its digest, never by name. Every curve’s total impulse is within 0.1% of OpenRocket’s, and bit for bit: the 3 the library embeds are two independent readings, and the 1,288 database curves check the hand-off. In all 67 configurations hpr flies with a supplied curve, OpenRocket places each one too. Of the 162 configurations the bundled catalog left without a curve, 66 now fly, 72 are held back for another named reason and 24 still have none. Where each motor’s weight sits still differs from OpenRocket’s. | The .ork format: motors |
| ADR-068: OpenRocket’s flights of the public designs, and what its metric words mean | M2.2d, flights against OpenRocket, splits in two. OpenRocket 24.12 flies the public designs in calm air: 56 complete flights and one aborted run, which is no reference. A record keeps each summary word beside the quantities of its own time series: nine of ten words are defined, among them the deployment speed as the last deployment’s; the optimum delay is not measured and is withheld, as are other versions’ words (L80). A metric whose event is missing is never scored: withheld when neither flight had the event, failed when only one did (L81). | .ork: what the summary words mean |
| ADR-069: hpr’s flights of the public designs against OpenRocket’s | M2.2d2: cargo xtask ork-flights flies the 21 configurations of OpenRocket’s examples that hpr can fly, in OpenRocket’s recorded conditions, and a committed report sets each against OpenRocket’s apogee, largest speed and margin at rod clearance, by ADR-068’s definitions. The margins are within 0.016 calibers. With no named cause, hpr’s apogees are 0.06% to 4.34% low. Each apogee more than 5% off has a named cause: a parachute OpenRocket opened before apogee (hpr flies none from a .ork yet), or a part set to no drag, which hpr ignores (#165). | .ork: hpr’s flights against OpenRocket’s |
| ADR-070: M2.2e split: mass and centre of mass first, then the corpus | M2.2e is cut into four: M2.2e1 adds the spread of hpr’s mass and center of mass against OpenRocket’s to the flight report; then OpenRocket flies the private designs (the corpus), hpr flies them, and each apogee more than 5% off gets a written cause. On the 21 public flights the launch mass is within 0.21% and the center of mass within 0.016 calibers. | .ork: hpr’s flights against OpenRocket’s |
ADR-071: The corpus OpenRocket flies is its .ork files | M2.2e2 flies the private library’s 27 .ork files: 88 of 89 configurations to the end. Its 4 RASAero and 4 RockSim files wait until hpr reads those formats. | .ork: OpenRocket’s flights of the private designs |
| ADR-072: hpr’s flights of the private library, under anonymised ids | M2.2e3 tries the 12 private designs that are not copies of public ones and publishes only differences, under ids like C09/2. hpr flies 17 configurations of 4 of them, so the two reports hold 9 designs, not the 20 that M2.2 (the OpenRocket comparison) asks for. That bar is now M2.2e9 (ADR-094 split the tilted rod off as M2.2e5, which added one design, and ADR-095 the old override flag as M2.2e6, another). The rest can come from the staging and cluster designs (M1.9), the airframe readings (#174, two designs left), or the four public designs held by pods and parallel stages (OpenRocket’s pod examples, unflown for reasons outside the pods though M1.13 is done) or tube fins (#133). | .ork: hpr’s flights of the private designs |
| ADR-073: Each named cause sized by OpenRocket’s own flight without it | M2.2e4 sizes the two causes named for the five apogees more than 5% from OpenRocket’s: OpenRocket flies each flight again with nothing deployed and, where a part is told it has no drag, with that setting cleared (matching what hpr flies, since hpr reads the setting but can’t apply it yet) or the part removed. Four of the five come within 5% of every such flight. The fifth stays 7.80% high like for like (the no-drag part removed from both programs), and what is left on its design has a lead, not an explanation (#177, a very blunt nose’s drag). | .ork: the two named causes, and their size |
| ADR-074: Ignition times and powered staging: the sustainer flies on as a rigid body | M1.9a lets each motor light at its own time (at launch, at a time, after another motor’s burnout, or after its stage’s separation). A separation with the forward part still to burn is powered: that part, the sustainer, flies on with its own shape and mass while the booster falls to its own landing. The sustainer keeps the nose, so its aerodynamics are an ordinary rocket’s; nothing needs a model of a rocket without a nose. Checked by tests, not yet against another simulator. | Staging |
| ADR-075: A cluster is one tube repeated, and a motor in it one motor per tube | M1.9b makes a cluster a list of tube places on one inner tube: the tube and what it holds are repeated in each, and its motor is one motor per tube, so thrust, mass and moments add up as for any motors. A tube can be marked as a motor out. A .ork file’s pattern is read as OpenRocket places it, measured on 25 probes; OpenRocket weighs the tubes stacked on the cluster’s axis, which hpr does not copy. | Clusters |
ADR-076: A .ork file’s ignitions and one powered separation flown against OpenRocket | M1.9c reads each motor’s ignition in a .ork file into hpr’s (at launch, at a time, or after the stage below burns out or fires its charge) and flies one powered separation, a cluster with a motor in every tube, and an air start. The tolerance, set before measuring: every flight of a design within 5% of OpenRocket’s apogee and largest speed. OpenRocket’s two-stage, cluster and air-start examples all are (three cluster apogees against OpenRocket’s flight with no parachute, because its parachute opened before apogee) | Staging |
| ADR-077: Flight metrics: peaks on the dense output, margins only where they mean something | M1.10a finds each peak (speed, Mach number, dynamic pressure, the boost’s acceleration and, apart, the opening shock) between the integrator’s steps rather than in a recorded table. It keeps the static margin and the margin at the flight’s Mach number from the rail exit to apogee, and gives none where the parts’ normal-force slopes nearly cancel, since the margin is then noise. The optimum delay comes from a flight with the charges held, so it doesn’t depend on the delay flown. Anything that didn’t happen is None. Tests pin each against a hand calculation; nothing is checked against a real flight. | Flight metrics |
| ADR-078: Fin flutter by NACA TN 4197, the lower reading wherever the source leaves room | M1.10b gives a fin’s flutter speed and margin by Martin’s 1958 criterion, reproducing both his worked examples at their printed precision. It fixes a flutter dynamic pressure, so the least margin is at max q. Martin’s own line between safe and failed wings, a band measured off his figure 3, puts the flutter speed at 1.8 to 2 times the speed of sound, so a flutter speed just above the flight’s speed is not shown to be safe. Where the source allows two readings (the thickness ratio, a flat fin’s stiffness), hpr takes the lower flutter speed. 14 built-in materials carry a cited shear modulus; G10/FR-4 has none. Nothing is checked against a hobby rocket’s flight. | Fin flutter |
| ADR-079: Exports as text built in the core, heights on each format’s own datum | M1.10c1 writes a recording as CSV or JSON, and the flight path and landings as GeoJSON or KML. Each function returns text and writes no file. Numbers are written so they read back exactly; a value that isn’t finite is refused. GeoJSON heights are above the WGS 84 ellipsoid and KML heights above sea level, as their standards say. GeoJSON is checked against the published schema and KML by parsing. Parquet is split off to M1.10c2. | Exporting a flight |
| ADR-080: Parquet written in-house, read back by Apache’s library | M1.10c2 writes a recording as an Apache Parquet file, behind the parquet cargo feature. hpr-sim writes it from the format’s specification, with no added library, and the tests read it back with Apache’s own Parquet library, every number bit for bit. The file is uncompressed and has no per-page statistics; pyarrow and DuckDB read it once, by hand, not in CI. | Exporting a flight |
ADR-081: ERA5 weather read from netCDF classic in hpr-io; M2.3 split a to c | M2.3a reads the weather over a launch site from an ERA5 file. hpr reads netCDF classic files itself, from Unidata’s specification; the newer netCDF-4 files are converted first with three lines of Python. Values are interpolated between the four grid points around the site as RocketPy does, and between the two hours around the launch, where RocketPy takes the nearer hour. Heights use the World Meteorological Organization’s formula at the site’s latitude, where RocketPy uses ECMWF’s; both are approximations, and the page compares them. Real flights in that weather are M2.3b, and the private designs with flight logs M2.3c. | ERA5 weather files |
| ADR-082: Real flights read from refs, compared over the ascent, with checked explanations | M2.3b flies seven of RocketPy’s documented rockets in the weather of their day, with hpr’s own aerodynamics and each example’s own motor file, and compares each with its team’s altitude log: the apogee, and the climb to it. hpr’s height is read the way the log’s barometric altimeter reads the air, which on a hot day is several per cent below the height climbed. The mean absolute apogee error is reported against a 5% target; each flight outside it carries an explanation that the report checks against its own numbers: a second flight on the team’s own drag, or on the thrust file as recorded. | Accuracy: real flights |
| ADR-083: M2.3c blocked: no private design is the rocket of a logged flight | M2.3c was to fly the private designs that have a flight log. None does: the private logs match no design in the private library, and the only designs there with a logged rocket are copies of RocketPy’s public examples, whose logs are RocketPy’s and were already flown in M2.3b. One design shares a source with some logs, but nothing ties it to any of those flights, and a comparison against a guessed pair would measure nothing. So it waits for a design and its flight’s log to be added to the private data, and work moves on to M2.4. | Accuracy: real flights |
| ADR-084: The accuracy census: the reports’ numbers held to the ones accepted | M2.4 counts the numbers the validation reports hold hpr to, once each, naming for each group what it was compared with, the kind of comparison, how many flights and how fast they flew. The census accepted last is committed, and CI holds each of those numbers to it: one that moves by more than 0.1% of its bar, better or worse, fails until the change is accepted with a written reason. That catches what a regenerated report could otherwise carry in, such as hpr’s own drag getting worse inside a target. | Accuracy: the census |
| ADR-085: Ejected pieces: an airframe that parts at any joint | M1.11a lets the airframe part anywhere: at the joint aft of any body component, as a nose cone pushed off does, or around a payload carried inside. Each piece flies on to its own landing under its own parachute. The pieces are fixed before the flight, so a body’s number never depends on which trigger fires first, and the nose’s body is always body 0. Each parting adds no impulse, so masses and momenta add up. An override that doesn’t say how its mass divides between pieces is refused rather than guessed. The push of an ejection charge, and a tumbling piece, are M1.11b (ADR-086). | Recovery: ejected pieces |
| ADR-086: Ejection impulse and tumbling pieces | M1.11b lets an ejection push its two sides apart with an impulse, equal and opposite, so each changes velocity by the impulse over its own mass and the momentum is unchanged. While the airframe flies whole with nothing open the push is along its axis. A body with no attitude to go by is assumed to point against its velocity through the air when it hangs from an open parachute, and along it when nothing is open. A piece can tumble by the tumble model over its own parts, and that model now integrates a curved nose’s side area rather than taking its end diameters. | Recovery: ejected pieces |
| ADR-087: Mass that moves along the airframe | M1.12a lets ballast or a payload slide along the airframe during the flight, on the triggers a parachute has, along a smooth curve that starts and ends at rest. The rocket’s center of mass and inertia follow it exactly. The equations of motion gain one term, the moving part’s angular momentum relative to the airframe, which is zero for a part on the axis; its rates are exact rather than differenced. A mass released in flight is M1.12b. | Moving mass |
| ADR-088: Mass released in flight | M1.12b lets ballast or a payload go during the flight, on the triggers a parachute has. The rest of the rocket flies on in six degrees of freedom from the same state with its mass, center of mass and inertia stepped to the rest’s; the part leaves with the velocity it had in the airframe, so mass and momentum are kept, and falls to the ground as a point mass under a drag area the user gives. | Released mass |
| ADR-089: A pod is a stack of body components repeated around the axis (superseded for aerodynamics and tumbling by ADR-092) | M1.13a adds pods: a pod set on a body tube holds the pod’s own body components, which stack along the pod, and hpr repeats that one pod, with everything in it, evenly around the axis, each copy turned with its pod as a fin set’s fins are. Each copy is weighed where it sits, with its parallel-axis term, and a motor in a pod is one motor per pod. The aerodynamics and the tumble model refuse pods until a cited method for their normal force and drag is in (M1.13c). | Pods |
ADR-090: .ork pods placed as OpenRocket places them; pods of no length left out | M1.13b1 reads a pod set’s pods and puts them where OpenRocket 24.12 does, measured on probes: a relative offset is from the tube’s surface to the pod’s widest part. A flipped nose cone is read as the tail cone it is. Pods of no length, drawn to hang fins off the axis, were left out with a warning until M1.13b2 read them (ADR-091). | .ork: Pods |
| ADR-091: A pod of no length weighs nothing and holds its parts on its axis | M1.13b2 reads the pods OpenRocket draws to hang winglets or a lug off the axis: a pod whose only part is a tube of no length, no wall and usually no radius. That tube weighs nothing, and fins or a lug on it sit on the pod’s own axis, as OpenRocket 24.12 places them on probes. A pod set that holds nothing is read, and weighs nothing. | .ork: Pods, Pods |
| ADR-092: A pod’s parts are Barrowman’s, once per pod, on the axis | M1.13c1 flies pods: each pod’s nose cones, transitions and tubes get the normal force and drag they would have on the airframe, at the pod’s own fineness, and each pod’s fins are its own, turned with it; every pod adds its share. The forces act on the rocket’s axis, exact for two pods or more to first order, and the roll damping the pods’ offsets give is added. How the pods and the body disturb each other’s flow is left out, with its size stated, and a single pod’s off-axis moments are left to issue #213. | Pods |
| ADR-093: Pod probes flown as the public designs are, and listed apart | M1.13c2 checks pods against OpenRocket on six probe designs, one airframe carrying pods of bodies, fins, tail cones, winglets or motors, or none, flown as the public designs are and listed apart from them. Each is within 5% of OpenRocket’s apogee and largest speed, and what the pods change is held too, since a straight-up flight tests drag more than normal force. The close agreement shows the two codes apply the same rules; it cannot size the interference both leave out. | Pods |
| ADR-094: A tilted launch rod flown as OpenRocket records it | M2.2e5 flies a tilted rod as OpenRocket records it: hpr’s rail takes the same compass bearing and an elevation of 90 degrees minus the tilt. Four public probes check it: the bearing at apogee agrees within 0.03 degrees and the apogee the tilt takes off within 0.27 percentage points. OpenRocket’s rocket clears a tilted rod at a small angle of attack, which on the probes and on the one private design explains most of a margin gap that grows with the tilt. | The .ork format: a tilted launch rod |
| ADR-095: The single pre-1.9 override flag read as OpenRocket reads it | Older .ork files use one flag to say a part’s overrides cover the parts inside it. M2.2e6 reads it as OpenRocket 24.12 does: as all three per-quantity flags, the later tag winning where a file writes both. Eleven probe designs measured it, and a test holds hpr to them. One private design now flies, within 0.26% of OpenRocket’s apogee. The other the flag was blamed for does not: it also has a stage separation HPR Sim can’t fly yet (#184), so that part of the bar is recorded as not met. | The .ork format: the values inside the tags |
| ADR-096: Fin fillets and an automatic radius inside a nose cone read as OpenRocket reads them | M2.2e7 weighs a fin fillet as a prism of its section along the root chord, one each side of every fin. An automatic outer radius inside a hollow nose cone or transition is the bore at the part’s narrower end; an innertube written auto keeps OpenRocket’s 9.5 mm (0.37 in). 21 new probes measure it. On 9 fillet probes, the fillets’ mass and center of mass are OpenRocket’s to 1e-15, the whole probe’s pitch inertia up to 0.64% apart. On 14 bore probes, 13 of which hpr flies, every part inside but one packed mass component (#186) is at OpenRocket’s mass to 1e-14 and station to 1e-15; a coupler at a nose’s tip is refused. | Mass properties: fin fillets, the .ork format: inside a nose cone |
| ADR-097: A cause in the drag sized by hpr flying OpenRocket’s drag | The first supersonic flight in the OpenRocket reports climbs 13.60% higher in hpr. An oracle records OpenRocket’s drag coefficient along its flight, and hpr flies it: +1.11%, so the cause is the drag. OpenRocket keeps the whole base’s drag under power, measured on its own examples, which hpr can now fly for comparisons; hpr’s supersonic pressure drag is about twice OpenRocket’s. Which of each is right is open (#222: supersonic pressure drag and base drag under power) | The .ork format: a supersonic flight, Aerodynamics: drag |
| ADR-098: A tube fin set’s automatic radius read as OpenRocket reads it | M2.2e8 reads the automatic radius of a .ork tube fin set. For three tubes or more, the radius is the one at which each tube touches the body and its neighbors; for one or two, it is the body’s radius. OpenRocket 24.12 gives the same radius, within 1e-15, on 19 probe designs. More than 8 tubes are read as 8, as in OpenRocket. Both inertias are departures, kept on purpose: OpenRocket’s roll inertia exceeds what any mass in the ring could give, and its pitch inertia leaves out the tubes’ distance from the axis; hpr keeps its own. Tube fins are weighed but not yet flown: M2.2e9 adds their aerodynamics. | |
| ADR-099: Tube fins flown as ring wings | M2.2e9 flies each tube of a tube fin as a ring wing: Weissinger’s slope (within 3% of NACA’s five rings), Fletcher’s measured aerodynamic center joined to the leading edge by hpr’s slender-body derivation (his longest ring, A = 1/3, left out by judgment), and friction inside and out with a square edge’s drag on the wall, below Mach 0.8 and for three tubes or more. The tube fin example’s apogee is 6.95% above OpenRocket’s, within 0.03% on OpenRocket’s own drag, so the gap is hpr’s drag, probably low because OpenRocket’s was refined on measured flights (#228). Its margin is 1.08 calibers below OpenRocket’s; ADR-102 keeps a first look: OpenRocket’s slope at 1.62 times the long-ring limit (1.65 times hpr’s) | |
| ADR-100: A motor whose ignition never comes flown unlit | M2.2e10 flies a .ork motor set never, or lit at an event that never comes (burnout or ejectioncharge in the bottom stage, or a plugged motor’s charge), unlit and loaded, as OpenRocket does on five probes of its two-stage example; a separation at such a motor’s burnout or charge never comes. One more private design flies, 0.88% above OpenRocket in apogee, which makes the 20 designs M2.2 asks for. It corrects ADR-076’s reading of one private record | |
| ADR-101: OpenRocket’s mass conventions rolled up | M2.2b closes: each mass convention OpenRocket was found to follow is hpr’s rule or a departure pinned by a test. The corpus survey, run again on 71 files (51 distinct by content), has mass and center of mass within 1% on 68, pitch inertia on 56 and roll inertia on 57 with OpenRocket’s fin shortcut; each file outside in mass, center or roll has a named cause (mass page). The comparison as a whole stays open for two Loft lessons, L19 and L82, moved to M2.2f | |
| ADR-102: Tube fins’ centre of pressure measured against OpenRocket | M2.2f records OpenRocket 24.12’s answers for tube fins: 14 probe designs and its Tube fin rocket, at five Mach numbers. Its tubes lift 1.26 to 1.86 times what hpr’s ring wings do, the same per tube at any count, and act a quarter of their length aft of the leading edge up to Mach 0.5. No measurement supports either, so hpr keeps its model; slender-body theory adds a body interference that hpr leaves out and OpenRocket does not vary with the count (#234). L19’s quarter-caliber bar is not met: up to Mach 0.5 hpr’s center of pressure is 0.42 to 3.0 calibers forward of OpenRocket’s, 1.07 on the Tube fin rocket, with each gap pinned by a test (tube fins) | |
| ADR-103: The builder API wraps the crates’ own types, with no default materials | M4.1 is split: the builder first (M4.1a), then models of your own and a guide in the API reference (M4.1b). The builder’s Environment, Motor, Rocket and Flight make the crates’ own design tree and simulation and hand them over, so no physics is written twice. Every part names its material and wall, since a default would be a guess at the rocket’s mass. Degenerate numbers are refused where they are given, each by name (L95; The builder) | |
| ADR-104: A drag model replaces the zero-lift drag only, as a drag table does | M4.1b closes M4.1: a drag model of your own, a Rust trait, gives the rocket’s zero-lift drag coefficient at each flow, with hpr’s own drag at hand to adjust. The flight scales it for the angle of attack as it scales a table’s; the normal force, center of pressure and damping stay hpr’s. A model and a table replace each other, and a powered separation refuses either. A model handing back hpr’s drag flies the same flight bit for bit. Three examples join the builder’s, and hpr::guide is the guide in the API reference (Models of your own) | |
| ADR-105: The command line’s surface: every command registered, JSON by schema, a generated table | M4.2 is split in four: the command surface and hpr motors first (M4.2a), then flying a design (M4.2b), the validation cases and file conversion (M4.2c), and reading a flight log (M4.2d). Every command is registered from the start, and one not yet available refuses with exit status 3 and the milestone that brings it. With --json a command prints one JSON document, even when it fails, and each document has a published schema. The README’s command table is written from the tool’s own list of commands, so it can’t claim one that doesn’t exist (The command line) | |
ADR-106: hpr sim flies the library’s flight, the stack whole, from a stated launch | M4.2b: hpr sim flies a .ork or a rocket’s JSON with the library’s own code, so its numbers are a program’s to the last bit. Without options it launches at 0° N, 0° E, sea level, from a vertical 1.5 m (4.9 ft) rail in calm air, and prints what it used. It flies no parachute or separation yet, and says so in its notes; a rocket whose stages come apart under power is refused (The command line) | |
ADR-107: hpr validate shares the project’s own validation check; hpr convert translates .eng and .rse by the format notes | M4.2c: hpr validate re-runs the RocketPy validation cases and makes the check the project’s automated tests make, with the same code, so the two fail together; it needs a copy of the repository (since replaced by cargo xtask validate --check, ADR-187). hpr convert writes a motor as .eng or .rse: the thrust curve, size and masses come back bit for bit, what .rse adds is filled the way ThrustCurve.org’s .rse files are, and what .eng can’t hold is dropped with a warning (The command line) | |
ADR-108: A flight log read alone: PerfectFlite’s .pf2 first, heights after a running median, an invented log in CI | M4.2d: hpr analyze reads a PerfectFlite altimeter’s log, with no design file, and prints liftoff, apogee, the top speed and landing, each saying where it came from or why the log can’t support it. Heights come from the altitude after a running median, not the Hampel filter Debrief used, because on a real log the Hampel filter kept an ejection charge’s pressure pulse as the apogee. The tests read an invented log whose every reading is known; the one public real log, whose terms are unclear, is read only where it has been fetched (Flight-log readings) | |
ADR-109: M3.2 split, and a .ork written from the design | M3.2 is split: the writer first (M3.2a), then OpenRocket loading and flying what it writes (M3.2b). hpr writes a .ork from its own design, each value as the reader reads it, and puts back everything it keeps but doesn’t model where it was. A value the reader drops, such as a rail button’s screw height, is kept and written back, so OpenRocket still reads it. Each number is written as the shortest decimal that reads back to the same bits. Ids that aren’t UUIDs are left out, since OpenRocket refuses a file holding one (Writing a .ork) | |
| ADR-110: M3.2b: OpenRocket flies the export; only counts are published | OpenRocket 24.12 tries to fly each of the 75 .ork files hpr’s checks use twice, as written and as hpr writes it back out, and only counts are committed. Every design it opens as written must open as exported, a design it refuses must be refused for the same reason, and every configuration flown both ways must reach the original’s apogee within 0.5% (Checked in OpenRocket) | |
| ADR-111: M3.3: the hpr design format, its extensions, versions and crate | M3.3 is split: the JSON document first (M3.3a), then the zip container, migrations and the comparison (M3.3b), then generated types (M3.3c). A design is a .hpr file, the container a .hprz. A document names its format and a major.minor version, checked first; a key its version doesn’t define is refused, not dropped. The document holds the design as the .ork reader models it, with the source file’s other files, so hpr-format builds on hpr-io (The hpr design format) | |
ADR-112: M3.3b: the .hprz container and migrations | Version 0.2 renames the source file’s other files source_files, so “attachment” means a file in a .hprz, and records why a .ork’s airframe wasn’t read as written, which the .ork written from a document can’t say. A change that stops old documents reading takes a new version and a migration, tested on a committed older document. A .hprz is a zip whose first entry is the .hpr; attachment names are relative paths, refused otherwise. hpr convert and hpr sim take all three design formats (The hpr design format) | |
| ADR-113: M3.3c: TypeScript and Python types | xtask generates the types and a reader for each language from the schema, not a third-party generator. A reader checks a document against the schema embedded in its file, and tests hold both readers to a separate schema checker on 4,892 altered documents. Not on npm or PyPI (TypeScript and Python) | |
| ADR-114: M4.3: the Python package | M4.3, the Python bindings, is split in three: the package, RocketPy’s example flown from Python, and models written in Python. The package wraps the Rust builder and adds no physics; it keeps RocketPy’s shape (a flight flies when it is made, its recording comes back as arrays) but the Rust API’s unit-named arguments. One wheel per operating system serves CPython 3.10 on; nothing is published to PyPI | Python |
| ADR-115: M4.3b: a drag table, and Calisto from Python | The flight builder takes another program’s drag table, and the Python package gains it with RocketPy’s gravity formula and a parachute cut away when another opens. RocketPy’s ways of measuring a flight (from the dry center of mass, its rail exit at the forward button) stay in the Calisto example rather than the library; a test holds the example to 3% of RocketPy and to the validation suite’s own numbers | Python |
| ADR-116: M4.3c: drag and wind as Python functions | A flight takes a drag, and an environment a wind, written as Python functions. hpr calls them as it flies; an exception one raises stops the flight and reaches the caller unchanged, not as hpr’s own error. A constant drag function flies exactly as a table of the same number | Python |
| ADR-117: M5.1 split; the cache and offline mode | The online layer ships in two parts: first the cache and the offline rule over a transport you plug in, then HTTP. Offline never calls the transport; online, a copy younger than the source’s time to live is served without fetching, and a failed fetch falls back to an old copy marked stale | Online data and the cache |
| ADR-118: M5.1b, HTTP over the cache | The HTTP client is ureq with rustls, behind a cargo feature, so no OpenSSL. Its size limit counts the unpacked answer, since a small compressed one can unpack to gigabytes. The platform’s cache folder is found by hand, because the usual crate for it pulls in a weak-copyleft (MPL-2.0) dependency | Online data and the cache |
| ADR-119: M5.2 split; Open-Meteo’s pressure levels as a sounding | The weather milestone ships in four parts: Open-Meteo first, then weather-balloon soundings, then NOAA’s model files, then files you download and the hpr weather command. Open-Meteo’s answer becomes a sounding whose lowest level is the ground, with the 10 m (33 ft) wind as the wind on the rail. Levels the models report below the ground are left out, and the heights are read as geopotential, which a check on the recorded answers bears out | Launch-day weather |
| ADR-120: University of Wyoming soundings | A weather balloon’s sounding from the University of Wyoming’s archive is read from its comma-separated text, whose column names carry the units. Rows are kept from the longest chain from the ground in which each row fits the thickness the hypsometric equation gives the layer from the row before it; of each run of rows with the same rounded pressure the middle one is kept; a row kept must lie above the last one kept. The first row is the ground; the answer is refused when a chain without the ground beats every chain with it. A saved copy is fetched again once the sounding has settled. Only soundings from U.S. stations, U.S. government works, are committed as test data | Weather-balloon soundings |
| ADR-121: GFS and RAP from NOMADS’ grib filter, read by an in-house GRIB2 decoder | NOAA’s GFS and RAP forecasts are fetched as a small GRIB2 cut from NOMADS’ grib filter, 0.3° each way around the site, and blended bilinearly between the four grid points around it. The ground and the levels above it follow ADR-119 (the Open-Meteo sounding), and RAP’s winds, given along its map’s grid, are turned to east and north at the site. hpr reads GRIB2 with its own decoder (latitude/longitude and Lambert grids, simple packing) rather than the grib crate, which gives single-precision values and binds C libraries; every value matches ecCodes’ to one rounding. Whole NCEP files, with complex packing or JPEG 2000, are refused and left for files you download | NOAA forecasts: GFS and RAP |
ADR-122: hpr weather, and M5.2d split | The command line fetches a launch day’s weather from any of the sources, one subcommand each, through the same cache as the library. --offline answers from the cache alone, and --from reads an answer saved earlier, held to the same checks as a fetched one. The profile is written as the library’s own sounding type, which reads it back with its checks. NOAA’s whole files, with their other compressions, follow in two more steps | The command line |
| ADR-123: Complex packing, and a whole GFS file | hpr’s GRIB2 decoder reads the tighter packing of NOAA’s whole GFS files, and totals over a time span (such as accumulated rain; read, not used in a profile). Every value of one whole file was checked against ecCodes by a script, run once outside CI; CI checks eight of its messages and a recorded cut ecCodes packed the same way. A whole file’s profile is its NOMADS cut’s to 1.04e-7, with the levels above 10 hPa as well | A whole GFS file |
ADR-124: JPEG 2000 packing, through hayro-jpeg2000 | hpr’s GRIB2 decoder reads fields stored as JPEG 2000 images, as NOAA’s whole RAP files are, using a JPEG 2000 decoder written in Rust rather than one of its own. Only lossless images of up to 21 bits a value, coded as NCEP codes them, are read, which its 32-bit floats keep exact; the rest are refused by name. CI checks four public RAP fields against ecCodes | Files in JPEG 2000 |
ADR-125: Site data split, and WMM2025 in hpr-core | M5.3 split a to c; WMM2025 in hpr_core::magnetic, finite at the poles, refused outside 2025 to 2030 and −1 to 850 km (−0.62 to 528 mi); NOAA’s 112 test values, NCEI’s file’s X to its measured 7.18e-4 nT residue, shown to lie in the file’s X′ | |
| ADR-126: M5.3b, Open-Meteo’s elevation through the cache | M5.3b: Open-Meteo’s elevation in hpr_net::elevation, up to 100 places a request, coordinates to 5 decimals in the URL, a year’s TTL, heights refused outside −1,000 to 9,000 m (−3,281 to 29,528 ft), a surface model above the EGM2008 geoid with N left to the caller; no command yet | |
| ADR-127: M5.3c1, geodesics through GeographicLib, held to Karney’s test set | M5.3c split c1, c2; geodesics in hpr_core::geodesic through geographiclib-rs, flattening past 1/150 refused; Karney’s 500,000-line test set within his 15 nm on five measures, either azimuth pair on its 21 mirror lines | |
| ADR-128: M5.3c2, a site’s height from a user’s GeoTIFF, held to rasterio’s reading | M5.3c2: a user’s GeoTIFF in hpr_io::geotiff over the tiff crate; geographic CRSs within a few meters of WGS 84 only, projections and far datums refused; the containing pixel placed as GDAL places it; GDAL’s scale and offset, units the file states, else meters; held to rasterio 1.5.2 on seven fixtures and a whole USGS tile | |
| ADR-129: M5.4 split, and M5.4a, the motor finder’s API through the cache | M5.4 split a to c; M5.4a: motor.fusionspace.co’s five files in hpr_net::motor_finder through the cache, an hour’s TTL, its structural rules refused and its derived ones pinned on the recording; eight answers of one build committed as fixtures; the credit with the site’s caution on every answer | |
| ADR-130: M5.4b, ThrustCurve searches and curves through the cache, and the in-stock join | M5.4b: ThrustCurve.org’s search and download in hpr_net::thrustcurve through the cache, a day’s TTL; the join by exact maker and designation, misses reported not guessed; three makers’ searches and two public-domain files committed as fixtures; the join’s report in validation/reports/thrustcurve-join.md | |
ADR-131: M5.4c, hpr motors search, stock and prices at the command line | M5.4c: hpr motors search, the finder’s list from the network, the cache or a saved file; five filters, --max-price in exact cents on the cheapest in-stock offer; cheapest first; both credits on every list; the example tested on an edited copy, as the recording lists nothing at $150 | |
ADR-132: M5.5a, OpenRocket’s .orc parts catalogues, held to OpenRocket’s reading | M5.5 split a and b; M5.5a: hpr_io::orc reads OpenRocket’s .orc parts catalogs; the 16 files OpenRocket 24.12 ships bundled unchanged (Apache-2.0); held part by part to OpenRocket’s preset loader, run as an oracle; exact unit definitions, the file’s makers’ names and densities kept, a stated mass kept beside them; unreadable parts left out with a warning, not the file | |
| ADR-133: M5.5b, catalogue parts in the builder, weighed as OpenRocket builds them | M5.5b: catalog parts in the builder (from_catalog on Nose, Tube, Transition, MotorTube, and the new Fitting); what the file leaves unsaid as OpenRocket 24.12 builds it, but a hollow part’s shoulder takes its wall; a stated mass scales the part’s density; a part with an undefined material refused; every part held to OpenRocket’s built mass and center, the two codes’ hollow walls each checked | |
| ADR-134: Monte Carlo dispersion: independent normals, one stream per sample and input | M6.1a: Monte Carlo dispersion in hpr_analysis::montecarlo; each input an independent normal about its nominal value; one random stream per sample, input and copy, keyed by SeededRng::for_stream; impulse dispersed with the propellant mass; a drag scale in the aero model; failed samples kept; M6.1 split a to d | |
| ADR-135: Landing ellipses: the normal ellipse, the next flight’s, and a count of what each holds | M6.1b: landing ellipses in hpr_analysis::ellipse; the normal ellipse of the sample’s mean and covariance, scaled by k² = −2 ln(1 − p); a prediction ellipse for the next flight by Hotelling’s T²; the landings each ellipse really holds counted, failures as bounds; tested against normal spreads with known answers | |
| ADR-136: Sensitivity analysis: Morris paths and Saltelli’s Sobol’ estimates, with their standard errors | M6.1c: sensitivity analysis in hpr_analysis::sensitivity; uniform independent factors; Morris’s paths with μ, μ*, σ and μ*’s standard error, and the exact grid moments by Morris::population; Saltelli 2010’s first-order and Jansen’s total estimates on pseudo-random rows, with delta-method standard errors; held to Ishigami and Sobol’s g in closed form and calibrated over seeds | |
| ADR-137: Ten thousand flights: a run’s flights share the nominal’s layout and supersonic table | M6.1d: a Monte Carlo run’s flights share the nominal design’s supersonic table (AeroModel::share_supersonic_table, when the covered segments and reference area are equal) and its layout (Rocket::lay_out, LaidOut::relay, Simulation::from_laid_out); evaluations borrowed, not copied; 10,000 flights timed on Valetudo (the flight benchmarks’ Level 2 rocket) and on a supersonic K940 rocket, by a bench target; per-evaluation speed-ups left to #285 | |
| ADR-138: Optimization: CMA-ES first, held to test functions and to pycma | M6.2 split a to e; M6.2a: CMA-ES (Hansen’s tutorial, Table 1, positive weights only) over continuous variables, worked in each variable divided by its step, with optional bounds by resampling, ask-and-tell (Run::tell), Jacobi eigen-decomposition each generation; held to four test functions’ minima, to pycma 4.5.0’s evaluation counts (medians within 25%) and to a dense recomputation of every generation; the 3,048 m (10,000 ft) problem re-flown from a fresh build and at 100× tighter tolerances | |
| ADR-139: Optimization constraints by Deb’s feasibility rules | M6.2b split b1, b2; M6.2b1: constraints for CMA-ES by Deb’s (2000) feasibility rules (Evaluation, Run::tell_constrained), no penalty weight; infeasible candidates ranked, not redrawn; a target and TolFun count only feasible points; held to the sphere with x₀ ≥ 1, the tangent problem and CEC 2006 g06 from 20 seeds | |
| ADR-140: Discrete choices by CMA-ES with margin | M6.2b2: integer variables (Variable::integer) by CMA-ES with margin (Hamano et al., GECCO 2022), α = 1/(nλ); Φ by libm::erfc, Φ⁻¹ by AS 241; held to SphereInt, EllipsoidInt and SphereOneMax at 10 and 20 variables and to cmaes 0.13.1’s CMAwM; the rocket example hits 3,048 m (10,000 ft) with the motor and nose free, its body length fixed so designs share a supersonic table | |
| ADR-141: Several goals by NSGA-II | M6.2c: several goals by NSGA-II (Deb et al. 2002) with bounded SBX and polynomial mutation, constrained domination; held to ZDT1 to ZDT3’s exact fronts and to pymoo 0.6.2 (every run’s GD and IGD within twice pymoo’s worst, medians within a factor of 1.25 either way), tournaments paired as pymoo pairs them; a rocket’s apogee against static margin, its front flown again and matched by CMA-ES at 2.5 calibers | |
| ADR-142: Few evaluations by EGO | M6.2d: EGO (Jones, Schonlau and Welch 1998) with a kriging surrogate fitted by likelihood and the expected improvement searched by CMA-ES; M6.2d split d1 (Branin, Hartmann 3: within 1% of the minimum in 50 evaluations from 20 seeds, worst 0.12%) and d2 (Hartmann 6, which d1’s version leaves at a local minimum in 7 runs of 10) | |
| ADR-143: The operating envelope and a stop rule for accuracy work | Bands are by Mach alone. Accuracy work goes to the core band first, Mach 0 to 2.5, where nearly all commercial-motor flights are; Mach 2.5 to 3.5 is the extended band, flown with less accuracy checking. The envelope is Mach 0 to 3.5 at any angle of attack. Angle is a separate condition: accuracy work assumes 15° or less. Faster flights still fly; M1.14a will flag those at high angle of attack, outside the core band or beyond the envelope. An accuracy step counts as progress when it shrinks a measured error against an independent reference, or adds a reference that will; two in a row that do neither end the milestone, gaps written down. | Validation plan: the operating envelope |
| ADR-144: The 2026-10-03 planning review: leaner bookkeeping, issues, writing, guardrails and licensing records | The 2026-10-03 planning review: M0.5 leaner bookkeeping first, then M6.2d2 (one attempt), M4.5, M1.14, M6.2e, M6.3 on; M4.5 and M8.3 CAD interop added; issue labels and P-critical first; a writing standard; guardrails; licensing records | |
| ADR-145: Recorded answers and their licences: stand-in ThrustCurve searches, CC BY 4.0 for the motor finder | Recorded answers and their licenses: ThrustCurve.org’s three searches replaced by stand-ins (five invented motors per maker, and the in-stock motors’ records carrying the motor finder’s CC BY 4.0 values); motor.fusionspace.co’s answers under CC BY 4.0, credited “Motor stock data from motor.fusionspace.co” | |
| ADR-146: Leaner bookkeeping split, and one file per decision record | M0.5 in nine increments, one per item of its plan; each decision record in its own file, with this site’s links and the generated index pointing at it, and every older link still landing on the record’s row | Decisions and the roadmap |
| ADR-147: M0.5b and M0.5d, a roadmap of open work, an archive and tables kept by the tool, and a queue the check follows | The roadmap now holds only open work, in an order set by a queue at its top that the checks follow; done milestones move unchanged to an archive file, and the site’s tables of records follow, by a command rather than by hand | |
| ADR-148: M0.5c, short planning files with size checks | Planning files kept short, with size checks. | |
| ADR-149: M0.5e to g, reviews while CI runs, a faster gate and a split CI | Reviews start once the PR is open and CI runs, with a shared bar for blocking findings and scoped re-reviews; the gate runs tests in parallel and adds the private-data checks when physics changes; CI’s slowest job is split. Amended 2026-11-03: a pull request’s CI within 20 minutes and a passing full gate within 30; the flight censuses (the synthetic flights, two logs and the fit’s intervals) run whole each night on main, a failure filing a P-critical issue, and a change to research notes alone skips the jobs that read none. Amended 2026-11-04: pull requests and the gate fly every 21st flight of the synthetic flights and two logs, held line for line to a committed slice. | |
| ADR-150: Peak thrust and the burn-time crossings come from delivered samples | A thrust-curve sample strictly inside a run of three or more equal times is never delivered, so it no longer sets the peak thrust or a 5%-of-peak burn-time crossing; no surveyed ThrustCurve.org file changes | |
| ADR-151: hpr-sim-fixtures joins the reference library as private data | Neer’s collection of designs paired with the logs of the same flights is pinned in the reference library and kept private under refs/; only aggregate statistics are published; it stays out of the default .ork survey until an increment brings it in | |
| ADR-152: Hartmann 6 by EGO’s log transform | M6.2d2: EGO fits its surrogate to −ln(−y) (or ln y) of the values when the caller asks, as Jones, Schonlau and Welch did on Hartmann 6; all 20 runs (seeds 1 to 20) end within 1% of the minimum in 250 evaluations, worst 0.29%, against 6 of 20 without; the 20-run check is a release-build program the local gate runs, as it takes hours in CI’s debug build | |
ADR-153: A .ork’s recovery flown as OpenRocket flies it, held to its descents | M4.5a: a .ork configuration’s parachutes and streamers become flight devices: the stated drag coefficient, or OpenRocket’s own (0.8 on the canopy for a parachute, appendix C for a streamer), opening at once; apogee, altitude, ejection and launch triggers with the file’s delay. Targets, set before any hpr descent was measured: each deployment within 0.1 s or 2% of OpenRocket’s time, landing speed and flight time within 5% | |
| ADR-154: Motors fetched from ThrustCurve.org by name, cached, and named when offline | M4.5b: hpr sim fetches a motor the bundled catalog lacks from ThrustCurve.org, by name for --motor and by manufacturer and designation for a .ork motor with no curve, through hpr_net’s cache; hpr motors fetch pre-loads; offline and uncached, the refusal names the exact command. One rule picks the file; nothing is bundled | |
| ADR-155: Design checks that match reality: a part through the skin, a case that can’t fit | M4.5c: an internal part wider than its parent’s bore but inside the airframe warns; one that reaches past the airframe’s outside by more than 0.005 in is an error. A nominal motor size wider than its mount’s bore warns while AeroTech’s drawn case fits it, and is an error past that. OpenRocket’s examples raise no design error; the private library’s errors fall from 13 flights to 5 | |
ADR-156: hpr sim reads by name: configurations by their motors, a lead summary | M4.5d: hpr sim’s text names configurations, mounts and the design checks’ parts by name, never by UUID; an unnamed configuration is called by its motors and delays in brackets, such as [C6-5]; --config takes a configuration’s number, name or id, and --mount a mount’s name or id; the checks print as sentences; the summary leads with margin, apogee, rail exit speed, delay and descent. --json keeps the ids | |
ADR-157: hpr sim --plot draws one fixed SVG figure | M4.5e: hpr sim --plot FILE.svg writes one SVG: altitude, speed and acceleration against time in three panels over one time axis, each instant with events a numbered marker listed underneath, and the fall on the airframe alone shaded “not a prediction”. It is drawn by hand in hpr-cli, with no plotting dependency, from its own sampling of the flight, which adds every step’s start and end to the recorder’s times so a parachute’s opening is drawn at full height | |
ADR-158: Three how-to guides run like the command-line guide, on a rocket of their own, with --delay for --motor | M4.5f: the guides “Fly your .ork”, “Pick a motor” and “Check stability for a certification flight”, and the README’s “Install and first flight”, show hpr’s output made by running each command, as docs/cli.md does, so CI fails when one goes stale. They fly a hand-written public design, validation/fixtures/ork/guides/level-1.ork, whose two motors are in hpr’s catalog, so they run offline. hpr sim --delay sets --motor’s ejection delay. Guidance numbers are quoted from their sources, dated, never stated as hpr’s | |
ADR-159: A .ork’s powered separation flown in hpr sim, each part under its own devices, a part with none tumbling | M4.5g1: hpr sim flies a .ork configuration whose booster drops away under power. hpr::ork::separated_recovery puts each parachute and streamer on the part its stage is in, and adds the tumbles the flight needs: the booster tumbles from the split until its first own device opens and releases the tumble, and a sustainer with no device tumbles from its apogee. FlightBuilder::separation takes the separation, so the command flies the library’s flight, bit for bit. Each part’s landing is printed. The sustainer’s descent is held to OpenRocket’s with ADR-153’s targets; the booster’s is not validated | |
| ADR-160: Several powered separations, each handing the flight on to a sustainer cut at its boundary | M4.5g2: the flight takes a list of separations, each at a stage boundary further forward than the one before (Simulation::with_separations). With more than one, each must leave the nose’s body a motor to burn: at each, the stages behind drop away and the flight flies on as a sustainer cut from the whole design at that boundary. OpenRocket’s Three stage low power rocket flies in hpr sim and in cargo xtask ork-flights. On OpenRocket’s own curves its three configurations are within 1.48% of OpenRocket’s apogee and 1.64% of its largest speed, both separations at OpenRocket’s times; in hpr sim, on the curves it fetches (ADR-161, OpenRocket’s curves by digest), within 2.48% and 1.67% | |
ADR-161: A .ork motor fetched from ThrustCurve takes the file holding OpenRocket’s curve for its digest | amends ADR-154 §2 and §4: a fetch may name a ThrustCurve data file to take ahead of the rank’s order (Wanted::prefer, hpr motors fetch --file). hpr sim names one for a .ork motor whose digest a committed table holds: the file whose curve is the one OpenRocket flies. cargo xtask ork-curves writes the table for the motors of OpenRocket’s examples by comparing curves; it holds ids alone. With it, OpenRocket’s three-stage example’s first configuration reads +0.31% of OpenRocket’s largest speed in hpr sim, not +5.7%, and every configuration is within 2.48% of OpenRocket’s apogee | |
| ADR-162: The suite and its releases: what ships when, and the order of the new product lines | Neer’s 2026-10-04 ideas: hpr-sim becomes a suite of six products built in one workspace and joined by shared formats (simulator, flight analyzer, app, motor designer, recovery designer, avionics). Releases come at product boundaries: 0.1 the simulator once M4.5 and M1.14a are met, 0.2 accuracy, 0.3 the flight analyzer, 0.4 competitions, 1.0 the first app. The UI phase no longer waits for every library phase. COTS solids stay the only scope until 1.0. After it, the new lines come one at a time: experimental solid motors, then custom parachutes, then avionics, then hybrids and liquids. Each line gets its own guardrails | |
| ADR-163: The second pass: six products, the analyzer before the accuracy campaign, and what each release must hold | Amends ADR-162 §1 to §4 after a whole-project review (95 open issues). Six products, defined by who uses them; the competition kit is one, and avionics starts as a test bench for any flight computer. Release 0.1 adds Monte Carlo from the CLI and Python, an apogee check on logged flights, and named issue fixes. 0.2 becomes the flight analyzer, ahead of the accuracy campaign; 0.3 is accuracy and fault diagnosis; 0.4 the competition kit, with RASAero and RocketPy files and ejection-charge sizing; 0.5 an app preview centered on the 3D ghost replay; 1.0 the app with the editor. After 1.0: the motor designer, the recovery designer, pad day on a phone, then avionics | |
ADR-164: hpr-sim follows the FusionSpace product system, as FS · SW · TOOL 005 | hpr-sim adopts the FusionSpace product system (nrdptel/fusionspace-design, product/, Rev A, pinned at 32770a4) for its command line, documentation site, plots, exports, writing and every later app and device. It takes the designation FS · SW · TOOL 005. Apache-2.0 files from the system are copied in with their license lines; brand files only as README banners, outside the repository’s license. Milestone M0.6 makes the existing surfaces comply, after M4.5 and before release 0.1; later milestones and every release checklist take the system’s rules and checklists. The CLI keeps SI first with US units in brackets, and carries no brand banner | |
ADR-165: A .ork’s separation with nothing left to burn flies in hpr sim when each part has drag from the split | M4.5g3: a .ork configuration whose only separation comes with nothing ahead of it left to burn is read and flown. From the split every part flies as a point with only its own devices’ drag, ADR-014’s model unchanged, so hpr::ork::tumbling flies it only when the part that keeps the nose has a device of its own open by the split, and refuses it otherwise. lowerstageseparation opens a device on the split’s own trigger. OpenRocket’s Deployable payload and ARC payload rocket fly: the payload’s apogee within 1.05% of OpenRocket’s record and every descent within ADR-153’s targets. The coast with no drag that the rule refuses would put one payload 4.00% above OpenRocket’s own free flight of it | |
| ADR-166: A fin set on a nose cone or a transition, its root along the surface | M4.5g4: a freeform fin outline’s last point may stand above its first, and the planform gains root_m, the root’s points between its trailing and leading edges. A fin set may sit on a nose cone or transition: the tree checks that each of its root’s points lies within a micron of the surface and that it has no tab or fillet. The .ork reader draws the root through 63 points on the parent’s profile. OpenRocket’s Pods--airframes and winglets flies all five configurations, each apogee within 0.5% of OpenRocket’s record; its cockpit’s area, mass and center of mass match on OpenRocket’s own root points | |
| ADR-167: A part’s drag override, as OpenRocket flies it | M4.5h: a .ork part’s or stage’s stated drag coefficient flies in hpr as OpenRocket 24.12 flies it, measured on 25 probes; a step down belongs to the part ahead of it; Base drag hack (short-wide) within 2.1% on a C11-5, but 13% and 11% high on a D12-3 and an E12-4 for its nose (#177), not the setting: not met for those two, recorded. | |
| ADR-168: Pods--powered flies, and the margin is the weakest plane’s | M4.5i: a rail button’s screw head weighed as half an ellipsoid; the thrusting motors’ area told apart per pod set; a device at the charge of a stage where no motor lights never opens, as in OpenRocket; the margin reported in the rocket’s weakest plane (#329); OpenRocket’s Pods--powered with recovery deployment flies its three complete configurations, two within 1.9% of OpenRocket’s apogee, the third turning over before apogee in both tools | |
| ADR-169: A ring around its tube needs room in the part around it | M4.5k: a centering ring on its tube’s axis whose bore takes the tube’s outside wraps the tube, and is measured in the part around it at its own station that holds it whole; amends how two earlier decisions read the pods examples’ rings, which now fly as saved | |
| ADR-170: A packed part wider than its bore warns | M4.5l: a packed part (a mass component, parachute, streamer or shock cord) drawn wider than the room in its parent warns, by any amount, while its center is in that room, and flies as drawn; its width sets only its own inertia. A ring, tube or packed part centered past the room stays an error. OpenRocket’s Deployable payload flies its five configurations as saved | |
| ADR-171: A parallel stage is a pod set that separates | M4.5m: hpr’s design gains a parallel stage, a stage laid out as a pod set beside a body tube of an axial stage before it, weighed to its own stage and dropped by its own separation as a part that tumbles. The .ork reader reads OpenRocket’s <parallelstage> on a rocket of one axial stage; a motor in it lights as one in that stage does, and a parallel stage with no motor that lights stays on. OpenRocket’s Parallel booster staging flies both configurations as saved, each apogee within 1.3% of OpenRocket’s | |
| ADR-172: A stage’s first burnout, and a booster dropped still burning | M4.5n: a .ork stage whose motors sit in several mounts burns out when its first motor does, by the motors’ ignitions and curves, as OpenRocket 24.12 flies it (measured by a committed probe). The stage above lights there, and the stage separates there, when the file says so. A split at that first burnout may drop the stage’s other motors still burning. The flight then leaves their thrust out of the dropped part’s flight as a point, and says how much impulse that is. OpenRocket aborts its own flight of Pods--powered with recovery deployment’s first configuration, so hpr’s flight of it is checked against OpenRocket’s up to the abort: at the separation and at OpenRocket’s last row, within 5% | |
| ADR-173: A blunt ellipsoid’s subsonic pressure drag, from Hoerner’s measurement | M4.5o: an elliptical nose or shoulder takes Hoerner’s measured forebody pressure drag below Mach 0.8 (a hemisphere 0.01, a round head one diameter long −0.05, a flat face the step’s), held at 0 from 7/12 caliber on, and rises in a straight line from Mach 0.8 to Stoney’s scaled curve at Mach 1.2. Base drag hack (short-wide)’s 0.577-caliber nose gets 0.0008, so its E12-4 stays 7.80% above OpenRocket’s apogee with recovery in both: the 5% bar would need about 0.015, which no measurement supports. Not met, recorded; M4.5 is closed with that gap. | |
ADR-174: The command line’s colors, help: lines and title block | M0.6b: hpr colors its streams by the product system’s cli.md (the --color flag, then NO_COLOR, then FORCE_COLOR or CLICOLOR_FORCE, then auto), in the system’s fs_style.rs roles, copied in unchanged; never in --json output or a file. Every hint is a help: line, and an error document’s help array; clap’s tip: and “For more information” lines are rewritten to match. hpr --version, every --json document (a tool object first), and every file hpr writes name hpr-sim, its version and FS · SW · TOOL 005, where its format keeps them; a CSV’s goes in a .meta.json sidecar. A converted design file names this program, its source kept as read, amending ADR-112 §6. | |
| ADR-175: The plot in the product system’s chart style | M0.6c: hpr sim --plot draws in the light theme’s color roles of the product system’s foundations (Rev A) and no other color; every series is simulated, so dashed in the predicted color, a quantity’s size thick and its vertical part thin; events are dotted lines under numbered balloons with a table of every event’s number, time, altitude and name; the ground is a chain line; axis titles are QUANTITY · unit; no legend box, the line types said once in a caption whose first line, also the SVG’s <desc>, gives the summary’s apogee, its time and top speed. The fall that is not a prediction is hatched, its label outside the hatching. Amends ADR-157 §2, §3 and §5. | |
| ADR-176: The spelling check: what it reads and what it leaves alone | M0.6d is split in two: M0.6d1 adds cargo xtask spelling and clears the pages, the README and the scripts; M0.6d2 widens its scope to the crates, xtask, the schema and the pages’ fenced code blocks. The check reads a file’s writing (a page’s prose, a source file’s comments and strings) and skips code identifiers, string literals that are one bare word, link targets and URLs, HTML tags, links quoting a decision record’s title, and the frozen records, which now include docs/DECISIONS.md. Quotations, source titles and names that keep their spelling sit on a short list in the check, each with the phrase that holds it; the check counts them on every run and fails on an entry that matches nothing. | |
| ADR-177: The spelling check in the crates: words first, em dashes next | M0.6d2 is re-split in two before it shipped: M0.6d2 widens cargo xtask spelling to crates xtask schema and the pages’ fenced code blocks, read by each block’s language, and clears every UK spelling there; M0.6d3 rewrites the 266 em dashes left in them, which the check counts and prints until then. A name in a format string and a key quoted inside a string are identifiers; the check’s own file isn’t read; probe names an oracle’s recording keys by are allowed names. | |
| ADR-178: US names, and the spelling check reads them | M0.6e renames the 63 names that held a word on M0.6d’s list (center_of_pressure_m, MorrisDesign::analyze, VerticalUnit::Meter and the rest, as they are now called) to their US forms, and cargo xtask spelling now reads names as well as writing, so a new one fails CI. Seven serialized types keep each renamed key’s old spelling as a serde alias, read and never written, with tests that read the old form back; the design format’s keys never held a word on the list. GDAL’s own names for a unit are another program’s data and stay. | |
| ADR-179: The envelope flags, and when an angle of attack counts | M1.14a splits in two: a1 the four envelope flags of ADR-143 §1, a2 the warnings for ADR-163 §4’s issues. The flags come from a flight’s summary: three by its top Mach number against 1.1467 (the fastest public reference, pinned to the committed reports by a test), 2.5 and 3.5, and one by a new peak, the largest angle of attack more than 1 s after the rail exit and before apogee or the first deployment, counting only instants whose dynamic pressure is at least a tenth of the largest so far. Each edge is exclusive. The library, hpr sim (text and JSON) and Python all report them. | |
| ADR-180: The drag issue warnings, and M1.14a2’s split | M1.14a2 splits in two: a2 the warnings for the five drag issues on ADR-163 §4’s list (#67, #68, #70, #72, #222), a3 the four stability ones (#87, #120, #121, #172). A drag warning comes from the flight’s top Mach number and the design’s parts: a cone or ogive nose past Mach 0.8 (#67); every rocket past Mach 0.8, saying low from 1.2 (#68); airfoil fins past Mach 1 (#70); a boattail steeper than 10° past Mach 1 (#72); an ogive nose or airfoil fins past Mach 1 (#222). Each Mach edge is exclusive; a NaN top Mach number raises every warning the design’s shape allows. The library, hpr sim (text and JSON) and Python report them. | |
| ADR-181: The stability issue warnings | M1.14a3’s four stability warnings. #87, #120 and #121 warn past Mach 1.2 when hpr_aero’s supersonic body run, which is otherwise silent about why it stops, names that switch as the one that stopped it: a new public SupersonicFallback on AeroModel. #172 states no condition, and its cause is unmeasured, so it warns on every flight on hpr’s own aerodynamics that reports a smallest static margin, quoting the largest measured gap (0.073 calibers high) and no threshold. | |
ADR-182: hpr mc, Monte Carlo from the command line | M4.6 is split: M4.6a hpr mc, M4.6b Python. A Monte Carlo run’s FlightInputs now carry the flight’s separations, so a staged .ork is scattered as hpr sim flies it, and a tumble hpr adds to a separated part is not given a dispersed lag. hpr mc takes one option a dispersion, in the command line’s units, flies its samples on every core, prints the nominal flight beside the apogee’s and landing distance’s spreads and three landing ellipses, counts its failed flights by reason, and exports every flight as a CSV table (hpr_analysis::table::RunTable) whose numbers read back to the run’s bits. | |
| ADR-183: Monte Carlo in Python | hpr.MonteCarlo flies the library’s run on every core and returns its RunTable as NumPy arrays: numbers as float64 with NaN for a missing value, index as uint64, words as string arrays. Its eleven arguments are hpr mc’s options under the names its JSON uses. Rocket.from_file(..., recovery=True) flies a file’s recovery devices as hpr sim does, so a Python run and hpr mc can fly the same design, and a test holds them equal bit for bit with both release builds. | |
| ADR-184: Logged apogees of the private collection | M2.3c1 flies the 83 tier-A flights of hpr-sim-fixtures whose design is a .ork, in hpr and in OpenRocket 24.12, each in its day’s ERA5 weather with nothing deployed, and compares each apogee with the flight’s logged one, turned into the height climbed in that day’s air. A hand-read manifest under the gitignored corpus/ holds what each flight’s free-text row says; only aggregates are published, with the collection’s credit and the Copernicus attribution. | |
| ADR-185: Release 0.1 split, and its first fixes | M10.1 is split in four: a, the flight and design fixes; b, the data, network and Python fixes; c, the release workflow; d, the release notes and ADR-162’s checklist. M10.1a refuses a separation or ejection timed before the rail exit instead of firing it late, records one apogee, counts only errors in SimError::DesignChecks’s message, makes DragTable::with_reference_diameter_m check its diameter (#79’s decision), and measures a part in a nose cone or transition against the room where it sits: an error past the fit tolerance of the widest room along it, a new warning when it fits there but runs into the wall where the profile narrows. | |
| ADR-186: The data, network and Python fixes of release 0.1 | M10.1b fixes five issues. The bundled motor catalog is written from its 32 public-domain curve files alone by cargo xtask motor-catalog, every figure the file’s own (#295). .hprz attachment names are compared after canonical decomposition as well as case folding (#252). Open-Meteo and NOMADS write a site’s coordinates to 5 decimals so a radians round trip keeps the cache key (#272). Three pages’ accuracy figures are the report’s, and the site’s number trace now checks them (#298). A pytest pins Python’s recovery=True flight to hpr sim’s bit for bit (#308). | |
ADR-187: The release workflow, its license texts, and hpr validate left to xtask | M10.1c: a Release workflow builds and smoke-tests the command line’s archives for three operating systems, the Python package’s abi3 wheels and its source package, each carrying both licenses, THIRD-PARTY-NOTICES.md and its dependencies’ license texts written by cargo-about; it publishes only from a dispatch that asks to, after approval in the release environment. Every library crate and hpr-cli become publishable. hpr validate leaves the command line, because a published crate can’t depend on the unpublished harness; cargo xtask validate --check makes the same check. | |
| ADR-188: Release 0.1’s notes, and the flattering-side issues without a warning | Release 0.1’s last increment splits in two. M10.1d1 writes CHANGELOG.md and the install pages, and lists by number every open env-core issue on the flattering side or of unknown sign; M10.1d2 adds a warning for each flattering-side issue that has none (#18, #64, #73, #179, #325, #326, #354, #367), settles or warns each unknown sign, fixes #335, and then shows the whole checklist at a commit on main. The changelog links pages by the site’s address and is held to the site’s link and label checks. | |
| ADR-189: The unstable-under-power flag and four shape warnings; M10.1d2 split in three | M10.1d2 splits in three: d2 the flag for a flight unstable under power (#335) and the warnings read from the design’s shape (#64, #73, #325, #367) with #172’s bound raised to 0.1108 calibers; d3 the warnings for separated parts, laminar friction and kinked fins (#18, #179, #326, #354) and the seven unknown signs; d4 the checklist and its Release dispatch. Each new warning’s condition takes in the unmeasured range next to its measured one. | |
| ADR-190: The friction and freeform fin warnings; M10.1d3 split in three | M10.1d3 splits in three: d3 the warnings read from the design and the drag alone (#18 on every flight on hpr’s drag, #326 on every freeform fin set, both at any speed); d5 the separated parts’ warnings (#179, #354); d6 the seven unknown signs. Each takes in its issue’s unmeasured range. | |
| ADR-191: Neer’s 2026-10-06 ideas: the four web tools, watches, the repo layout and the hardware line | the four FusionSpace web tools (Motor Finder, Charge, Window, Muster) are rebuilt as library code and app screens in M9.6, after mobile; Motor Finder’s scraper stays a hosted service whose API hpr keeps reading. hpr stays one repository with several workspaces, split only by named triggers. Watches wait until after mobile, with the phone as hub. The hardware line is ordered by regulation, and active-control firmware or hardware waits for Neer’s export-control answer. | |
| ADR-192: Neer’s 2026-10-06 follow-up: the best product over the first, no legacy contracts, and three export tiers | Neer’s decisions on ADR-191’s three open questions. The old web tools get no more work and constrain nothing: Motor Finder’s API is not a contract, and hpr’s stock service is designed fresh even if release 0.1’s reader breaks. The best product outranks the first release. Export control sorts the work into three tiers (public, held, never): the simulator and its control models stay public; firmware or hardware that moves a control surface is held off GitHub and out of cloud services until a ruling; target guidance, thrust vector control and lifted GPS caps are never built. | |
| ADR-193: Neer’s 2026-10-07 control scope: drag-only airbrakes, roll-only canards and fin tabs | hpr’s active control, simulated or built, is limited to airbrakes that only add drag and to canards and tail-fin tabs that only roll the rocket, stable with every surface inert and with any one surface stuck. The controller has two commands, brake deployment and roll, through a fixed mixer, so nothing can command pitch or yaw. Active pitch and yaw control joins the never tier; the backlog’s thrust vector control and active fins leave it. Roll tabs come before roll canards, because a tail spanning as much as the canards removed most of their roll in NASA’s supersonic tests. M6.5 becomes roll control; new M13.6 holds the control hardware for a ruling. | |
| ADR-194: Neer’s 2026-10-07 field tools: checklists, equipment and ground tests | Release 0.4 gains M6.8, a field kit in the library and the CLI: a launch checklist and guide, a check of each altimeter’s settings, and a ground-test log that M6.7’s charge sizing reads. M6.7 is tightened by the one measured source found (Fetter, 2025): a packed bay needed several times the calculated charge to separate, so a packed bay is sized to his measured outcomes, never from the empty-bay pressure; the bulkhead load takes the empty-bay peak’s high side; the charge grows with altitude, and above 20,000 ft no black-powder size is printed. M9.7 adds an equipment register and frequency board. M13.7 is a ground-test bench (a pressure logger and a wired firing box), in the public tier. | |
| ADR-195: Neer’s 2026-10-07 guides: rocketry explained, illustrated and live | Neer’s guides to all of high-power rocketry become M0.7, Rocketry explained, a section of the docs site in four increments. M0.7a, right after release 0.1, sets the format and writes four guides on the largest gaps hpr models: stability, fin flutter, drag through Mach 1, and how far to trust a simulation. M0.7b, before release 0.4, adds recovery, wind and rail exit, and motors. M0.7c, after release 0.5, makes the figures live, run by hpr itself in the browser. M0.7d, after 1.0, covers the rest of the hobby. Every number a guide shows comes from hpr or a cited source, every figure is checked for clipping, and nothing is copied from copyrighted or share-alike sources. | |
| ADR-196: Neer’s 2026-10-07 product guides: each product, illustrated | Each of the suite’s products gets a guide on the docs site: a landing page and an illustrated tour that ends on a public real flight, in M0.7’s format and checks. Every picture is made by a command CI reruns, never taken by hand: CLI output as terminal figures, plots from hpr, app screens from end-to-end tests, with phone and watch captures checked against the device’s safe area. M0.8a writes the simulator’s guide after M0.7a; from release 0.2 on, the release checklist requires that release’s guide, read by Neer; each line after 1.0 ships its guide with its first milestone. The roadmap’s budget rises to 40,500 bytes. | |
| ADR-197: Neer’s 2026-10-07 parts catalog: commercial parts, and a catalog of hpr’s own | OpenRocket’s catalog, bundled since M5.5, stays as the base. M5.6 adds a catalog of hpr’s own in four increments. M5.6a adds the format, where every value carries its source and date, plus hpr parts search and a parts list to buy from. M5.6b adds parachutes and recovery hardware, each Cd stored with its reference area and a descent rate given as a range, the flattering side pinned. M5.6c adds motor hardware and rail buttons, never counting a mass twice. M5.6d adds more airframe makers and electronics, masses carried as ranges. Only cited facts go in; no vendor text or photos. M5.6a comes after release 0.5, ahead of M8.2; the rest before 1.0, with M5.6b ahead of M8.1’s parachute sizing. | |
| ADR-198: Neer’s 2026-10-07 project name: Eridanus, its stars, and the design system’s catch-up | the project is Eridanus, FS-ERI, and the repository becomes nrdptel/fusionspace-eridanus when Neer renames it. Each product takes one of Eridanus’s stars as its internal name: the simulator is Achernar (FS-ACHERNAR), the app Zaurak, the flight analyzer Angetenar, avionics Sceptrum, the competition kit Acamar, the motor designer Rana and the recovery designer Cursa. The designation FS · SW · TOOL 005, retired in the design system, becomes FS-ACHERNAR · SW · TOOL 001, and files stamped with the old one still read. GitHub doesn’t redirect a project site after a rename, so the rename comes before release 0.1 publishes anything. M10.1d7 and M10.1d8 do the code side, and catch up with the 21 design-system commits since the pin. | |
| ADR-199: Neer’s 2026-10-07 public name: FusionSpace HPR, on every product and package | the suite’s public name is FusionSpace HPR, and each product is “FusionSpace HPR ·” and its role: Sim, Analyzer, Competition Kit, Motor Designer, Recovery Designer, Avionics, with the app and its store listing called FusionSpace HPR. Packages carry the brand: PyPI fusionspace-hpr imported as fusionspace.hpr, crates fusionspace-hpr and fusionspace-hpr-*, npm @fusionspace/hpr. The command stays hpr, and its help, version and banner open with FusionSpace HPR. Stamps read FusionSpace HPR 0.1.0 · FS-ACHERNAR · SW · TOOL 001, and files stamped by hpr-sim still read. The docs move to hpr.fusionspace.co. M10.1d9 renames everything before release 0.1 publishes, because a published name is permanent. Star names stay internal codes. | |
| ADR-200: The separated parts’ warnings | M10.1d5: #179 warns on every flight with a body aft of a stage boundary flying on its own (a booster, at any speed); #354 on every flight with a body that starts its own flight with nothing open, a device opening at that same instant counting as open. Both read the flight’s bodies, so a drag of the flight’s own keeps them. | |
| ADR-201: The unknown signs | M10.1d6: of the seven issues of unknown sign, #104, #360 and #361 print no wrong number (the first is never printed, the other two are refused), and #8, #106, #213 and #219 err either way by case, so each warns, as a new flight kind: a near-calm wind level that turns, a body part’s damping station inside the supersonic join, a single pod off the axis, and a center of gravity more than 1e-9 m off the axis. | |
| ADR-202: The release files: glibc floor, license copies and a paced publish | #372: the Linux archive and wheel are built with Zig for glibc 2.17 (manylinux2014), checked by objdump and smoke-tested inside a pinned manylinux2014 image; each publishable crate holds byte-identical copies of both licenses, tested; crates go up one at a time through scripts/release/publish-crates.sh, paced to crates.io’s limit on new names and resumable. Amends ADR-187 §4. | |
| ADR-203: The FusionSpace HPR packages | M10.1d9: the 14 published crates are fusionspace-hpr and fusionspace-hpr-*, keeping their Rust library names (hpr, hpr_core, …); the Python distribution is fusionspace-hpr, imported as fusionspace.hpr from an implicit fusionspace namespace; stamps, --version, --help, the site and README titles, the User-Agent, cache folders, release title and archives say FusionSpace HPR; a hpr-sim stamp of either designation still reads. | |
| ADR-204: The no-clipping checks | M0.7a is split in five: the no-clipping checks first (M0.7a1), then the format with the trust guide, then stability, flutter and drag through Mach 1, one guide each. Three checks enforce Neer’s rule that nothing is clipped: xtask figures holds every SVG to its viewBox and its clips, with text measured in the widest of a set of system fonts character by character; the same check fails text over text; xtask site loads every guide page in headless Chrome at each width from 320 to 1,920 px and fails sideways scroll, text past the left or right edge or cut by its box, and text over text. The first run found four real clips, each fixed by layout. | |
| ADR-205: Neer’s 2026-10-08 sweep: one name and one design on every surface, checked by a tool | M10.1d9 renamed the packages, stamps and titles, but the words around them still say hpr-sim: 242 times in 35 of the site’s rendered pages, 113 in the crates, 5 in the README, and in every package’s license, notice and crate descriptions. M0.9a renames them by ADR-199’s rules and adds cargo xtask names, which fails on hpr-sim, or a bare hpr naming the product in prose, outside a narrow allowlist whose entries each give their reason and must match. M0.9b audits every shipped surface against the pinned design system; each rule that applies is met and checked, or has an issue. M0.9a lands before release 0.1 publishes, because a published version’s README and crate docs never change. | |
| ADR-206: The name check in two steps: the packages’ text, then the site | M0.9a is split. M0.9a1 builds cargo xtask names with both of ADR-205’s rules, and holds every surface ADR-205 §1 lists to it except the site’s pages: the text that ships inside a published package (README, crate texts, Python package, schemas, licenses, notices, CHANGELOG) and the banners, plus the landing page, whose first paragraph now names the suite. M0.9a2 adds the pages SUMMARY.md renders and the records page, about 2,300 more mentions. Release 0.1 waits for M0.9a1 only, since a published version’s package text is fixed and the site’s is not. Code compiled only for tests ships nothing and is not checked; a string literal’s hpr is the command when a subcommand, a flag or a placeholder follows it. | |
| ADR-207: The name check on the site’s pages | M0.9a2 holds every page SUMMARY.md renders, and SUMMARY.md itself, to cargo xtask names. About 2,280 mentions were rewritten: comparisons and tables say “HPR Sim”, other prose “the simulator” or “this project”, the command and library hpr in code. Two names keep the old name by rule: a decision record’s file name and the flight engine’s folder in a path, crates/hpr-sim/. On the records page, a decision record’s row inherits the allowance of the record its first cell’s [adr-NNN] link names, and nothing else does. 15 entries keep the site’s anchors, stamps and history, and 73 records up to ADR-205 are allowed whole for their rows. 16 headings that said hpr were rewritten, 15 of them with new anchors. | |
| ADR-208: The design audit: 112 sections against what ships, and three increments to close it | docs/research/design-conformance.md rows all 112 ## sections of the FusionSpace product system’s 14 product/ files at the pinned commit f45454f. 64 sections sit in the eight files for surfaces shipping today. Of those, 8 are met (5 held by named tests, 3 by review), 49 are not met, 3 wait for a later surface and 4 govern nothing the project ships. The 49 gaps are 11 issues, fixed by three new increments: M0.9c (command line), M0.9d (site look) and M0.9e (words). xtask/src/conformance.rs fails on a missing section, a moved pin, a dead test or a closed milestone. Release 0.1 doesn’t wait for the audit (ADR-205 §3), but review.md’s Before release lists (ADR-164 §5) are not all met. | |
| ADR-209: Neer’s 2026-10-08 standard: the best on the market, measured, for every product | Every product aims to be the best available: never worse than the best comparable tool on any axis, decisively better on the two or three its users care most about, with at least one capability no other tool has. A generated scoreboard ratchets, so a release can’t make a number worse without an ADR (M0.10). Accuracy is judged on held-out flights, predictions recorded first (M2.7), and uncertainty on whether ranges hold as often as they say (M2.8). Release 0.3 needs held-out mean absolute apogee error below OpenRocket’s, absolute bias within 3%, and 50% and 90% ranges that hold as often as claimed, or, only once the accuracy campaign ends by its stop rule, an ADR with the miss. | |
| ADR-210: US units in brackets on the command line; no units switch and SI exports until the app | hpr sim, hpr mc, hpr motors show and the plot give US units in brackets after the SI value, in their note: and warning: lines too: feet and feet per second for heights and speeds, mph for wind, inches for CG, CP and motor size, ounces or pounds for masses. hpr motors show gives the class’s impulse range in the standards’ written form, the nominal thrust beside the measured one where they differ, and the propellant’s name where the catalog has it. The command line gets no --units switch, and the CSV and JSON exports stay SI, until the app’s units control (M9.1). Other readouts that still print SI alone are #392. | |
| ADR-211: How far to trust a result: one note, from the largest comparison with real flights | hpr sim and hpr mc mark their figures as simulated and end with a note, How far to trust it: the kind of figure, what its apogee was checked against, and what to rely on instead. The numbers are the committed report’s, when written on 55 logged flights of fliers’ own designs (53 since the recheck of ADR-238: 8.7% above, 26 within 10%, 13 low), the largest and least flattering comparison with real flights: the simulated apogee averaged 9.8% above the logged height climbed, within 10% on 27, low on 14 by at most 20%. A test holds each to the report. The plot ends with the same note; --json carries it as trust, beside kind: "simulated". | |
| ADR-212: Measure against OpenRocket’s newest release, not only 24.12 | OpenRocket’s development branch has merged changes since 24.12 that can move its apogees; two others, a powered base-drag correction and thrust corrected for air pressure, apply only when a nozzle exit diameter is entered (the default, 0, applies neither). Release 0.3’s target, held-out error below OpenRocket’s, would be judged against a version flyers are about to leave, so the comparison follows OpenRocket’s releases. M2.3c3 flies the private collection and the public comparison sets on OpenRocket’s newest release after 24.12 beside 24.12, each version named. Release 0.3 (M10.3) then needs HPR Sim’s held-out error below 24.12’s and below that of any OpenRocket release published before M2.7 is met; with none, 24.12’s alone. Nothing is built from OpenRocket’s source. | |
| ADR-213: US units and a trust note on every readout; M0.9c4 split in four | hpr weather, hpr motors list, search and fetch, and hpr analyze give US units in brackets after the SI, as hpr sim does: a table’s heading names both units (m MSL (ft)), and each cell gives the US figure in brackets after the SI one. hpr weather, hpr analyze and hpr motors show end with the three-part note hpr sim has, and --json carries it as trust, beside a kind with four new values: measured, forecast, reanalysis and copied. Each note says “not yet checked” where nothing has compared its figures with a measurement of what they stand for; the ERA5 note quotes the one comparison with real flights committed for a weather source. | |
| ADR-214: Provenance on the exports: the catalog’s date, the trust note, units in brackets, ASCII JSON | hpr sim --export’s JSON recording, the .meta.json sidecar beside a CSV and hpr mc --export’s sidecar carry the bundled motor catalog’s as-of date (catalog_as_of) and the How far to trust it note as --json has it (kind, trust). hpr sim and hpr mc say “from the bundled catalog, as of 2026-09-17” beside a motor taken from it, and --json gives the date as the source’s as_of. A CSV header gives each column in words with its unit in brackets, time [s], not the time_s the other formats keep. Every JSON document hpr writes, and the library’s JSON and GeoJSON, is ASCII: other characters, the designation’s middle dots among them, are \u escapes. | |
| ADR-215: Errors that name what was typed, and numbers read as typed; M0.9c6 split in two | Every numeric option of hpr reads a number as typed: spaces trimmed, a comma read only as a thousands separator between groups of three digits (1,280 is 1,280, and a note: line says --elevation 1,280 read as 1280 m), any other comma refused with a question (is 3,9 meant as 3.9?), a non-number refused with what a number looks like. hpr sim and hpr mc refuse a launch option the library wouldn’t fly with its name, value and unit, before the library does. hpr motors show with an unknown name says what HPR Sim’s cache of ThrustCurve.org holds. A refusal from inside a flight still has the library’s words and no next step (#405, M0.9c9). | |
| ADR-216: The plot’s type and spacing on the scale, numbers kept with their units; M0.9c7 split in three | The hpr sim --plot figure draws every line at the 12 px label size, balloon numerals included, and its title at the 20 px, weight 600 subtitle size; its caption, balloon rows, event table and indents step on the 4 px scale (8, 16, 24 and 32 px); the time axis is titled at its right end; and a number and its unit are joined by a no-break space in the caption, the notes and the balloons’ tooltips. Each is held by a plot test. Colliding balloons on a leader, banking, a title block and the CSV are M0.9c12; the site’s figure width and the site’s US units (#400) are M0.9c13, both queued after M0.9c9. | |
| ADR-217: Neer’s 2026-10-09 plan: fusionspace.co rebuilt from the ground up | fusionspace.co, FusionSpace’s front page, is rebuilt from the ground up as FS · SITE 001, like the old web tools (M9.6) but sooner: M9.8, queued after the simulator’s guide (M0.8a) so the page can send people to it. It presents FusionSpace and its projects, FusionSpace HPR’s products first, each with its status, its guide, docs and latest release, and the old tools until M9.6 replaces them. It follows fusionspace-design’s web rules, passes the no-clipping checks at every width in both themes, makes no claim of “better” without a committed comparison (ADR-209), and lives in its own public repository, clean of tooling traces from its first commit. Pointing the domain at it is the maintainer’s step. | |
| ADR-218: The plot’s balloons on leaders, banked panels, title block and data file | the hpr sim --plot figure sets its balloons in one row, each that would collide stepped right along a short leader, growing for three-digit numerals; each panel’s height is banked to 45° by Cleveland’s length-weighted average orientation, between 120 and 360 px; the figure ends in an ISO 7200-style title block; and --plot f.svg writes the numbers it draws to f.plot.csv, with a f.plot.meta.json sidecar. Each is held by a test that fails without it. | |
| ADR-219: Figures at their size on the site, US units in the guides’ prose; M0.9c13 split | A figure on the site may reach past the 750 px prose column, up to the product system’s 1,120 px content width, and is shown at its size wherever that holds it; in a narrower window it shrinks and mdBook’s zoom shows it at its size. cargo xtask site’s page check fails a figure shown smaller than drawn with room for it, or without a zoom. Every height, distance and speed in the guides’ prose and tables gives its US units in brackets after the SI, 1,400 m (4,593 ft), and a site check fails one in SI alone or with a bracket that isn’t its conversion. The model, file format and records pages follow in M0.9c16, with millimeters. | |
| ADR-220: The margin bar tightened to 0.2 calibres, M1.14 held to Release 0.3’s target | The bar a stability margin or a center of mass is judged by, against OpenRocket, drops from 0.5 to 0.2 calibers. Every difference measured on both comparison sets but one is within 0.111 calibers, so the old bar let the worst agreement get four times worse with no row changing its standing; the new one catches a doubling. No row changes its standing: margins within it on 52 of 53 public flights and 35 of 35 private, centers of mass on 54 of 54 and 35 of 35. M1.14 now also needs its error on the private flight collection below OpenRocket’s, 24.12’s and its newest release’s, with its bias within 3%. | |
| ADR-221: The site’s defaults split: what the screen’s stylesheets draw first | #383 lists seven classes of mdBook default the product system’s theme doesn’t reach: colors, shape, motion, icons, the head’s metas and accessibility, fonts, and print. M0.9d2 now covers the first three as mdBook’s stylesheets draw them on screen, each held by xtask site’s page check reading every element’s computed style in light and navy and with reduced motion set. The new M0.9d4 keeps the old done-when whole (#383 closed, every class held), after M0.9d3, and takes the rest: icons, metas and accessibility, fonts, print (its link color included), and the smooth scroll mdBook’s script asks for, which no stylesheet can turn off. | |
| ADR-222: Six platforms, each tested on every pull request | CI’s per-platform jobs (the tests, the examples, the Python package and the validation cases) and the release’s archives and wheels now run on six platforms: Linux, macOS and Windows, each on x86-64 and on 64-bit ARM. Each runs natively on its own CPU, and a script fails the job if the toolchain would build for another one. Intel Macs are tested on GitHub’s last Intel image until it retires (fall 2027), then under Rosetta. Windows on ARM tests the Python package from 3.11, its oldest CPython. Static Linux builds, 32-bit ARM, package managers and math that rounds the same everywhere are follow-ups. | |
| ADR-223: The page anatomy split: the page’s frame first | #384 lists eight parts of the product system’s page that the site doesn’t draw. M0.9d3 now covers the frame every page shares: text on the system’s type scale (tabular figures in Archivo, navigation in Cascadia Mono 14 px, the current page underlined 2 px), prose at most 68 characters a line, and gutters of 16 px on a phone and 32 px from 720 px, each held by xtask site’s page check at every width. The new M0.9d5 keeps the old done-when whole (#384 closed, every rule held), after M0.9d4, and takes what changes each page’s markup: title blocks, sheets, the intro, the system’s notes, and every page opening with how far to trust it. | |
| ADR-224: The site’s defaults split again: the head, the keyboard and forced colors first | M0.9d4 now covers what the stylesheets, the head and a script of the site’s own can fix without changing mdBook’s page template: color-scheme and the Paper and Void theme-color metas, the 2 px Ion focus ring, forced colors, scroll-padding-top under the sticky bar, contrast measured, the system’s fonts.css with its fallback faces in every stack, and no smooth scroll, each failing xtask site or a site test when it comes back. The new M0.9d6 keeps the old done-when whole (#383 closed, every class held), adds #443 (Core Web Vitals measured), and takes what needs the template or a print reading: the system’s icons for Font Awesome’s, the favicon, one h1 a page, and print. | |
| ADR-225: The page anatomy split again: the notes first | M0.9d5 now covers one of #384’s six parts: every quote block a page writes is drawn as the product system’s note (.fs-note). Pages write Markdown GitHub renders: a trust note opening with **How far to trust it.**, or a GitHub alert, [!NOTE], [!CAUTION] or [!WARNING]. After mdBook builds the site, cargo xtask site rewrites each as the system’s specimen writes a note, and fails any other quote block or any note whose signal word, strip, fill or border is off the system’s. The new M0.9d7 takes the rest: title blocks, sheets, the intro and every page opening with how far to trust it. | |
| ADR-226: The gap to OpenRocket split by cause before M1.14 starts | on the 55 logged flights of the private collection, FusionSpace HPR’s apogees miss the logs by a mean absolute 13.96% and OpenRocket 24.12’s by 13.08%. Nothing says which of its inputs makes up the 0.88-point gap. M2.3c6 splits each flight’s difference into thrust, mass and drag parts before M1.14 tries to close it. | |
| ADR-227: Phones built on every pull request | CI builds the workspace for iPhone (aarch64-apple-ios), its simulator on Apple silicon (aarch64-apple-ios-sim) and 64-bit Android (aarch64-linux-android, Android 7.0 and later) on every pull request, so the mobile apps (M9.4) start from a core that already builds there. Build only: the tests run on phones when the apps do, and no phone archives or wheels are released. | |
| ADR-228: The site’s defaults split again: the chrome first | M0.9d6 now covers what the page’s chrome draws: after mdBook builds the site, cargo xtask site swaps each Font Awesome glyph for the system’s icon of the same meaning and makes the menu bar’s title a paragraph; a file check fails a glyph left, an icon not the system’s or a second h1; the favicon is the system’s; and the page check fails an icon off 16, 20 or 24 px and a selection off the action role at 22 %. The new M0.9d8 takes print and the Core Web Vitals. The field theme, which the audit counted under #383 but which is no mdBook default, moves to #452. | |
| ADR-229: The page anatomy split again: the frame first | M0.9d7 now covers the page’s frame: after mdBook builds the site, cargo xtask site makes the menu bar a header that draws the system’s one-color horizontal lockup, keeps the sidebar open with no menu button from 720 px, and ends every page with the system’s title block in a footer, its entries written once at the end of the landing page’s source. The page check fails a lockup off 24 px or the ink role or without its clear space, a menu button from 720 px, a sidebar reachable while put away (or not while shown), and a title block off the system’s shape or not last. The new M0.9d9 takes the intro, the sheets and the trust openings. | |
| ADR-230: The site’s defaults split again: print and the text marks first | M0.9d8 now covers print and the marks: the build draws the sidebar’s fold toggle as the system’s chevron, the theme menu underlines the chosen theme, a heading jumped to takes no mark, and the site prints in the light theme’s values with navigation hidden, link addresses shown and rows, notes and the title block kept whole. The page check fails a text mark drawn as an icon, and reads every page with its print rules applied at the run’s width nearest a sheet of paper (720 px), in both themes. The new M0.9d10 keeps the old done-when whole (#383 and #443 closed) and takes the Core Web Vitals. | |
| ADR-231: The page anatomy split again: the drawing first | M0.9d9 now covers what the build can draw on every page: after mdBook builds the site, cargo xtask site opens each page’s intro with the designation tag, makes each h2 section a sheet with SHEET n / N in its rail under a 2 px ink rule, and turns mdBook’s six-theme menu into the system’s segmented switch, in the header from 960 px and at the top of the sidebar below. Checks fail a page without them, a heading that skips a level, or any drawn off the system’s. The new M0.9d11 keeps the old done-when whole (#384 closed, every rule held) and takes the intro’s chip and lead, the sheet count and the trust openings. | |
| ADR-232: The pages’ vitals, measured as a phone on slow 4G | cargo xtask site now loads every page of the guide cold in headless Chrome as Lighthouse’s mobile preset (a 412 px phone, 562.5 ms on every request, 1.5 Mbit/s down) with the CPU slowed to a phone’s by Lighthouse’s BenchmarkIndex, measures LCP, CLS and INP, and fails a page over 2.5 s, 0.1 or 200 ms (the median of three loads for a page over). To pass, every page links one stylesheet and preloads four fonts, two more than the product system’s limit; the theme switch is placed before the first paint; and the print page shows a cover on screen. The page check now also fails anything fixed to the window on paper. | |
| ADR-233: The pages’ own words split again: the intro’s chip and lead first | M0.9d11 now covers the intro: after mdBook builds the site, cargo xtask site sets the title block’s status (IN PREPARATION or RELEASED) in the system’s chip beside the designation tag, and makes the paragraph under every page’s title its lead, which a file check holds to one sentence of at most 25 words; the page check fails a chip or a lead drawn off the system’s. The title block’s version and status, which still read “not yet released” after 0.1.0 shipped on 2026-10-08, now say what the site describes. The new M0.9d12 keeps the old done-when whole (#384 closed, every rule held) and takes the sheets and the trust openings. | |
| ADR-234: The pages’ sheets and trust split again: the sheet count’s check first | M0.9d12 now covers the sheet count’s check: cargo xtask site and a site test count each page’s ## sections, its sheets, and fail a page with fewer than two or more than six, except the 38 pages over six on a list in xtask/src/site/sheets.rs, held exact: a listed page at six or fewer fails until it comes off, and so does a listed page the summary doesn’t hold. The glossary, 187 sections, one a term, now groups its terms in six by first letter, each term a ### heading with the same anchor. The new M0.9d13 keeps the old done-when whole (#384 closed, every rule held) and takes the 38 pages’ grouping and the trust openings. | |
| ADR-235: Every page in two to six sheets and opening with how far to trust it | The 38 pages that had more than six ## sections are grouped into two to six sheets, so the check fails any page outside that range and the list of exceptions is gone. Every page but a model page now holds a trust note, a quote block opening with **How far to trust it.**, between its title’s lead and its first sheet; a model page opens with In short instead. cargo xtask site and a site test fail a page that doesn’t. | |
| ADR-236: Supersonic flights from published comparisons, after Release 0.3 | no public real flight FusionSpace HPR is scored against passes Mach 1, and the private collection’s report doesn’t split its errors by speed. RASAero II’s author publishes 36 flights with measured apogees, and says the designs of most ship with RASAero II. M2.3c7 flies those designs, scores them by Mach band beside RASAero II’s own published errors, and splits the collection’s errors at Mach 1. | |
| ADR-237: One fixture repository: the pin, the labels and a file two packages install | The reference lock pins only the private flight collection, at its master merge commit 7268bcd0, with a second manifest pin for the design library copied inside it. The two older private repositories are read from its byte-exact imported/ copies, and the survey counts the library under that path. The OpenRocket round-trip report was flown again because its record predated a writer change. The Python environment check now accepts a file two packages install when it holds either package’s copy. | |
| ADR-238: The corpus rechecked against the collection’s catalog | Each of the 121 flags the private collection’s catalog raised on 68 of the 83 flights the fixture report draws on was settled against the flight’s log and sources. Four flights changed in the manifest: one launch day, one logged apogee, and two flights left out; every entry also records the tier the catalog proposes. HPR Sim’s mean apogee error over the logs moved from +9.83% (55 flights) to +8.73% (53), OpenRocket’s from +9.00% to +7.79%, with nothing in either simulator changed. Leaving out one flight that tumbled through its climb is more than the whole move. The report adds the errors without the flights the catalog proposes below tier A: +7.84% over 44. | |
| ADR-239: The words to the design: spelling, minus signs, number columns and the READMEs | xtask spelling reads the British forms the design audit found and the others a survey of the pages turned up, and the project now writes them in US English, renamed code names included; the site check fails a hyphen-minus written for a minus sign and a table column of numbers that isn’t right-aligned; the READMEs follow writing.md’s order with a status word and the version, held by a test. What #386 listed beyond M0.9e’s done when moves to #476 and a new increment, M0.9f, before release 0.2. | |
| ADR-240: The scoreboard: its cells, its ratchet, and the cells no milestone measured | cargo xtask scoreboard writes validation/reports/scoreboard.{json,md}: HPR Sim against OpenRocket 24.12 and RocketPy 1.13.0 on accuracy, bias, honest uncertainty, speed, round trips, features and steps to a first answer, each number read by key from a committed report and kept as printed, each unmeasured cell naming the open milestone that measures it. A check in the xtask tests, and in CI against main’s committed scoreboard, fails when one of HPR Sim’s numbers prints worse, counts fewer flights or designs, or a measured cell is no longer measured, unless an accepted ADR names that cell and the next release in a - **Scoreboard:** line. A new milestone, M2.9, measures the other tools’ cells that no milestone did, and every tool’s speed. | |
| ADR-241: Steps to a first answer: what a step is, and a tool that can’t | The scoreboard counts the steps to open a design’s .ork file, fly it once and see its apogee, and get its landing spread, in four rows: commands, script lines, clicks and typed entries. HPR Sim’s commands and Python lines are files a test runs; OpenRocket’s and RocketPy’s steps come from their documentation, each step citing its page. A way in that a tool lacks, or a task it can’t do that way, is a cell that says can’t, with its source. HPR Sim takes 2 commands or 9 script lines; OpenRocket 24.12 opens and flies in 7 clicks but has no Monte Carlo; RocketPy 1.13.0 reads no .ork file. | |
| ADR-242: The guides’ format and the trust guide, every number read from a report | The first guide, How far to trust a simulation, is a top-level page in a new Rocketry explained part of the site. cargo xtask guides holds every number in a guide’s prose to a committed report: a quote fills its holes from the report’s JSON, a page must hold it word for word, and any other number in the prose fails. The guide’s figure, HPR Sim’s apogee misses on 53 logged flights by bin, is drawn from the same report, the band within 10% shaded and the low side marked as the one that flatters a ceiling, tied to a new test of a miss’s sign. | |
| ADR-243: The stability guide: the center of pressure against a wind tunnel, and the guide rocket’s own report | The second guide, Stability in flight, explains how Mach number and angle of attack move the center of pressure. Its numbers come from two committed files: the existing comparison with NASA’s Arcas Robin wind-tunnel tests, and a new report of the guide rocket’s center of pressure, which cargo xtask guides writes and fails when stale. The figure draws the tunnel’s readings against HPR Sim’s line, and marks each speed where HPR Sim’s center of pressure sits aft of the tunnel’s: a margin that reads high, tied to a new test of that sign. The angle section marks no side, since nothing measured checks the whole rocket at an angle. | |
| ADR-244: The flutter guide: the guide rocket’s fins read two ways, and the halved constant marked | The third guide, When fins flutter, explains what flutter is, what Martin’s criterion’s flutter speed depends on, and what its two readings (the ratio of the flutter speed to the airspeed at max q, and Martin’s own chart) say about the guides’ rocket. Its numbers come from a new report, guide-rocket-flutter.json, which cargo xtask guides writes from the design and its flights through hpr sim --json and fails when stale. The figure draws the rocket’s flutter speed against its fins’ thickness, with Martin’s band shaded and the halved constant of Peak of Flight #291 and #411 marked in the caution color: a flutter speed that reads high, tied to a new test in hpr_sim::flutter of that direction. | |
| ADR-245: The drag guide: the guide rocket’s drag through the speed of sound, the tunnel’s high reading marked, and the maintainer’s read apart | The fourth guide, Drag through the speed of sound, explains the drag’s three parts, how HPR Sim’s forebody drag compares with NASA’s Arcas Robin wind tunnel, and which error flatters. Its numbers come from a new report, guide-rocket-drag.json, which cargo xtask guides writes and fails when stale. The figure draws the tunnel’s forebody drag against HPR Sim’s with every speed where HPR Sim’s reads high marked: an apogee that reads low, tied to a new hpr_sim test of that direction. The guide also quotes the logged flights’ mean apogee miss, which leans the other way. M0.7a5’s maintainer-read clause moves word for word to a new increment, M0.7a6, marked blocked on him. | |
| ADR-246: Student Launch by requirement number, and the other tools’ known defects | M6.3’s NASA Student Launch preset takes the College/University division’s 14 numeric limits from the 2027 handbook, each by requirement number and at both ballast settings, with a defined second method for descent time and landing energy beside the simulation, and each check’s error side pinned. M2.9’s cells for the other tools name the release they came from and each open defect that moves that tool’s apogee by more than 0.5%, flown with the public fix too. | |
| ADR-247: The simulator’s guide in four increments, its terminal figures drawn from the CLI’s own runs, and its tour ending on the median public flight | M0.8a, the simulator’s guide, splits four ways, its own done when unchanged: the landing page and a tour of the command line (M0.8a1), the same flight from Python (M0.8a2), the Compared with section ADR-209 §8 asks for (M0.8a3), and the maintainer’s read (M0.8a4, blocked on the maintainer). The guide is a new Product guides part: a landing page, HPR Sim, and A tour of HPR Sim, both held to the guides’ number check. The tour’s pictures are terminal figures: cargo xtask cli draws each from the same run as an example on the page, and --check fails a stale one. The tour ends on the public flight with the median unsigned apogee miss, picked by rule in code. | |
| ADR-248: The simulator’s comparison: a record of capabilities read from each tool’s documentation, written into the guide and counted on the scoreboard | The simulator’s guide gets a third page, Compared with other simulators. Its capability table is written by cargo xtask guides from a committed record, validation/features/simulator.toml, in which each cell of another tool names the documentation page that shows it, the release and the date it was read, and a note for every partly and no; each of HPR Sim’s cells names the page of the site that covers it, or the open milestone that brings it. The reader refuses a cell without its page, a no without its note. The tools are OpenRocket, RocketPy and RASAero II. Only full yes cells count, and the scoreboard’s features.count row counts them for its three tools. | |
| ADR-249: fusionspace.co in two increments, a static page in its own repository, checked in Chrome at every width | M9.8, fusionspace.co rebuilt, splits in two, its own done when unchanged: the page, its checks and the steps that move the domain (M9.8a), and the maintainer’s use (M9.8b, blocked on the maintainer). The page lives in the new public repository nrdptel/fusionspace-site. It is one static page in plain HTML and CSS with one script, on Cloudflare Pages, with no build step. A check written for it drives Chrome over the DevTools protocol from Node, with no packages. It lays each page out at the 41 widths from 320 to 1,920 px in the light, dark and field themes. It fails on anything cut off, scrolled, past an edge, overlapping or covered, and on a font or browser error. | |
| ADR-250: The measure as a median and a maximum, a reading scale that grows with the window, and the column flush left, from the product system’s Rev B | Prose on the site stopped at 24 em, about 384 px, so a desktop window was mostly empty. The product system’s Rev B states the measure as a median line of 60 to 75 characters and none over 80, set as 29.5 em of the text; grows the type scale with the window on a reading page (16 to 18 px body between 1,024 and 1,600 px); sets the column flush left beside the sidebar up to 1,120 px; and ships the code that measures these rules, which the site’s page check now runs unchanged. | |
| ADR-251: Flight log importers in two increments: the record every reader fills, a survey of the sample logs pinned by digest, and the PerfectFlite, AltOS and Raven readers first | The sample logs under refs/ number about 1,000 distinct files in some 20 layouts, too many for one increment. M7.1a builds the flight record every reader fills (every column a channel on its own clock, the logger’s events), a survey that reads every sample and writes a committed report of counts and anonymized ids, and readers for the PerfectFlite text exports, AltOS CSV and the Raven’s FIP CSV; M7.1b reads the rest. A private or unlicensed log is pinned by a digest of what was read from it, never by a snapshot of its values. | |
| ADR-252: The sidebar put away at every width, and page arrows that name their pages, from the product system’s Rev D | A review of the site found two things on a desktop window. The sidebar could be resized but not put away, and the page arrows were easy to miss: small icons at the window’s sides, at the foot of the page, far from the centered column. The product system’s Rev D lets a docs site’s table of contents be put away and brought back at every width, with the menu button or by dragging its edge to the window’s side, and keeps the choice from page to page. It puts the page arrows under the text, inside the column, as bordered buttons that name their pages. | |
| ADR-253: M7.1b in two: the RRC3’s, Eggtimer’s and Blue Raven’s CSV exports first, each unit a header leaves out decided from the file or stated as assumed | M7.1b listed every layout M7.1a left, about 30 families, too many for one increment. It now reads the three CSV exports with the most sample files among them, the RRC3’s, Eggtimer’s and the Blue Raven’s (173 distinct files), into the record M7.1a built; M7.1c reads the rest. A unit a header doesn’t name is decided from the file, such as an RRC3’s altitude from its pressure, or taken from the maker’s manual, and either way stated in a note the survey counts; a Blue Raven’s high-rate file, which holds no altitude, reads with an empty primary track. | |
| ADR-254: M7.1c in two: GPS tracks first (Featherweight’s GPS CSV, KML and NMEA), read with an empty primary track and each point on the clock the file gives it | M7.1c named about 27 families of sample logs, too many for one increment. M7.1c1 reads the three that record a GPS receiver’s track: Featherweight’s GPS tracker and ground-station CSV, KML, and NMEA 0183, 95 distinct sample files. None has a barometer, so each reads with an empty primary track and every column a channel. A point’s time is the one the file gives it, from a column, a sentence, a when or the comment a writer puts beside each point; a KML path that states no time keeps its points with their times as gaps. A KML altitude is in meters, as the KML standard sets, unless the file’s writer is known to write another unit. | |
ADR-255: M7.1c2 in two: four text loggers first (AltimeterCloud, Entacore AIM, PerfectFlite’s .pfa, an Eggtimer TRS’s terminal text), the rest to M7.1c3 | After M7.1c1, 26 families of sample logs, 503 files, still had no reader: binary downloads, spreadsheets, companion summaries, teams’ own CSV and text, and four text layouts a single maker writes. M7.1c2 now reads those four, 54 files: AltimeterCloud’s CSV and Entacore AIM’s, each with the generic csv family’s files in its layout moved to it by id, PerfectFlite’s .pfa and an Eggtimer TRS’s terminal text. M7.1c3 keeps the rest and the parent’s done when, in a planned order: club and app text layouts, raw downloads checked against their makers’ exports, AltOS’s raw files and the RDAS’s, then containers, summaries and the column mapper. | |
| ADR-256: M7.1c3 in two: three self-checking layouts first (AerospaceNU’s SillyGoose logs, Silicdyne Fluctus’s CSV, the ARTS2’s interpreted data), the rest to M7.1c4 | After M7.1c2, 22 families of sample logs, 449 files, still had no reader. ADR-255 ordered what was left: club and app text layouts first. A survey of those found three layouts whose units each file can settle, from its header, its maker’s manual or a check on its own values: AerospaceNU’s SillyGoose flight computer’s logs (14 files), Silicdyne Fluctus’s CSV (6, filed as generic CSV) and the ARTS2’s interpreted data (4, filed as generic CSV). M7.1c3 now reads those 24. The others in that group need a decision the files can’t make yet, and stay in M7.1c4 with the parent’s done when. | |
| ADR-257: Calibrated intervals for the flight readings and fits, and the post-flight comparison | M7.2’s “within the stated error” gains, and M7.3’s “within tolerance” becomes, one test: on at least 1,000 synthetic flights on fixed seeds, each stated 90% interval must miss on each side about 5% of the time and hold the truth about 90%, judged by 99.9% Clopper-Pearson bands, and the test must fail when the intervals are narrowed, widened or shifted. M7.3 also reports, on the public logged flights and the collection, apogee predicted from the log up to burnout beside the forward simulation’s, which fills a new scoreboard row, and draws the predicted and logged flight under launch-day conditions in one command, the analysis NASA Student Launch asks for after a team’s flights. | |
ADR-258: M7.1c4 in two: AerospaceNU’s flight computer board, a phone app’s launch CSV and an Eggtimer’s RTF first, the rest to M7.1c5 | After M7.1c3, 23 families of sample logs, 425 files, still had no reader. M7.1c4 now reads the group ADR-256 left open over unit questions, 52 files: AerospaceNU’s flight computer board’s CSV (20), its ground station’s text (4), a phone app’s launch CSV (27), and the one Eggtimer download saved as RTF (#520); the other two RTF files, a radio telemetry stream, move to M7.1c5. It also makes one rule for every reader: a value that a unit conversion turns infinite is refused (#518). M7.1c5 keeps the rest and the parent’s done when. | |
ADR-259: M7.1c5 in two: the Raven’s .FIPa and the RRC3’s .rff raw downloads first, each checked against its maker’s export; the rest to M7.1c6 | After M7.1c4, 23 families of sample logs, 376 files, were left to M7.1c5, 374 of them read by no reader. M7.1c5 now reads the two raw downloads whose makers’ exports of the same flights sit beside them, 63 files: the Featherweight Raven’s .FIPa (57) and Missile Works’ RRC3 .rff (6). Each raw file with an export beside it must match that export in every sample of every channel the two share: all 55 such .FIPa files and the one such .rff match, 6,019,645 raw samples, with no value off by any step. The rest, ARTS2’s raw data and .odf, the RTx’s files and the families ADR-258 listed, moves to M7.1c6 with the parent’s done when. | |
| ADR-260: M7.1c6 in two: Featherweight’s summaries first, each checked against the file beside it; the rest to M7.1c7 | After M7.1c5, 21 families of sample logs, 312 files, were left to M7.1c6, 310 of them read by no reader. M7.1c6 now reads the Featherweight app’s summaries of a Blue Raven’s or a GPS tracker’s flight, 48 files: every row is kept as a figure, in SI only where the unit it writes is one its name allows, and each summary’s stated maximum and pad altitude are checked against the file of samples beside it. 31 files that aren’t flight logs are filed as such: Debrief’s made-up flights, which say so, teams’ checklists, a Blue Raven’s settings sheets and a flyer’s own program’s reading of a log. The rest goes to M7.1c7. | |
| ADR-261: M7.1c7 in two: zip archives and two readers’ variants first; the rest to M7.1c8 | After M7.1c6, 233 sample logs in 16 families were left to M7.1c7, 231 of them read by no reader. M7.1c7 now unpacks the 8 zip archives, in memory and within a bound, and reads each file inside as a file of its own: 19 files no other source holds, 11 of them a Blue Raven’s files and summaries. It reads PerfectFlite’s text export written with no header row (4 files) and a CSV export that names its temperature Temp (1), and a Blue Raven high-rate file with no date (1). It files 16 more files as not logs, and one hand-edited Blue Raven file as damaged. The rest goes to M7.1c8. | |
| ADR-262: M7.1c8 in two: the R-DAS’s raw text first; the rest to M7.1c9 | After M7.1c7, 209 sample logs were left to M7.1c8, in families that each need a decoder or the column mapper. The largest, 54 files, is one layout: the raw text AED Electronics’ R-DAS flight computer’s Windows software exports, a configuration summary and then a table of the converters’ counts. M7.1c8 now reads it. The file holds no calibration, so every count is kept as written and the record holds no altitude; the clock is held to the configuration’s stated rate. The rest goes to M7.1c9. | |
| ADR-263: M7.1c9 in two: AltOS telemetry first; the rest to M7.1c10 | After M7.1c8, 155 sample logs were left to M7.1c9. Two of them are AltOS radio telemetry, the .telem files AltosUI saves of the packets a TeleDongle hears, and Altus Metrum publishes their layout. M7.1c9 now reads them from that document, with every unit it converts held to a second check, and the rest goes to M7.1c10. The document’s pressure unit is contradicted by the files, which hold pascals, not tenths. | |
| ADR-264: Typeset equations, from the product system’s Rev E | The site’s equations were plain Unicode text, in code blocks and code spans, which reads like a formula typed into a chat. The maintainer asked for equations set as a textbook sets them. Pages now write LaTeX between dollar signs; an mdBook preprocessor in xtask turns each formula into MathML when the site builds, with the math-core converter (MIT, pure Rust); the browser draws it in New Computer Modern Math, the face of LaTeX’s textbooks, served from the site. No script runs and nothing loads from another server. A formula the converter can’t read fails the build, and the page check fails one wider than its box. | |
| ADR-265: M7.1c10 in two: AltOS raw downloads first; the rest to M7.1c11 | After M7.1c9, 153 sample logs were left to M7.1c10. Fourteen of them are AltOS’s .eeprom files, the board’s own log as AltosUI downloads it, and nine have AltosUI’s export of the same flight beside them. M7.1c10 now reads them, their layout worked out from the files and held to those exports, every unit converted resting on a sensor’s data sheet and a second check; the rest goes to M7.1c11. | |
| ADR-266: M7.1c11 in two: ARTS2’s raw data first; the rest to M7.1c12 | After M7.1c10, 137 sample logs were left to M7.1c11. Six of them are an Ozark Aerospace ARTS2’s raw data: three .odf files, as its software DataAnalyzer saves a flight, and three raw CSV exports of the same records, each flight with DataAnalyzer’s interpreted export and an AltOS board’s log beside it. M7.1c11 now reads them, the .odf in units from the calibration it carries, held to its sensors’ data sheets and to a climb check, and to the files beside it; the rest goes to M7.1c12. | |
| ADR-267: M7.1c12 in two: Missile Works’ RTx first; the rest to M7.1c13 | After M7.1c11, 131 sample logs were left unread. Fourteen are a Missile Works RTx GPS tracker’s: five .rtx files, as mDACS saves a download, and nine CSV and text exports, eight of them beside an .rtx with the KML export of the same fixes. M7.1c12 now reads them, the .rtx’s words decoded from the files and held to every export beside them; the rest goes to M7.1c13. | |
| ADR-268: M7.1c13 in two: tables read by their headers first; the rest to M7.1c14 | After M7.1c12, 117 sample logs were left unread, most of them tables from teams’ own flight computers and scripts, each in its own words. Thirty-one of them, among them a Blue Raven file a person edited, name their units in their headers; M7.1c13 now reads such a table by what its header states, holds each unit to the column’s name and values, and takes a caller’s column mapping for the rest; spreadsheets and the other layouts go to M7.1c14. | |
| ADR-269: M7.1c14 in two: Excel workbooks first; the rest to M7.1c15 | After M7.1c13, 87 sample logs were left unread. The largest group one change can read is the 23 .xlsx workbooks: written out sheet by sheet, each cell as the workbook stores it, 16 of them read through the readers that exist; M7.1c14 now reads them, every cell held to an independent reader, and the rest goes to M7.1c15. | |
| ADR-270: M7.1c15 in two: EuRoC exports and mappings a publisher states first; the rest to M7.1c16 | After M7.1c14, 68 sample logs were left unread, in 19 layouts, the largest 7 files. Nine of them need little new code: three exports of known loggers saved by a European locale’s spreadsheet, and six tables whose publisher, RocketPy, states each column’s meaning and unit. M7.1c15 now reads them, refuses an Eggtimer file whose filtered altitude or clock shows its decimal points were lost, and leaves the rest to M7.1c16. | |
| ADR-271: M7.1c16 in two: binary records by a stated layout first; the rest to M7.1c17 | After M7.1c15, 59 sample logs were left unread. Five of them are a team’s binary records with the table the team decoded from them beside each: three captures of a flight computer’s serial shell dumping its flash as base64, and two raw files of records end to end. M7.1c16 reads files like these by a record layout the caller states, the names from that table and the types found from the bytes and that table. All 931,875 fields of the 45,915 records written match the teams’ tables. The rest goes to M7.1c17. | |
| ADR-272: M7.1c17 in two: the Blue Raven’s USB download first; the rest to M7.1c18 | After M7.1c16, 54 sample logs were left unread. Two of them are a Blue Raven’s recording as its USB port downloads it to a terminal, one line a sample, each closed by a CRC, in a layout the maker’s manual describes. M7.1c17 reads these, keeping only the records whose CRC checks, each held to its stated length, and reads each field by the manual where the record holds what the manual lists. All 354,284 values of the 19,636 records read agree with the survey’s own decoding. A third file is filed as a flyer’s copy of a summary, not a log. The rest goes to M7.1c18. | |
| ADR-273: The 2026-10-15 review: OpenRocket’s supersonic ogive drag as a cause | OpenRocket’s issue #3391 (2026-10-14) reports that OpenRocket 24.12 gives a tangent-ogive nose almost no pressure drag above Mach 1: about 0.0007 against about 0.13 at Mach 1.5 by the method its own technical documentation describes. HPR Sim found the same gap on a supersonic flight in its collection (#222) and left open which code was right. M2.3c6 splits the apogee gap to OpenRocket into thrust, mass and drag. Its drag part must now give this term on its own line: a public probe sets the two codes’ nose pressure drag beside the published equivalent-cone value, and the collection’s flights past Mach 1 report how much of the gap the term accounts for, with its sign. | |
| ADR-274: M7.1c18 in six: a course’s Teensy logger first, then the five increments left | After M7.1c17, 51 sample logs were left unread, in five groups. This record plans all of them at once, in six increments, the easiest to check first. M7.1c18 reads the 8 files of a university course’s Teensy data logger, one sensor’s reading a line, in two layouts. Where a file states no unit, the unit is held to the physics the files must keep: on every one of 305,340 Alt lines, the barometer’s altitude follows its pressure by the BMP180’s formula to within 5.4 mm (0.21 in); the accelerometer reads 0.983 to 0.989 g on the pad; and the time to apogee is 0.90 to 1.14 times √(2h/g). The other 43 files go to M7.1c19 to M7.1c23. | |
| ADR-275: Neer’s 2026-10-14 plan: awareness and care on the sites | The docs site, and then fusionspace.co, get a thin banner under the page’s strip and a line in the footer: heritage and awareness months, health and mental health, accessibility, science and space days, and rocketry-safety reminders. One banner at a time, chosen in the reader’s browser by date from a table whose every row names its organizer’s page. A region-specific observance names its region, a solemn day stands alone, nothing looks up where the reader is, and with scripts off nothing shows. A help page lists checked crisis lines, as WHO’s guidance on suicide prevention asks. A second increment adds a code of conduct, a page on getting involved and a way to report a barrier to access. | |
| ADR-276: Neer’s 2026-10-16 plan: a flyer’s own logger and GPX tracks in the analyzer | Release 0.2, the flight analyzer, must read a flyer’s own altimeter or GPS tracker from the command line and Python, not only from Rust, and must read GPX tracks. M7.1d1 reads GPX 1.0 and 1.1; M7.1d2 lets hpr analyze and the Python package read a table by a column mapping and binary records by a record layout, as the library already does. | |
| ADR-277: A track’s own speed, held by its vertical speed before apogee | M7.1c22’s done when names a track’s own speed among the physical checks that hold a mapped table’s units. A track’s ground speed holds none: the 4 tracks’ medians spread 21.34 times. Its vertical speed does. In the 5 s before apogee a coasting rocket slows at g, plus a little drag, so a parabola fitted to a GPS track’s fixes there must slow at 0.6 to 5/3 g. An altitude in feet stated as meters reads 3.28 times too high. The club’s GPS track slows at 0.9925 g, so that part of the done when is met. | |
| ADR-278: An evidence register: what backs each claim, and an open issue until a real sample does | The docs say honestly when a reader, model or check rests on invented samples, an assumption or another program alone, but nothing tracks finding the real evidence later: of the 24 distinct gaps the site stated on 2026-10-17, 12 had no issue, roadmap entry or research topic, 8 of them flight-log readers. Milestone M2.10 adds validation/evidence.toml, one row per claim with the kind of evidence behind it and the kind wanted, and a check that fails when a page states such a gap without a row, or a row short of a real sample has no open needs-sample issue. A report counts the rows by kind on the site, with no combined score. | |
| ADR-279: The 2026-10-17 review: fin flutter held to measurement, and intervals by design | HPR Sim’s fin flutter check, a safety output, is tested only against Martin’s own worked examples, and nothing shows which way it errs on a fin someone else measured (the evidence register’s row G22). A published wind-tunnel test found five identical composite fins fluttering at 19.6–21.5 m/s (64–71 ft/s); on that fin HPR Sim’s flutter speed reads about 10.7 m/s (35 ft/s), on the safe side. M2.11 scores HPR Sim’s flutter readings against at least three distinct measured fins from at least two research groups and against an independent BSD-licensed calculator; it states the largest error on the flattering side and the range the cases cover, and adds a flutter row to the scoreboard. | |
| ADR-280: M7.2 in seven, the synthetic flights first | M7.2 is split in seven: M7.2a draws 2,200 synthetic flights on fixed seeds (a tuning set of 200 and two test sets of 1,000, the second flying a model reshaped in drag, wind shear and thrust), each with its truth and the log one of six simulated loggers would write, by cited noise terms; the readings on every logger, the rest of the readings, the smoother, the 90% intervals, two recordings and stages, and ghost files follow; the readings, the smoother and the intervals are checked on those flights. | |
| ADR-281: Readings on every logger: one height track, a pad its samples can vouch for, and a top that must be a coast’s | The readings (liftoff, apogee, the top speed, landing) now come from every logger that records a barometric altitude or a pressure, each within a bound its error stayed inside on the synthetic flights’ tuning set, logged at every rate from 500 to half a sample a second, at every step to 10 m (33 ft) or 100 Pa, and from cropped starts, or withheld with one of 23 named reasons. A GNSS track gives none. Three rules carry most of the weight (below). On the 1,058 records the sample logs hold, apogee is given on 593, liftoff on 554, the top speed on 354 and landing on 472, and every reason has a case. | |
| ADR-282: The project tests each UI milestone itself | No milestone waits on the maintainer’s use any more. A milestone that adds or changes something a user sees counts as done once its PR records the project’s own acceptance pass: user tasks written before the work and done end to end on the built product by a reviewer that didn’t build it, every screen captured at its real size and shape and checked for clipping, and a cold reader’s run through the guide. The app and the field kit also post a short recording for the maintainer to look at, which informs but never blocks. Turning off his sites, publishing, tags and finding M10.5’s outside flyers stay his. | |
| ADR-283: The rest of the readings: an axial accelerometer settled by three witnesses, burnout where the thrust’s fall ends, and the main found back from landing at the ground’s density | The flight-log readings now add the top acceleration, burnout, the flight time and the descent under each canopy, each within a bound its error stayed inside on the synthetic flights’ tuning set or withheld by name. The top acceleration comes from an accelerometer along the rocket’s axis only. Burnout is read from the thrust’s fall through zero (a floor without an accelerometer), and the main’s opening is found back from landing at the ground’s density (below). Of the 1,058 records the sample logs hold, the top acceleration is given on 161, burnout on 428, the drogue’s descent on 267 and the main’s on 459, and every new reason has a case. | |
| ADR-284: The maintainer’s own voice on every page | The project’s pages read as if they came off a template, not from a person. M0.14 rewrites what people read (the README, the docs site, fusionspace.co, the design system’s writing rules and README, hpr’s own messages and the repositories’ About text) in the maintainer’s plain voice, with a voice section in the writing guide and a cargo xtask voice check. Decision records, the archive and tools due to be replaced stay as they are. | |
| ADR-285: The rest of the site in nine increments, each held to the voice limits as it lands | The 71 site pages M0.14c covers hold 413,377 words, too many for one rewrite. They go in nine increments by the site’s sections. From the first, cargo xtask voice fails when a page M0.14 has rewritten goes over a voice limit or misses the guide’s sentence targets, so a page that passes stays passing while the rest are done. The last increment holds every site page, a new one included. | |
| ADR-286: The 2026-10-20 review: the export bar tightened | In the corpus, the only apogee differences OpenRocket shows between a design and HPR Sim’s export of it are OpenRocket’s own run-to-run spread, 0.00051% on the most sensitive configuration, while a probe that rounded every number to six decimals still passed the 0.5% bar, so the bar is tightened to 0.002% and the planning review places four new ideas. | |
| ADR-287: ThrustCurve.org’s motor records used as published facts | ThrustCurve.org’s motor records are published facts about motors anyone can buy, so the project uses them, from the site, its API or the site’s 2016 sample dump, with ThrustCurve.org’s credit; curve files marked public domain or with no license may be committed too, files marked “free usage” or “other (restricted)” are fetched only when a user asks, and every accuracy check stays. | |
| ADR-288: Every solid motor ships in the package | M5.7 will compile ThrustCurve.org’s solid-motor catalog into hpr-motor: every record, and every curve file HPR Sim reads but a restricted one, so no motor in the snapshot needs a fetch. Each file carries its check against its motor’s published figures. A motor’s default file passes where one does, and flying a failing file warns. hpr motors update adds newer motors and files when online. Until then, 32 motors come built in. | |
| ADR-289: The 2026-10-24 review: the RocketPy speed and apogee gates tightened | In the RocketPy comparisons flown on the same inputs, the burnout, largest, rail-exit and landing speeds agree within 0.056% and the apogees of the six flights with no written model difference within 0.113%, while RocketPy’s own solver moves them by at most 0.0032% and 0.00064%; a 3% gate was 53 times the largest speed difference, so they become 0.2% and 0.5%, and the planning review places four new ideas. | |
| ADR-290: The control abort’s 30° measured from the launch elevation, and TP-1353’s aileron points to Mach 2.96 | The airbrakes and roll surfaces go inert on an attitude more than 30° from the launch elevation, as the IREC student competition’s 2026 rule §7.3.1 words it, not 30° from vertical. M6.5’s supersonic tab check compares against NASA TP-1353’s tail-fin ailerons from Mach 1.6 to 2.96, the range of the report’s Figure 18 points. | |
| ADR-291: The bench’s chamber band from Fetter’s seven printed peaks | The ground-test bench’s (M13.7) seven 0.5 g black-powder shots in an empty chamber must give a mean peak from 23.68 to 33.85 psi (28.76 ± 5.08), the band from the seven peaks in Fetter’s 2025 ejection-testing paper (Fig. 7-5) and their sample deviation; a correct logger lands inside about 93% of the time. The figure’s printed mean and deviation, 28.49 and 4.04 psi, don’t match those peaks. The band is fixed, so a logger whose shots scatter more doesn’t get an easier test. | |
| ADR-292: The program’s words in four increments, the help first | M0.14d covers hpr’s help, its warnings and errors, the Python package’s docs and each crate’s top-level docs. That’s too much for one rewrite: the help is about 4,400 words, but the messages are about 270 error types and 80 to 90 places that push a warning, in 14 crates. They go in four increments. The help comes first, with a snapshot of each command’s --help that cargo xtask voice reads and holds to the voice limits, as the site’s pages are held. | |
| ADR-293: Cavour’s log read to its apogee event | Cavour’s real-flight record reads its log only up to 23.6 s, the first row its ground station tags as the drogue event. After that row the radio telemetry’s filtered height jumps 8 m (26 ft) in 0.2 s, faster than the rocket can climb, about 2 s before the drogue charge most likely fires. So the logged apogee is the coast’s peak, 2,785 m (9,137 ft), not the jump’s 2,789 m (9,150 ft). Cavour’s error rises from +5.63% to +5.78%, and the mean absolute apogee error over the seven flights rises from 6.04% to 6.06%. | |
| ADR-294: The 2026-10-26 review: the RocketPy times, burnout heights and traces tightened | In the RocketPy whole flights flown on the same inputs, the rail-exit times agree within 0.143%, and in the six flights with no written model difference the apogee times within 0.239%, the burnout heights within 0.049% and the height and speed traces within 0.272% of RocketPy’s apogee and 0.153% of its top speed, while RocketPy’s own solver moves the point metrics by at most 2.4e-5 of their value; so those 33 gates go from 3% to between 0.2% and 1%, each at least 3.2 times the largest difference measured. These bound agreement between two codes on RocketPy’s example rockets, not accuracy against a flight. | |
| ADR-295: The rest of the words in four increments, joined names and long warnings first | M0.9f holds the site, the README and hpr sim’s warnings to seven writing rules that #476 lists. Fixing them all is several sessions’ work, and two of the rules add bytes to a search index with 71 bytes to spare. So it goes in four increments: joined names and long warnings first, then long notes and table heads, which make room in the index, then grouped figures and prose dates, and last the no-break space between a figure and its unit, joined in the built pages after mdBook writes its index. | |
| ADR-296: What the words leave: the figures’ digits and the command line’s words, M0.9g | Ten rows of the design audit named M0.9f for gaps outside its done when: figures quoted to more digits than are known (#966), and the command line’s and the plot’s words, which no check reads (#973). M0.9g holds both, queued after M0.13. | |
| ADR-297: A table too wide for its column stacks its rows | A table wider than its column no longer scrolls sideways in its box. Its rows stack, each cell labeled by a copy of its column’s head, and the page check fails a table that still scrolls, at every width from 320 px. | |
| ADR-298: Every solid motor in four increments, each file’s check first | M5.7 compiles ThrustCurve.org’s whole solid catalog into hpr-motor (ADR-288). It is several sessions’ work, and its first bullet needs a fresh snapshot from ThrustCurve.org’s API, which has answered HTTP 503 since 2026-10-25. M5.7a builds each file’s stored check, the default-file rule and the warning on the 32 bundled files first; M5.7b compiles in the fresh snapshot; M5.7c holds every passing file to the oracles; M5.7d adds hpr motors update and the motor page’s figures. | |
| ADR-299: Withdraw the smoother to land it again in order | M7.2d, the smoother, merged in #983 before the captures of the pages it changed were looked at, as ADR-282 requires before a merge. The look found the health card’s lines cut at their box’s edge, which #986 fixed after the merge. Both are reverted, the tree going back to the commit before #983, and one PR lands the two again with every check run before its merge. M7.2d’s roadmap entry goes back to open until then. | |
| ADR-300: The smoother and its check on the synthetic flights | hpr_flightdata::smoother fuses a log’s barometer, accelerometer and GNSS receiver in a Kalman filter run forward and a Rauch-Tung-Striebel pass back, and gives the height and vertical speed at every sample with a standard error. cargo xtask synthetic holds it to the truth of the three synthetic sets at burnout, the top speed, apogee and a drawn moment, and fails unless every cell holds on every set and logger, the pass back solves every step, and trusting the GNSS receiver from liftoff fails on both test sets. Its 90% intervals hold on all three sets: between 94.3% and 99.4% of the truths lie inside each set’s cells. | |
| ADR-301: The whole catalog in two increments, the index before the lookups | ThrustCurve.org’s API answered again on 2026-10-28, and a fresh snapshot was taken: 1,004 solid motors and 1,706 files. Compiling it in is one session’s work; switching every lookup to it is another, because it moves flights, shared names and reports. M5.7b1 compiles the snapshot in, with each file’s check, beside M5.7a’s 32 motors, which the lookups keep using. M5.7b2 switches the lookups to the whole catalog. | |
| ADR-302: Every motor by name, offline | Every lookup now reads the whole bundled catalog: 1,004 motors, 924 of them with a curve file. A name two makers use, by designation or common name, takes its maker (Estes C6); within one maker a designation outranks a common name. Each motor gets a selector, a name that finds it alone. A motor with no curve is listed and refused, not hidden. A bundled default file more than 5% light on propellant warns, as a fetched one does. cargo xtask motor-catalog --check lists and flies every motor offline, with counts from the raw snapshot. | |
| ADR-303: The 2026-10-28 review: the RocketPy peaks tightened | In the RocketPy whole flights flown on the same inputs, the largest Mach numbers agree within 0.235% and the largest accelerations under power, outside Bella Lui’s two flights, within 0.248%, while RocketPy’s own solver moves them by at most 9.1e-6 and 2.7e-4 of their values. Each bound goes from 3% to 1%, 4.3 and 4.0 times the largest difference. Bella Lui keeps 3% on its accelerations for the cause its case file measures. A test pins every bound. | |
| ADR-304: Every passing file held to the oracles | The 1% test against each file’s record and the test against ThrustCurve.org’s own statistics code run over all 412 files stored as passing, with the code’s fixture holding exactly those. HPR Sim reads two samples at one time as a step, and ThrustCurve.org’s code as one averaged point. HPR Sim keeps the step, and the code with its merge turned off matches it to 3e-15 on every file; the test names the 6 files the merge moves. A recount from the raw snapshot, with ThrustCurve.org’s code, agrees with the index on all 1,700 files it holds. cargo xtask motor-catalog --check fails over 1%, worked out again from each file’s bytes, and runs in CI. | |
| ADR-305: Neer’s 2026-10-28 licensing calls: vendors’ published sizes and masses as facts, and which holds stay | Dimensions and masses a parts vendor publishes are facts, used with credit, as ADR-287 reads ThrustCurve.org’s records; no photo, drawing or descriptive text is copied and no vendor is contacted, so M5.6b needs no question to vendors. The motor finder’s real test records come from the 2026-10-28 snapshot hpr-motor ships, and the held catalog file is cleared. CATS’s log layout, RASAero II’s design files and the guide’s real-flight trace each get a route for when their work comes up. Featherweight’s Bluetooth packets, makers’ data sheets, Wyoming soundings and the refused references stay as they are. The orhelper migration idea is dropped. | |
| ADR-306: Withdraw the motor update to land it again in order | M5.7d, hpr motors update, merged in #1040 before the captures of the pages it changed were looked at as ADR-282 requires: the look before the merge took more captures than its limit, before the site’s clipping check. A look done right after the merge found no clipping beyond #1043’s. As with ADR-299, #1040 is reverted and one PR lands it again with every check run before its merge. M5.7d’s roadmap entry goes back to open until then. | |
| ADR-307: Newer motors found by comparing ThrustCurve.org’s whole catalog with the bundle | hpr motors update asks ThrustCurve.org’s search for every motor at once and compares the solid ones with the bundled catalog by id, file count and update day, downloading only the motors that may differ. Its date filters aren’t used: one of them matched nothing on 2026-10-29. A newer motor is found offline after the update; a newer file of a bundled motor is only cached, and the bundled file keeps flying. | |
| ADR-308: M7.2e in four: the intervals by reading, then the surfaces | each reading’s 90% interval runs from the reading less one share of its own bound to the reading less another. The two shares are the 5% and 95% points of the readings’ errors as shares of their bounds, fitted on a calibration set of 2,000 synthetic flights on a seed of its own. cargo xtask synthetic fits them again, holds them to the library’s, and runs ADR-257’s test with its three probes on sets A and B. M7.2e1 does this for the apogee’s height and time; e2 and e3 add the other readings; e4 takes the intervals and the smoother’s health card to hpr analyze and Python. | |
| ADR-309: A fin tab weighed as its file states it | a fin tab may start ahead of its root’s leading edge or end past its trailing edge. | |
| ADR-310: The 2026-10-31 review: the RocketPy rail-exit and landing speeds tightened | In the RocketPy comparisons flown on the same inputs, the rail-exit speeds agree within 0.0144% and the landing speeds within 0.0301%, while RocketPy’s own solver moves them by at most 3.13e-5 and 8.6e-7 of their values. The bounds go from 0.2% to 0.05% and 0.1%, 3.5 and 3.3 times the largest difference. All nine rail-exit speeds read low, the cautious side, for two causes measured here, and a test stops one reading high. These bound agreement between two codes, not accuracy against a flight. | |
| ADR-311: The 2026-10-31 review: every flight OpenRocket flies, and CI’s long checks | On the private collection OpenRocket 24.12 flies 79 of the 83 flights that come from a .ork and HPR Sim 68, which no scoreboard row shows. A new row, coverage.collection, and a milestone before the gap is split by cause, close that. CI’s long report checks now run from an optimized build with debug assertions, split by set over two jobs on every platform, with a test that fails if a set is left out. | |
| ADR-312: Two logs on one timeline: the offset’s error, the new sets, a booster’s truth | two logs of one flight, or one logger to a stage, go on one timeline by a shared | |
| ADR-313: Ghost files: the log’s own height, three formats from one track, outside readers in Node | hpr analyze --ghost writes a flight’s logs as time-synced trajectories in a frame at | |
| ADR-314: M7.3 in five: residuals first, the simulation read as the log is | M7.3 is more than one PR, so it goes in five parts: residuals, the least-squares fit with its coverage test, the Bayesian option under the same test, the report with apogee predicted from the boost, and the post-flight plot. Residuals come first because the rest stand on them. They rest on one rule: the simulated flight is written out as a noise-free log and read by the same reader as the real log, its height as the real log’s sensor would read it, and both clocks are lined up by what that reader calls liftoff. | |
| ADR-315: The 2026-11-01 licensing layers: the engine stays open, hosted services carry their own terms, and M9.0 sets the app’s license | The code that computes and checks FusionSpace HPR’s numbers stays MIT OR Apache-2.0. Hosted services, starting with the motor stock API at motor.fusionspace.co, carry their own terms: free for personal use and for FusionSpace’s own tools, with written permission needed for any other site, app or service and for any commercial use. The app’s license is chosen in M9.0’s decision record, before any app code is public; the leading option is the Functional Source License 1.1 with Apache-2.0 as its future license. Registering a FUSIONSPACE trademark stays deferred. Amended 2026-11-03: the motor stock API is open again, its data under CC BY 4.0 for any site, as before 2026-11-01; §1, §3 and §4 stand. | |
| ADR-316: M7.3b: the least-squares fit, what it solves for and how its intervals are held | Levenberg-Marquardt fits drag, impulse, a constant wind and mass to a log, with the | |
| ADR-317: M7.3c in two: the posterior’s sampler, then the test | the Bayesian option draws each flight’s posterior by importance sampling around the | |
| ADR-318: The 2026-11-02 review: the cause-free apogees tightened | In the RocketPy comparisons flown on the same inputs, the six apogees with no written model difference agree within 0.1123%, while RocketPy’s own solver moves an apogee by at most 6.35e-6 of its value. The bound goes from 0.5% to 0.35%, 3.1 times the largest difference. All nine same-drag apogees read high, the cautious side for a waiver, and a test now stops one reading low. These bound agreement between two codes, not accuracy against a flight. | |
| ADR-319: The 2026-11-04 review: the RocketPy descents tightened | In the RocketPy descents flown from the same state under the same devices, the 17 numbers held here agree within 0.0857%, while RocketPy’s own solver moves them by at most 3.41e-6. The bound goes from 3% to 0.3%, 3.5 times the largest difference. A drag area 1% too large now fails each of the four descents held to 0.3%; at 3% they passed. RocketPy counts the air a parachute drags along and HPR Sim doesn’t: a small difference on these four, a large one on NDRT 2020, whose descent time differs by 0.705%. NDRT 2020’s descent and Valetudo’s drifts, made by the Earth’s rotation alone, keep 3%. These bound agreement between two codes, not accuracy against a flight. | |
| ADR-320: M7.3c2 in two: the Bayesian option draws the wind first and integrates the sensor out; its raw intervals don’t pass yet | M7.3c1’s one Student-t about the least-squares answer kept a median of 14 effective draws in 300 on set A’s first 60 flights, as the wind’s ridge bends on heights alone. So the wind is drawn first and the rest about one Gauss-Newton step in that wind; a pilot widens the proposal where the posterior reaches further; the four linear sensor unknowns integrate out; on heights alone the wind’s shear is drawn, uniform from 0 to 0.2. On 1,000 flights of each set the raw 90% intervals pass 4 of the 10 counts: set A’s drag and set B’s impulse fail, and the wind is too wide on both. So M7.3c3, the option counted, is met; M7.3c4 keeps the intervals passing. | |
| ADR-321: M7.3c4 in three: the track as a receiver reports it, then the drag on heights alone, then every count | ADR-320’s posterior took the track’s noise as the least-squares fit states it, at least 10 m (33 ft), and its wind intervals came out too wide. Its own noise made them too narrow; reading the receiver’s filter, centering the draws and integrating out the pad’s position brought them in. So on a log with a track the posterior now reads the drift through a second-order filter of stated range and integrates out the track’s noise, its run from bin to bin and the pad’s position. The wind’s four counts now pass, and no count that passed before fails. M7.3c4 is split in three: M7.3c5 the wind, M7.3c6 set A’s drag, M7.3c7 every count. | |
| ADR-322: The 2026-11-05 progress review: accuracy before reader-facing work | In the four weeks to 2026-11-05 the measured accuracy did not move: FusionSpace HPR’s mean absolute apogee error on the private collection’s 60 logged flights is 12.07% against OpenRocket 24.12’s 11.26%, a gap of 0.8 to 0.9 points since 10-08, and no aerodynamics fix has closed since 10-15. There are no outside users yet. The work goes to what is hard to add later, correct numbers and accuracy against real flights, and holds what matters only once someone reads it: the 0.2 release, the sites’ calendar banner, the figures’ digit check. Next: M7.3d, its fits split by the held-out halves, then M2.7, M7.5, M2.3c6 and M1.14. | |
| ADR-323: The transonic margin warning, and shorter known-issue lines | From Mach 0.8 the fins’ straight-line join puts the center of pressure aft of a wind tunnel’s, by 0.6794 and 1.343 calibers on two Arcas Robin models at Mach 0.9, so the flight margin reads high, and nothing warned. Every flight with a margin past Mach 0.8 now warns (#1198). To keep the guides’ example output inside the search index’s 10 MB limit, a known issue’s text line leaves its address to one help: line, and the always-on warnings are shorter; #18’s message now says its 3.6% is of the friction, not the drag. #414 comes before any further prose. | |
| ADR-324: One full gate a pull request, and the site step on prose left to CI | The gate (scripts/gate.sh) is the maintainer’s local run of most of CI’s checks; a full gate runs every default step. A pull request passes one full gate before it opens. A later commit, such as a review’s fix, passes the steps it touches and CI on its head, unless main is merged in. Main gets its own full gate, with the checks on the private reference data, on each new tip of main before the next piece of work. The gate’s default run leaves the site step out when a branch changes only the words of pages: CI builds and checks the site at every width on every pull request, and a merge needs it to pass. | |
| ADR-325: M7.3d2, apogee predicted from the boost on the public flights | The 7 public flights’ logs are fitted whole where the apogee reads (6) and up to the boost’s cut where there’s a prediction (2), in each flight’s ERA5 air. Two flights get a prediction, with a mean absolute miss of 3.03% where the forward simulation’s is 6.89%. Only NDRT 2020’s is the case the method is meant for, cut after its burn on a log under the transonic limit: −3.88% against +10.40%. Hartigan’s exact sign-flip interval on the difference is unbounded below 6 flights. On these logs the cut can fall inside the burn: 4 of the 5 cuts do (Bella Lui’s 0.18 s short of its end), Lince’s among them, measured and reported, not fixed here (#1307). | |
| ADR-326: M7.3d3 in four, the halves sealed first | The private collection’s held-out flights are fixed by ADR-322’s encoding, and the SHA-256 of their sorted ids is committed on its own, before any half’s number exists. Each flight’s log is chosen from its pinned logs by the apogee nearest the one the collection states, read and cut at the boost, counted over the whole collection only: of 72 flights not left out, 64 have a barometer’s log the analyzer reads an apogee from, 32 are cut, 30 refused at the transonic limit and 2 for a log slower than 8 Hz. The fix to the cut (#1307), the collection’s errors by halves and the scoreboard row follow, in that order. | |
| ADR-327: M7.3d5, the fall must hold and still fall | The boost’s cut waits until the climb speed’s fall has held 0.75 s and the speed is the lowest of those 0.75 s. On the public logs no cut falls inside the burn now (4 of 5 did): Bella Lui and NDRT 2020 are cut after their burns, and the other 5 reach the transonic limit first. Set A’s cuts come 1.08 s to 2.30 s after burnout, inside the 2.83 s bound; 1,787 of 2,295 dipped synthetic logs fall by the cut’s amount before burnout; each is cut after burnout or refused as transonic. The collection: 26 cut; none of the 20 whose burn and liftoff are known is cut inside its motor’s burn. | |
| ADR-328: The 2026-11-08 review: twelve public flights, predictions first | HPR Sim’s accuracy against public real flights rests on 7 flights, all from RocketPy’s examples. Five more public flights can join them: RocketPy’s Astra, Andromeda and Erebus 11, once their netCDF-4 weather is read and their designs are built from the examples’ inputs, and two MIT-licensed flights of one OpenRocket design. The new milestone merges each new flight’s inputs and predicted apogee in a pull request of its own before any of their errors is computed, then puts accuracy.public and bias.public over the 12. It changes no model and loosens nothing; it raises how many real flights the public numbers rest on, from 7 to 12. | |
| ADR-329: M7.3d6, the collection’s errors by halves | Each private collection flight with a cut log, among the flights the forward report compares, goes to the fit up to its cut, on the flight as fixture-flights flies it in HPR Sim, and is flown on to apogee: 21 predicted, 12 in the calibration half and 9 held out; 1 has too little up to its cut to fit. The prediction’s mean absolute apogee error is 3.22% in the calibration half and 3.56% in the held-out half, against the forward simulation’s 9.35% and 16.86% on the same flights; the paired bootstrap 95% intervals on the difference are −10.07 to −2.70 and −19.01 to −7.97 points. The held-out half’s fit aggregates stay private; their file’s SHA-256 is committed and checked. | |
| ADR-330: M7.3d7, the from-boost scoreboard row | The scoreboard gains accuracy.from-boost, the mean absolute error of the apogee predicted from the log cut after burnout: HPR Sim 3.22% on the 12 calibration-half flights it can predict, with a note on which flights and the forward simulation’s 9.35% on them. OpenRocket and RocketPy say can’t, by their documentation. | |
| ADR-331: Withdraw the from-boost row to land it again | #1365, the scoreboard’s accuracy.from-boost row, merged with seven commits that came after its last review; #1368 then tightened the row’s test. From here, a pull request merges only once each review it needs has read its last commit, so both are withdrawn and land again together with their reviews first. While withdrawn, the scoreboard has no accuracy.from-boost row. | |
| ADR-332: M2.7 in two, the halves and the fits’ guard, then predictions first | The private collection’s report gives its apogee errors over both halves, as aggregates: of the 60 flights compared, 37 are in the calibration half and 23 held out. A fit across the collection’s flights must take its flights through a guard that reads each flight’s half from its id again and refuses a held-out one, so cargo xtask fixture-flights --check fails when a held-out flight reaches a fit that takes it: the calibration half’s fit aggregates, and the report’s calibration half, by which the scoreboard’s check now holds its collection rows. New flights predicted before their logs are compared are the second increment. | |
| ADR-333: M2.7b, new flights predicted first | A flight the private collection’s manifest gains after M2.7a is compared with its log only when the collection holds its prediction, written from the flight’s plan alone, and that file’s SHA-256 sits in validation/reports/predictions.sha256 where the branch last took main, so it merged in an earlier pull request; otherwise fixture-flights refuses it by id. A committed digest of M2.7a’s 83 manifest ids tells a new flight from an old one. Shown on an invented flight; no flight is new yet, so the list is empty. The scoreboard’s held-out rows read the fixture report’s held-out half, HPR Sim 16.32% and OpenRocket 24.12 14.98% over 23 flights (bias +13.42% and +11.68%), shown, not held. | |
| ADR-334: M2.3d1 in three, the EuRoC 2022 predictions first | HPR Sim can’t fly the Macie XL design yet: its stage’s mass override adds to its parts, and HPR Sim holds such a stage back. So the five predictions merge in two pull requests, and no error is computed until both have merged. This record merges the first three, flown from their example notebooks in their launch hours’ ERA5 air: Astra 3,037.1 m (9,964 ft), Andromeda 3,581.0 m (11,749 ft) and Erebus 11 2,714.1 m (8,904 ft), as their altimeters would read them. Andromeda is counted on its team’s thrust file and tagged not traced; the catalog motor’s 3,050.3 m (10,008 ft) is shown beside it and never counted. | |
| ADR-335: A stage’s added mass, as OpenRocket weighs it | The .ork reader no longer holds back a stage whose mass override doesn’t cover its parts. OpenRocket 24.12 adds such a mass to what the parts weigh, as a point: at the center of that stage’s parts, or at the stage’s center of gravity override when that doesn’t cover the parts either. The design holds that mass as the stage’s added mass, and on 19 probes HPR Sim’s structure matches OpenRocket’s: the center within 0.2 µm, the mass and the inertias within 3 parts in a million. A motor aboard doesn’t move the added mass. Where an override covers the parts, the inertia stays HPR Sim’s own rule: on such stages’ probes, from 11.04% under OpenRocket’s to 400.5% over. | |
| ADR-336: M2.3d4 in three, the inertia and the refusals last | A stage in an OpenRocket file can carry a mass override and a center of gravity override, each covering the stage’s parts or not. M2.3d4’s done when holds such a stage’s inertia to OpenRocket’s and has it held back no longer. The merged work fell short twice. Where one override covers the parts and the other doesn’t, HPR Sim kept its own inertia rule: from 11.04% under OpenRocket’s to 400.5% over on eight probe designs. A few such stages are still refused. This record reopens the milestone: M2.3d6 is what merged, M2.3d7 the inertia, M2.3d8 the refusals, and, after ADR-340, M2.3d9 the inertia on a lower stage and with a motor. M2.3d4 is met when the last three are. | |
| ADR-337: The Macie XL predictions, each flight’s stored simulation flown as saved | The last two of the five new public flights are predicted: both flights of Macie XL, one OpenRocket design in a public repository. The repository gives no weather or rail, and of the launch site only each log’s pad height, so each flight is flown as the stored simulation its repository names for it, from the design file as OpenRocket 24.12 saved it. HPR Sim predicts 706.2 m (2,317 ft) for flight 1 and 692.6 m (2,272 ft) for flight 2, as their altimeters would read them. Both are tagged not traced. No error is computed. Flight 1’s motor now flies the bundled curve file the design’s digest names, which is not the catalog’s first file. | |
| ADR-338: The 2026-11-11 review: descent rates held to the logs, predictions first | Every scoreboard row that reads a logged flight reads its apogee. A rocket’s descent rate under its parachutes sets its landing speed and its drift, and HPR Sim’s is held to other simulators and to drop tests, not to flights. The analyzer reads each canopy’s rate from a log. On the five public flights that have both, the simulated rate under the main runs from 7.59 m/s (24.9 ft/s) slower than the log’s to 1.07 m/s (3.5 ft/s) faster. The milestone scores the private collection’s flights likewise, after the comparison’s rule and each flight’s predicted rates are merged, so each prediction is fixed before anyone sees its error. The scoreboard gains rows for the rate’s error and its sign. | |
| ADR-339: M0.17, the docs site at the tool level, queued second | The product system the docs site is pinned to now has three levels: front pages, tools and records. A docs site is a tool: it keeps what the drawing means (line types, trust notes, signal colors, units) and leaves off the drawing’s frame. The site still wears the whole record: a designation tag over each title, sheet numbers and a title block at the foot of every page. Issue #1364 asks for the move, and it is a milestone’s work, not an issue’s. This record adds it as M0.17 in two increments, the frame off and then a fourth color theme, Field, and queues it second, where the maintainer asked for it. | |
| ADR-340: A stage’s overrides leave its parts in place, as OpenRocket weighs them | A .ork stage whose mass or center of gravity override covers its parts now keeps the parts where the design puts them, as OpenRocket 24.12 does. Its inertia is the parts’ about the stage’s center. Before, HPR Sim moved and rescaled the stage as one body. On six of M2.3d7’s eight probes the inertia now matches OpenRocket’s within ADR-336’s bounds; it ran from 11.04% under to 400.5% over. On the two with the override on a lower stage, OpenRocket’s figure is below what the stage’s parts alone have about its center: the rocket’s inertia across the axis is now 4.95% and 3.33% over (it was 1.5% and 18.5%), pinned. The collection’s mean absolute apogee error goes from 12.07% to 12.04%. | |
| ADR-341: M2.3d8 in five, a parallel stage’s added mass first | A parallel stage in an OpenRocket file, boosters strapped beside the core, can carry a mass override that doesn’t cover its parts. HPR Sim warned of one and held the design back. It now reads it as OpenRocket 24.12 weighs it: one mass added to the set of boosters, at their center or at a stated station. Of 49 new probe designs HPR Sim lays out 27, and on the 25 of those with boosters the parallel stage alone matches OpenRocket’s mass, center and both inertias. The probes also show cases this change doesn’t fly, so M2.3d8 is split in five, and four increments stay open. | |
| ADR-342: The errors before the remaining OpenRocket-parity probes | The five public flights whose predictions were merged first are now compared with their logs. cargo xtask real-flights flies all 12 public flights and prints each of the five merged predictions beside its log’s apogee and its error: Astra −6.53%, Andromeda +4.14%, Erebus 11 −9.58%, and the two Macie XL flights −16.20% and −29.16%. Over the 12 the mean absolute apogee error is 9.00% and the mean with its sign is −4.91%; over the seven compared before, they were 6.06% and −0.22%. No prediction was revised. The work left on how an OpenRocket file’s stage overrides are read moves behind the accuracy work: it checks HPR Sim against OpenRocket on probe designs, and the logs are what decide accuracy. | |
| ADR-343: The docs site drawn as a tool: the frame off | The docs site follows the product system at dd7552f, the commit that gave it three levels, and is drawn as a tool. Pages lose the designation tag and the sheet numbers; each ## section is a part under a 2 px rule. Every page but the print page ends with a one-line footer: the mark and “FusionSpace HPR”, the version, the date of issue, the site’s status chip and a link to Start here. Start here keeps the title block as the site’s about box, and the print page still ends with it. Labels, navigation, note heads, chips and the switch are in Archivo, in sentence case, at the system’s web sizes; CAUTION and WARNING keep capitals, in the wide cut. | |
| ADR-344: M0.17b in two: Field first, then the restyle’s acceptance pass | M0.17b asks for two things that each take a session: a fourth color theme, Field, read by the page check at every width as light and dark are, and the acceptance pass for the whole restyle of the docs site. This record ships them one after the other. M0.17b1 adds Field to the theme switch and to the page check. M0.17b2 runs the acceptance pass over M0.17a’s and M0.17b1’s work and closes issue #1364. | |
| ADR-345: The restyle’s acceptance pass and its fixes | A reviewer that didn’t build the restyle ran ADR-344’s six tasks on the built site, and a cold reader did them from the guide alone. At 320 px the keyboard couldn’t reach the menu button, focus rings were cut at the column’s edge, and code blocks hid their lines’ ends. The captures of every page the tasks reach found a code block cut beside the open table of contents and the header left over a page’s end on a phone; checking the cold read found a table of contents shut with reduced motion still a keyboard stop. This record fixes them, adds a page-check rule and canaries for each, and answers the cold read’s findings in the site’s words. | |
| ADR-346: M7.5 in three: the rule before the fit | The correction of the bias the simulators share is two scales: one on the motors’ impulse, pooled from what the calibration half’s logs alone say of the boost, and one on the drag, from those flights’ coasts. Each enters only if its 95% interval excludes 1. It ships only if it lowers the mean absolute error and the absolute bias on the held-out half and makes neither worse on the public flights, with and without the flights whose logs and files disagree by more than NAR’s retest rule allows. This record is merged before that fit is run. Its own increment splits each half’s forward error at the boost’s cut and reads the calibration half’s logs alone. | |
| ADR-347: The 2026-11-14 review: landing points held to tracked landings, predictions first | hpr sim prints how far from the pad a rocket lands, and no report sets that against a real flight. 41 of the private collection’s 83 flights are cataloged with a latitude and a longitude column or as a tracker’s file (no track has been read yet), and each has the day’s winds by height. The milestone reads each track’s pad and landing points, merges them and each flight’s predicted landing point before any error is computed, then scores the miss. The scoreboard gains a row for the miss and a row for whether the predictions land short. A landing predicted nearer the pad than the real one is the flattering side. | |
| ADR-348: M7.5b’s verdict: the shared-bias correction fails on the public flights, and nothing ships | Fitted on the calibration half as ADR-346 fixed it, the correction is an impulse scale of 0.94 with the drag left at 1, in the fit without the flagged flight. It lowers the held-out half’s mean absolute apogee error from 16.26% to 10.91% and its mean error from +13.36% to +5.84%. Both fits pass all four held-out sets. On the 12 public flights it raises the mean absolute error from 9.00% to 12.16% and takes the mean error from −4.91% to −12.01%; the other fit does worse. The rule asks that the public flights get no worse, so the verdict is a fail. The held-out half’s sealed fit aggregates are published, their file matching its committed hash. | |
| ADR-349: M2.3c6 in four: the public nose probe first | The gap to OpenRocket by cause needs four things the tree lacks: a public probe of the tangent-ogive nose’s pressure drag, OpenRocket’s thrust, mass and drag along its own flights with a way for HPR Sim to fly them, the split in the fixture report, and the nose’s own line. Each becomes an increment. The probe ships first: on an invented fineness-3 tangent ogive, OpenRocket 24.12 gives the nose a pressure drag coefficient of 0.00098, 0.00073 and 0.00047 at Mach 1.3, 1.5 and 2, where HPR Sim and the equivalent cone give 0.1557, 0.1303 and 0.1042. | |
| ADR-350: M2.3c13’s result: the tangent-ogive nose’s line, and why #222’s flight is not in it | Five of the 68 flights both simulators fly pass Mach 1 with a tangent-ogive nose, and all five are swapped. With HPR Sim’s pressure drag of the nose replaced above Mach 1 by OpenRocket 24.12’s, the nose’s line is −1.28% of OpenRocket’s apogee on average, inside a drag part of −1.96%. Those flights reach Mach 1.06 on average, so the line is measured just past Mach 1. #222’s flight is not among them: it is in the design-library report, which holds no thrust and mass histories, and the line is defined on those. An open issue, #1497, carries its nose-only swap. No flight of the line has a repeated nose, so none was probed. | |
| ADR-351: M1.14b in eight: the Basic Finner’s normal force first | ADR-143 §6b names nine references for Mach 1.5 to 2.5. Three are refused on what the research notes found; the other six need work the tree lacks, in eight increments. The first ships here: against DREV-TM-9703’s free-flight range fits of the Basic Finner, HPR Sim’s normal-force slope reads 11.2% and 16.1% low at Mach 1.832 and 2.375, and its center of pressure 0.34 and 0.18 calibers forward, the side that understates stability. | |
| ADR-352: The 2026-11-16 review: speed off the rail held to accelerometer logs, predictions first | hpr sim prints how fast a rocket leaves its rail, and no report sets that speed against a real flight: it is held to another simulator flown on the same inputs. 48 of the private collection’s 83 flights are cataloged with an acceleration column. The milestone reads, from each such log, the rocket’s speed after the same travel along the rail, by summing the logged acceleration from rest on the pad. It merges those readings and each flight’s predicted speed before any error is computed, then scores the error. The scoreboard gains a row for the error and a row for whether the predictions run fast. A speed predicted higher than the flight’s is the flattering side. | |
| ADR-353: NASA’s check cases 1 and 2: both differences past the codes’ spread, traced | A free body of the report’s mass and inertia flies NASA/TM-2015-218675’s check cases 1 and 2 on HPR Sim’s gravity, Coriolis force, rigid-body equations and default integrator. In case 1 its altitude ends 19.51 mm (0.77 in) below the codes’, 137 times their spread: WGS 84’s normal gravity holds the terms past J2 that the codes’ gravitation drops, and that accounts for all but 0.1364 mm (0.0054 in). In case 2 its inertial body rates differ by up to 0.01633 deg/s, 12 to 16 times the spread: the rotational equations leave the Earth’s rate out, and that accounts for all but 0.001005 deg/s. Both remainders are inside the spread. | |
| ADR-354: The search index is held to mdBook’s own bar, not to its weight on 2026-11-10 | The site’s search index was held to its weight on 2026-11-10, 1,675,059 bytes compressed. The file stores every section’s text, so that limit held the guide to the words it had that week: a week later main had 2,684 bytes of room, about 920 words. The limit is now 10,000,000 bytes of the file, the size past which mdBook itself calls an index very large. That is room for about 139,000 more words; #1522 decides what follows. | |
| ADR-355: Withdraw NASA’s check cases 1 and 2 to land them again in order | M1.14b3, the free body flown against NASA’s check cases 1 and 2, merged in #1523 before the captures of the pages it changed were looked at, as ADR-282 requires before a merge. A look done right after the merge found nothing cut at an edge. As with ADR-306, #1523 is reverted and one pull request lands it again with every check run before its merge. M1.14b3’s roadmap entry is open until then; ADR-353 and ADR-354 stay, withdrawn with it. | |
| ADR-356: NASA’s check cases 3 and 6 to 10: the test’s loads, and the codes’ own air | The free body flies NASA/TM-2015-218675’s check cases 3 and 6 to 10 under loads the test applies: case 3’s damping moments, and the sphere’s constant drag along its velocity through the air. Case 3’s inertial rates differ from the kept codes past their spread, and the Earth’s rate left out of the rotational equations accounts for all but 0.003176, 0.001123 and 0.0007793 deg/s, inside it. The sphere’s positions in cases 6 to 8 differ from SIM 1 past the spread; the gravity past J2 with each code’s own air density brings them inside it, to 77.57 to 77.68 mm (3.05 to 3.06 in), without explaining SIM 1’s. Cases 9 and 10 are within the spread. | |
| ADR-357: Tip-off, measured with RocketPy’s: past the plan’s bar, the model in two more increments | RocketPy’s tip-off phase, at the merge of its pull request #920, flies thirteen example designs in still air and in a 20 mph (8.94 m/s) crosswind. Turned on, it moves 9 of 26 landing points by more than 1% of the apogee and one apogee by more than 1%, so the plan calls for a tip-off model. Against a rocket guided to its last button, as HPR Sim guides it, the phase moves the landing point by up to 3.765% of the apogee and the apogee by up to 0.414%. The model is M1.14b9’s, and flying it by default is M1.14b10’s. | |
| ADR-358: M1.14b9 in two: the tip-off phase on RocketPy’s normal force first | HPR Sim’s tip-off phase agrees with RocketPy’s on all 26 flights when both fly RocketPy’s normal force, and on the 13 still-air flights on HPR Sim’s own. On its own normal force the 13 crosswind flights are past the bars, because the two codes’ normal forces differ at 9.7° to 25.6° angle of attack: HPR Sim’s coefficient is 1.23 to 2.71 times RocketPy’s, and its moment about the last guide 0.35 to 15.20 times. M1.14b9 stays open on those 13. | |
| ADR-359: Drag below Mach 0.8 next: the drag part of the gap to OpenRocket, by Mach band | Split by the Mach number the drag acts at, the drag part of the gap to OpenRocket 24.12 on the private collection’s 68 flights is largest below Mach 0.8: a mean absolute 0.87% of the apogee there, 0.50% from Mach 0.8 to 1.2 and 0.23% above Mach 1.2. Flown on OpenRocket’s drag below Mach 0.8 alone, HPR Sim’s mean absolute error against the 60 logged apogees falls from 12.04% to 11.65%; on its whole drag, to 11.27%, beside OpenRocket’s 11.26%. M1.14’s increments by Mach number began at Mach 0.8. M1.14i is the band below it, and goes next. | |
| ADR-360: The 2026-11-19 review: drag in the coast held to accelerometer logs, predictions first | Both simulators’ apogees run high on the private collection’s logged flights, by +7.72% and +6.72% on average, and the apogee alone can’t say why: too little drag and too much thrust read the same way. Coasting, an accelerometer along the rocket’s axis reads the air’s force along that axis over the mass, with no thrust and no gravity in the reading. The milestone reads that below Mach 0.8 from each log with an acceleration column, merges the readings and both programs’ predictions before any error is computed, and then scores both programs on new rows, accuracy.coast-drag and bias.coast-drag. | |
| ADR-361: The voice report is built with the site, not committed | In the week to 2026-11-15, more than half of the pull requests (37 of 66) rewrote the committed voice report, so any two that edited pages conflicted on it, and a conflicting pull request gets no CI run. The report is no longer committed. The site’s build writes it onto a stub page, docs/voice-report.md, from the pages each time, and CI still fails a stock phrase, or a held page over a limit or missing a sentence target, as before. A mutation run shows each of the eleven failures still failing CI’s site command, and two branches that edit neighboring pages now merge cleanly where today they conflict. | |
| ADR-362: Base drag behind a boattail below Mach 0.8, held to the Hermes A-3A | Below Mach 0.8 HPR Sim gave the base behind a boattail the whole flat-base drag. On the Hermes A-3A’s measured free flight it read high by 0.050 to 0.064 power off, at least ten times the report’s stated error. The base now keeps of the flat-base value, the base’s diameter over the boattail’s fore diameter, from Stoney’s rule for conical afterbodies (NASA TR R-100, 1961, p. 11). On the reference the mean absolute error falls from 0.0574 to 0.0303, and no row’s error grows. On the private collection’s logged flights HPR Sim’s mean error goes from +7.72% to +8.01% and its mean absolute error from 12.04% to 12.09%. Those flights choose nothing here; they are reported. | |
| ADR-363: M1.14b10 in three: the tip-off reference at RocketPy’s rewritten phase first | RocketPy rewrote its tip-off phase after HPR Sim’s comparison was pinned. Re-pinned at the rewrite, the reference moves by at most 0.000020 deg/s in a turning rate and about 1 mm (0.04 in) in any apogee or landing point, the same flights are past the plan’s bars, and HPR Sim’s phase is inside every bar it was held to. Flying the phase by default reaches the command line, the Python package, the comparisons with other codes and most committed flight reports, so it is split: the reference first, then what the phase moves on the real flights, then the default. | |
| ADR-364: The tip-off phase on the real flights: two small rises, measured | Every real flight HPR Sim compares was flown twice, guided to its last guide as today and with the tip-off phase. Over the seven flights compared first the mean absolute apogee error falls from 6.065% to 5.974%, a fall that rests on Juno III’s rise in its wind. Over the five predicted first it rises by 0.0014 percentage points, and over the private collection’s 60 by 0.0033. Both rises are under the hundredth of a point the reports print. Each is measured to its flights: one is gravity lowering a flight HPR Sim already flies low, the other the phase raising, on net, a set HPR Sim already flies 8% high. M1.14b15 may make the phase the default. | |
| ADR-365: A smoothed track past Earth’s escape speed is withheld as diverged | The nightly census failed on four of its five platforms (#1590). One synthetic flight’s track, smoothed with its GNSS receiver trusted from liftoff, ran away, and the report held its standard error, 2,480,000 m (8,136,483 ft), to three figures the platforms made three ways. The smoother now withholds as diverged any track whose vertical speed passes 11,186 m/s (36,699 ft/s), Earth’s escape speed. The mutation’s diverged logs are counted and leave its cells, and it still fails. The bound also withholds 3 of the 1,058 real sample records, whose runaway tracks hpr analyze printed until now. A branch repairing a failed night may merge on a full run of its own head, main merged in. | |
| ADR-366: The main’s opening at the likeliest single change of the descent’s rate | The canopies reading walked back from landing and stopped at the first rate past the main’s mark, so a swing under the main or a coarse log’s scatter was read as the opening (#903). The main’s descent now starts at the likeliest place for one change in how often the rate is within the mark, the change-point of a two-valued sequence (Hinkley and Hinkley, 1970). On the issue’s real flight the opening moves from 108.45 s to 90.00 s, inside the issue’s 87 to 92 s, and the drogue’s rate from 14.6 to 17.3 m/s (48 to 57 ft/s) against a measured 17.3 m/s (57 ft/s). The committed synthetic census is unchanged (cargo xtask synthetic --check on this branch). |
These rows keep part of their detail here, so the table stays readable.
- ADR-209’s standard is completed by an open benchmark (M2.6), a correction for the bias every simulator shares (M7.5), steps-to-first-answer measurement now (M0.11) and tests by flyers outside the project at release 0.5.
- The check for fusionspace.co (ADR-249) also fails a comparative word with no committed comparison linked beside it, and a file from another site; pages built to fail prove each detector can fire.
- ADR-279 queues M2.11 after release 0.3 and before the IREC prediction table that prints a flutter speed (M6.6). It also has release 0.3’s paired bootstrap interval reported resampled by design, with the number of designs, since resampling single flights treats repeat flights of one design as independent.
- ADR-281’s three rules: the pad is taken only as far as its samples can vouch that the rocket was still on it; a track whose heights are above the pad only by a column’s word must start near its zero; and a top that isn’t a coast’s is withheld, either one the track fell from and climbed back to, or a spike that climbs in and falls out faster than physics allows.
- ADR-283’s top acceleration has its gravity settled by three witnesses (the family’s word, the pad, the coast to apogee) and which way up it reads by three more (the pad, the coast and the thrust, each as written), and is a floor where the part clipped, at its stated range or held flat, or where the accelerometer holds the thrust only in part. Without an accelerometer, burnout is a floor: the top speed’s time less its bound. The main’s opening is found back from landing as Debrief finds it, walked on the rate’s running median at the ground’s density; it was found on 87 tuning flights with a barometer, on their own logs, each within its bound, and no main was named on a flight under one canopy, on any log.
The roadmap
The roadmap is the ordered plan of work. It is split into phases, and each phase into
milestones. A milestone’s id is M, a topic number, a dot and its place in that topic. The topic
is not the phase: 0 is foundations, 1 physics, 2 validation, 3 file formats, 4 library interfaces,
5 online data, 6 Monte Carlo and optimization, 7 flight logs, 8 design help, 9 the app, 10 releases,
11 motor design, 12 parachute design and 13 avionics. Phases
mix topics, so M2.3, the real-flights milestone, sits in Phase 1 beside
M1.8, the second aerodynamics milestone. A milestone too big to ship at once is split
into increments with a letter, and sometimes a digit after it, such as M2.1b2. Each one
ends with done when conditions, and it is checked off only when all of them hold. Every
milestone has a row in the table below.
The roadmap file holds open work only. A queue at its top sets the order of work, and the
project’s automated checks fail if the running progress notes name any other milestone as current.
When a milestone is finished, cargo xtask records moves its entry, word for word, to
the archive of finished work, which opens with an index of one line per milestone.
The work runs in this order: the physics and its validation first, then the ways to use it and the analysis tools, with a release at each product boundary, then the app as release 1.0, then the suite’s new product lines one at a time (ADR-162, the suite and its releases).
- Phase 0: Foundations: the workspace, the reference library, the lessons from Loft and this site.
- Phase 1: Physics core, with validation interleaved: the models on this site, then transonic and supersonic aerodynamics, staging, and flight outputs such as the stability margin, with comparisons against RocketPy, OpenRocket and real flights along the way.
- Phase 2: Library surfaces and interop: a simpler interface, a command-line tool, Python bindings, and design files in and out.
- Phase 3: Uncertainty, optimization, challenges: Monte Carlo runs and design optimization for competitions.
- Phase 4: More formats and embeddings: RockSim, RASAero and RocketPy files, and use from C and the web.
- Phase 5: Flight data and forensics: reading flight logs and taking a flight’s readings off them (planned to work on its own, with no design file and no simulation) and then comparing a real flight with its simulation.
- Phase 6: Design experience: a design assistant for apps to build on.
- Phase 7: UI, 3D, web, mobile: a desktop app, 3D flight replay, a web app and mobile, started once release 0.4 is out.
- Phase 8: Releases: 0.1 the simulator (the library, the command line and Python), 0.2 the flight analyzer, 0.3 accuracy and diagnosis, 0.4 the competition kit, 0.5 an app preview with a 3D replay that draws the simulated flight as a “ghost” beside the real one, and 1.0 the app with its editor.
- Phase 9: The suite’s new lines: after 1.0, one at a time: designing experimental solid motors, then custom parachutes, then avionics (a test bench for flight computers, a ground station, a GPS tracker), then hybrids and liquids. Pad day on a phone (M9.4, mobile) comes after the parachute designer and before avionics.
What is done so far, and what is not, is on Start here. Ideas that are not on the roadmap yet, each with a tier, are in the ideas backlog.
Every milestone
Each milestone and increment has a row here, so a milestone label on any page leads to a line of
plain words. The label in the first column opens its phase in the roadmap, or in the archive once
it is done, where its full plan and its done when conditions are. The rows, their statuses and
those links are written by cargo xtask records; only the plain words are written by hand, and
the site check fails if a row is missing or its status disagrees.
| milestone | what it covers | status |
|---|---|---|
| M0.1 | The code workspace, the automated checks (CI) and the licenses | done |
| M0.2 | The library of published sources and reference programs, each pinned so results can be reproduced | done |
| M0.3 | The lessons from Loft, the project that came before this one | done |
| M0.4 | This documentation site | done |
| M0.4a | The site itself, and the checks on its links and labels | done |
| M0.4b | The model pages’ In short, Accuracy, the Glossary and Checking a claim | done |
| M0.4c | Getting started, and How a flight is simulated | done |
| M0.4d | Publishing the site and the API reference on the web | done |
| M0.4e | A new reader answers ten questions from the site alone, and what they find unclear is fixed | done |
| M0.5 | Leaner bookkeeping: one file per decision record, a roadmap of open work in queue order, shorter planning notes, these tables generated rather than hand-edited, and reviews while CI runs (ADR-144) | done |
| M0.5a | One file per decision record, with a generated index | done |
| M0.5b | A roadmap of open work only, with an explicit queue order, and an archive of what is done | done |
| M0.5c | Short planning notes, with budgets the checks enforce | done |
| M0.5d | Indexes and tables like this one generated, not hand-edited | done |
| M0.5e | Reviews that run while the automated checks (CI) run | done |
| M0.5f | Shorter planning files | done |
| M0.5g | The local checks that need the private reference data run on their own when physics code changes | done |
| M0.5h | The checks on the planning files rewritten to enforce the new rules | done |
| M0.5i | The first 20 pull requests after this milestone, measured against those before it | done |
| M0.6 | The FusionSpace product system: the docs site, the command line, its exports and its plot made to the design rules of FusionSpace, the family of tools this project belongs to, and the pages in US spelling (ADR-164) | done |
| M0.6a | The docs site | done |
| M0.6b | The CLI and exports | done |
| M0.6c | The plot | done |
| M0.6d | US spelling, no em dashes | done |
| M0.6d1 | The check, and the pages | done |
| M0.6d2 | The crates | done |
| M0.6d3 | The crates’ em dashes | done |
| M0.6e | US names | done |
| M0.7 | Rocketry explained: guides to high-power rocketry on the docs site, illustrated, then live (ADR-195) | not yet done |
| M0.7a | The format and four guides | done |
| M0.7a1 | The no-clipping checks | done |
| M0.7a2 | The format and the trust guide | done |
| M0.7a3 | Stability | done |
| M0.7a4 | Fin flutter | done |
| M0.7a5 | Drag through Mach 1 | done |
| M0.7a6 | The maintainer’s read | done |
| M0.7b | Recovery, wind and motors | not yet done |
| M0.7c | Live figures | not yet done |
| M0.7d | The rest of the hobby | not yet done |
| M0.8 | Product guides: a landing page and an illustrated tour for each product, every picture generated (ADR-196) | not yet done |
| M0.8a | The simulator’s guide | done |
| M0.8a1 | The landing page and the CLI tour | done |
| M0.8a2 | Python in the tour | done |
| M0.8a3 | Compared with | done |
| M0.8a4 | The maintainer’s read | done |
| M0.9 | One name, one design | not yet done |
| M0.9a | The name everywhere | done |
| M0.9a1 | The packages’ text | done |
| M0.9a2 | The site’s pages | done |
| M0.9b | The design audit | done |
| M0.9c | The CLI, exports and plot to the design | done |
| M0.9c1 | Diagnostics on stderr | done |
| M0.9c2 | US units in brackets | done |
| M0.9c3 | How far to trust a result | done |
| M0.9c4 | Units and trust notes | done |
| M0.9c5 | Provenance | done |
| M0.9c6 | Errors and typed numbers | done |
| M0.9c7 | The plot’s type and spacing | done |
| M0.9c8 | Provenance on every export | done |
| M0.9c9 | Help, roles and progress | done |
| M0.9c12 | The plot’s balloons, banking and title block | done |
| M0.9c13 | The site’s figures and units | done |
| M0.9c14 | Provenance on the other files | done |
| M0.9c15 | Next steps and waits | done |
| M0.9c16 | US units on the model pages | done |
| M0.9d | The site to the design | done |
| M0.9d1 | The figures in tokens | done |
| M0.9d2 | The site’s colors, corners and motion | done |
| M0.9d3 | The page’s frame | done |
| M0.9d4 | The head, the keyboard and forced colors | done |
| M0.9d5 | The notes | done |
| M0.9d6 | The site’s chrome | done |
| M0.9d7 | The page’s frame | done |
| M0.9d8 | Print and the text marks | done |
| M0.9d9 | The anatomy drawn | done |
| M0.9d10 | The pages’ vitals | done |
| M0.9d11 | The intro’s chip and lead | done |
| M0.9d12 | Two to six sheets: the check | done |
| M0.9d13 | The pages’ sheets and trust | done |
| M0.9e | The words to the design | done |
| M0.9f | The rest of the words | done |
| M0.9f1 | Joined names and long warnings | done |
| M0.9f2 | Short notes and cells, labeled heads | done |
| M0.9f3 | Grouped figures, prose dates and known digits | done |
| M0.9f4 | Units held to their figures | done |
| M0.9g | The figures’ digits and the command line’s words | not yet done |
| M0.10 | The scoreboard | done |
| M0.11 | Steps to a first answer | done |
| M0.12 | Typeset equations | done |
| M0.13 | Awareness and care on the sites | not yet done |
| M0.13a | The banner, the footer line and the help page | not yet done |
| M0.13b | Beyond the banner | not yet done |
| M0.14 | The maintainer’s own voice | done |
| M0.14a | The guide and the check | done |
| M0.14b | The front doors | done |
| M0.14c | The rest of the site | done |
| M0.14c1 | The first guides | done |
| M0.14c2 | Studies, data and logs | done |
| M0.14c3 | The command line and the evidence | done |
| M0.14c4 | Reference and the environment | done |
| M0.14c5 | The rocket and its flight | done |
| M0.14c6 | Aerodynamics | done |
| M0.14c7 | Recovery, staging and readings | done |
| M0.14c8 | The file formats | done |
| M0.14c9 | Flight logs, and every page held | done |
| M0.14d | The program’s words | done |
| M0.14d1 | The help | done |
| M0.14d2 | What the design commands say | done |
| M0.14d3 | What the data commands say | done |
| M0.14d4 | The Python package and the crates’ front pages | done |
| M0.15 | Damaged files refused, never a crash | done |
| M0.16 | The time budget for CI and the gate | done |
| M0.16a | Fixed slices of the flight censuses, and the budget measured | done |
| M0.16a1 | Two slices | done |
| M0.16a2 | The fit’s slice | done |
| M0.16a3 | The budget checked | done |
| M0.17 | The docs site at the tool level | done |
| M0.17a | The frame off | done |
| M0.17b | Field | done |
| M0.17b1 | Field in the theme switch | done |
| M0.17b2 | The restyle’s acceptance pass | done |
| M1.1 | Vectors and rotations, frames, the Earth’s shape and gravity | done |
| M1.2 | The atmosphere and wind | done |
| M1.3 | Solid motors: thrust curves, motor files, and mass through the burn | done |
| M1.4 | The rocket’s design and its mass properties | done |
| M1.4a | Part shapes and materials, and each part’s mass, center of gravity and inertia | done |
| M1.4b | The design tree: where parts sit, motor configurations and design checks | done |
| M1.5 | Aerodynamics below the speed of sound | done |
| M1.5a | Normal force and center of pressure | done |
| M1.5b | Drag, and tables that override it | done |
| M1.6 | The six-degree-of-freedom flight | done |
| M1.6a | The time integrator, and how events such as burnout and apogee are found | done |
| M1.6b | The rigid-body flight: the rail, the equations of motion and the phases of a flight | done |
| M1.7 | Recovery | done |
| M1.7a | Parachutes, and the descent under them | done |
| M1.7b | Streamers and tumble recovery | done |
| M1.7c | Separated bodies, each flown to its own landing | done |
| M1.8 | Transonic and supersonic aerodynamics, damping, and overriding the aerodynamics; closed with its drag target missed, which moves to M1.14 (ADR-143) | done |
| M1.8a | The normal force and center of pressure through Mach 1 | done |
| M1.8b | Drag through Mach 1: the transonic rise and supersonic wave drag | done |
| M1.8b1 | The drag of noses, shoulders and steps through Mach 1, against NASA’s Arcas Robin wind tunnel | done |
| M1.8b2 | Drag against RASAero II’s from Mach 0.1 to 2 | done |
| M1.8b3 | The drag of a boattail faster than sound, and the base behind it | done |
| M1.8c | Roll from canted fins, roll damping, and pitch and yaw damping (kept as each part’s local-flow damping) | done |
| M1.8d | Tables that override the normal force and center of pressure, read from RASAero II | done |
| M1.8e | The body’s normal force faster than sound, which slender-body theory underestimates past Mach 3; closed with its 15% target missed for the body alone (ADR-040, ADR-143) | done |
| M1.8e1 | The second-order shock-expansion method: the lift a body’s cylinder carries behind its nose faster than sound, checked against its report’s tables | done |
| M1.8e2 | The body’s supersonic normal force in a flight: the nose and its cylinder, joined to the subsonic model | done |
| M1.8e3 | Faster than sound: the blend into the shock-expansion method now starts at the exact Mach where the method starts to hold, not rounded to a 0.05 step | done |
| M1.8e4 | Faster than sound: a boattail, and a tube behind it, take their share of the body’s normal force from the shock-expansion method | done |
| M1.8e5 | Faster than sound: how much of the Arcas Robin’s remaining gap each missing effect (crossflow, the blunt tip, and others) explains, measured before modeling | done |
| M1.8e6 | The size of crossflow lift at every speed (Jorgensen) and a boattail’s measured share faster than sound (Washington and Pettis), the causes that measurement ranked first, in flight | done |
| M1.8e7 | Faster than sound: blunt and vertical nose tips (power-series, Haack and elliptical noses) by a Newtonian cap ahead of the shock-expansion method | done |
| M1.8e8 | Faster than sound: the lip behind a boattail, so that the committed Arcas Robin designs fly the shock-expansion method | done |
| M1.8e9 | Faster than sound: a bound on the boattail angle, footnote 8’s size pinned by hand, and the Arcas Robin wind tunnel’s 15% target judged | done |
| M1.8e10 | A lip’s shelter weighed as the drag buildup weighs it, instead of switching the whole body’s model at a threshold, and the size of every switch that remains | done |
| M1.8e11 | Cone slopes from 24° to 30°, from NASA SP-3007, where TN 3527’s own chart stops | done |
| M1.8e12 | What a blunt tip’s handover cap is worth once the cone slopes reach 30°, and what stops it moving there | done |
| M1.8e13 | What puts a marched answer at the mercy of the mesh: the surface pressure crossing its tangent cone’s, counted and told apart from a reduced element | done |
| M1.8e14 | Where the method stops marching a flare, bisected over Mach, and what the edge is made of | done |
| M1.8e15 | What a step in radius still switches, how big it is, and what a model of one would need | done |
| M1.8e16 | A blunt tip’s handover moved past 24°, once the march has a rule for the loading through a crossing (the rest of what M1.8e13 used to be, renumbered so the flare and the step keep their ids). Blocked, and deferred above Mach 4 with issue #108 (ADR-143); the vertical tip’s error goes to M1.14d below Mach 2.5 and M1.14h above | blocked |
| M1.8e17 | A flared body flown through the method where its shock is attached, with nothing jumping across that boundary as the model changes (the second of the three the old M1.8e14 splits into) | done |
| M1.8e18 | NASA TN D-4865 model 2’s readings committed, and what a marched flare is worth (the third of the three the old M1.8e14 splits into) | done |
| M1.8e19 | The band of near-flat flares the march used to refuse, which took the whole body off the method as a shape crossed it (found by M1.8e17); now read by the generalized method | done |
| M1.9 | Staging, clusters and air starts, for COTS motors | done |
| M1.9a | Motors lit at their own times, and a sustainer that flies on after a powered separation while the booster lands on its own, with tests for the ignition times, the mass step, the order of events and a trigger that never fires (ADR-074, Staging) | done |
| M1.9b | Several motors in one mount, their thrusts and masses summed, a motor out turning the rocket as a hand calculation predicts, and a .ork file’s clusters read with every tube where OpenRocket puts it (ADR-075, Clusters) | done |
| M1.9c | A two-stage and a cluster design from .ork files, each within the per-case tolerance of OpenRocket’s flight: every flight of each within 5% in apogee and largest speed (ADR-076, Staging) | done |
| M1.10 | Flight outputs: the stability margin over the flight, the best ejection delay, the peak dynamic pressure, fin flutter and the landing point | done |
| M1.10a | A flight’s peaks, its apogee with the height it counts from, its static and in-flight stability margins from the rail exit to apogee, each motor’s optimum ejection delay and each landing’s latitude and longitude, with None for what didn’t happen (ADR-077, Flight metrics) | done |
| M1.10b | Fin flutter speed and margin from a cited primary source, matching its worked example (ADR-078, Fin flutter) | done |
| M1.10c | Flights written as CSV, JSON, KML and GeoJSON files (Parquet optional), checked by schema and by parsing | done |
| M1.10c1 | A recording written as CSV or JSON, and the flight path with its landings as GeoJSON (checked against the published schema) or KML (checked by parsing) (ADR-079, Exporting a flight) | done |
| M1.10c2 | A recording written as Parquet, behind a cargo feature, and read back the same by Apache’s own Parquet library (ADR-080, Exporting a flight) | done |
| M1.11 | Ejected nose cones, body sections and payloads, each flown to its own landing | done |
| M1.11a | The airframe parting at any joint or around a payload, every piece landed under its own parachute (ADR-085, Recovery: ejected pieces) | done |
| M1.11b | The push of an ejection charge on the pieces, and a tumbling piece (ADR-086, Recovery: ejected pieces) | done |
| M1.12 | Payload mass that moves, or is released, during the flight | done |
| M1.12a | Ballast or a payload that slides along the airframe in flight, with the mass properties, the margin and the equations of motion following it (ADR-087, Moving mass) | done |
| M1.12b | Ballast or a payload released in flight, the rest flying on and the part falling on its own (ADR-088, Released mass) | done |
| M1.13 | Pods: bodies mounted beside the airframe, with or without motors | done |
| M1.13a | A pod’s mass: one pod repeated around the axis, each copy with its parallel-axis term, a motor in a pod one per pod (ADR-089, Pods) | done |
| M1.13b | Pods read from a .ork file | done |
| M1.13b1 | Pods of body components read from a .ork file, placed as OpenRocket 24.12 places them (ADR-090, .ork: Pods) | done |
| M1.13b2 | Pods of no length, which hang fins or a lug off the axis, and an empty pod set, read from a .ork file (ADR-091, .ork: Pods) | done |
| M1.13c | Pod aerodynamics from a cited source, and a pod design against OpenRocket | done |
| M1.13c1 | Pods fly: each pod’s parts with Barrowman’s normal force and their own drag, once per pod (ADR-092, aerodynamics: Pods) | done |
| M1.13c2 | A pod design with bodies and fins against OpenRocket, the limits of both codes’ pod models stated (ADR-093, aerodynamics: Pods) | done |
| M1.14 | Accuracy inside the operating envelope: the core band (Mach 0 to 2.5) first, then the extended band (Mach 2.5 to 3.5) in M1.14h, at angles of attack up to 15° (higher angles are M1.14e’s); real flights within the 5% apogee target, and at least as accurate as OpenRocket on the same flights (ADR-143) | not yet done |
| M1.14a | Four warning flags, each tested at its edge. Beyond the validated range: faster than the fastest public whole-flight reference, any committed comparison of a public flight against an independent reference (OpenRocket’s example at Mach 1.147 today; private flights never set it). At high angle of attack: above 15° more than 1 s after leaving the rail, at any Mach. Outside the core band: past Mach 2.5. Beyond the envelope: past Mach 3.5. And the aerodynamics page split by Mach band | done |
| M1.14a1 | Envelope flags | done |
| M1.14a2 | Drag issue warnings: issues #67, #68, #70, #72 and #222 warn by number when a flight meets their Mach and shape conditions (ADR-180) | done |
| M1.14a3 | Stability issue warnings: issues #87, #120, #121 and #172, where stability reads high, warn by number | done |
| M1.14b | New references from Mach 1.5 to 2.5: a public database of flights with simulator predictions, the free-flight coefficients of a standard finned test body (the Basic Finner), NASA’s six-degree-of-freedom check cases, and the validation uncertainty of each real flight. Two listed sources are refused (the reference note, §3 and §4): the Army Research Laboratory report ARL-TN-1128, which defines a shape, the High-Speed Army Reference Vehicle (HARV), and holds no coefficients; and a Mach 2.45 wind-tunnel drag point, whose authors measured a drag coefficient about a quarter of their own simulation’s and say their force setup should be reconsidered | not yet done |
| M1.14b1 | The Basic Finner’s normal force against DREV’s range | done |
| M1.14b2 | The Basic Finner’s drag and pitch damping against DREV’s range | done |
| M1.14b3 | NASA’s check cases 1 and 2 | done |
| M1.14b4 | NASA’s check cases 3 and 6 to 10 | done |
| M1.14b5 | Tip-off, measured with RocketPy’s | done |
| M1.14b6 | Wind from the GPS descent, against the reanalysis | not yet done |
| M1.14b7 | A validation uncertainty for each real flight | not yet done |
| M1.14b8 | MAPLEAF as a second open oracle | not yet done |
| M1.14b9 | The tip-off pivot, held to RocketPy’s | not yet done |
| M1.14b10 | Tip-off in every flight that has two guides | not yet done |
| M1.14b11 | The tip-off phase, held to RocketPy’s on RocketPy’s normal force | done |
| M1.14b12 | The crosswind tip-off on HPR Sim’s own normal force | not yet done |
| M1.14b13 | The tip-off reference at RocketPy’s rewritten phase | done |
| M1.14b14 | What tip-off moves on the real flights | done |
| M1.14b15 | Tip-off by default | not yet done |
| M1.14c | The normal force and drag near Mach 1, from 0.8 to 1.2, with the row at Mach 1.08 of the Basic Finner’s normal force | not yet done |
| M1.14d | Faster than sound, Mach 1.2 to 2.5. First the four shapes that fall back to slender-body theory and so read more stable than they are: a step in a body’s radius (issue #87), a flare behind a boattail too long for its wake (issue #120), a pointed tip steeper than 30° (issue #121) and a vertical tip steeper than its cap. Then drag, where HPR Sim reads 5.1% to 14.9% below RASAero II on RocketPy’s Calisto rocket, and the body-alone misses M1.8e left from Mach 1.5 to 2.3; and the rows from Mach 1.29 to 2.38 of the Basic Finner’s normal force | not yet done |
| M1.14e | Large angles of attack: what the legal 20 mph wind costs, and a high-angle model if it costs more than 1%; how long the first moments off the rail stay steep, which tests the 1 s the high-angle flag allows; and the issues about high angles | not yet done |
| M1.14f | Missing physics, ranked: misalignments, airframe drag under a parachute, base drag with the motor burning, gusts, parachute opening loads and more | not yet done |
| M1.14g | Generated figures on every accuracy and aerodynamics page, each with its reference and the error shown | not yet done |
| M1.14h | The extended band, Mach 2.5 to 3.5, after the core band: each fixed or re-measured in a decision record. The four switches’ errors as measured at Mach 3, where the center of pressure moves aft and the rocket reads more stable; the near-flat flare’s step at Mach 2.90 to 2.95 (issue #108), which way it errs not yet measured; and M1.8e’s body-alone row at Mach 2.96, 16.9% high in its normal-force slope, which tends toward the conservative side on a finned rocket, whose center of pressure then reads forward; and the two rows above Mach 2.5 of the Basic Finner’s normal force, the slope low and the center of pressure forward | not yet done |
| M1.14i | Drag below Mach 0.8 | done |
| M1.14i1 | The drag part of the gap to OpenRocket, by Mach band | done |
| M1.14i2 | The part below Mach 0.8, by term | done |
| M1.14i3 | Its largest term, held to a measurement | done |
| M2.1 | The validation harness, and comparisons with RocketPy | done |
| M2.1a | The harness itself: cases, reference data, tolerances and reports | done |
| M2.1b | Whole flights against RocketPy, with both codes given the same drag | done |
| M2.1b1 | The script that flies RocketPy’s example rockets from pad to landing, as the reference | done |
| M2.1b2 | HPR Sim’s whole flights compared with that reference | done |
| M2.1c | The same cases flown with each code’s own drag, a CI job, and regenerating references | done |
| M2.1c1 | A CI job that checks every case against its stored reference, and a workflow, run only by hand, that regenerates the references | done |
| M2.1c2 | The same cases flown with each code’s own drag | done |
| M2.1d | The time-series comparison, and where a rocket goes in wind (issue #50, why HPR Sim turned into the wind less) | done |
| M2.1d1 | Each whole flight’s height and speed, compared over time with RocketPy’s | done |
| M2.1d2 | Juno III, Calisto and Bella Lui in still air, as committed cases to measure the wind against (issue #50, why HPR Sim turned into the wind less) | done |
| M2.1d3 | Why HPR Sim turned into the wind less than RocketPy (issue #50): RocketPy’s equations, corrected, and HPR Sim’s body lift | done |
| M2.2 | OpenRocket as a reference program, and a corpus of designs to compare; closed with M2.2f, L19’s tube-fin bar missed and pinned | done |
| M2.2a | Each design’s structure (every stage, no motor): mass, center of mass and inertia against OpenRocket’s | done |
| M2.2b | OpenRocket’s mass conventions and roll inertia, split into M2.2b1 to M2.2b5 below; the stored results moved from the third to the fourth when ADR-062 split the fins off, and to the fifth when ADR-063 split the packed parts off; rolled up in ADR-101 | done |
| M2.2b1 | What a .ork leaves unsaid (a wall or shoulder of no thickness, no thickness written, no material) read as OpenRocket reads it, and which override wins | done |
| M2.2b2 | Fins and rail buttons against OpenRocket: where the roll inertia’s gap comes from, how each fin section is weighed, and where a rail button sits | done |
| M2.2b3 | Packed parts (parachutes, streamers, shock cords, mass components) against OpenRocket: the size one takes when its file writes none, and a mass override on one that weighs nothing | done |
| M2.2b4 | Motor clusters, fin fillets and the parts kept unread | done |
| M2.2b5 | Stored results in a .ork used as a reference only when they are current and plausible | done |
| M2.2c | The motors OpenRocket flies, for the configurations held back for want of a thrust curve, split into M2.2c1 and M2.2c2 below by ADR-066 | done |
| M2.2c1 | Every curve HPR Sim flies integrated as OpenRocket 24.12 integrates it, to the milestone’s 0.1% in total impulse | done |
| M2.2c2 | The curves the reference library embeds, and the configurations held back for want of one, supplied from OpenRocket’s own motor database by ADR-067 | done |
| M2.2d | Flights to apogee on the public designs, against OpenRocket, split into M2.2d1 and M2.2d2 below by ADR-068 | done |
| M2.2d1 | OpenRocket 24.12 flies the public designs; what each of its summary words measures is written down for that version, and other versions’ are withheld; a metric for an event that never happened is never scored | done |
| M2.2d2 | HPR Sim flies the configurations of that record it can fly, in a report against OpenRocket’s apogee, largest speed and stability margin (ADR-069, results) | done |
| M2.2e | The corpus, with a hypothesis for every apogee miss over 5%, split into M2.2e1 to M2.2e10 below by ADR-070, ADR-072, ADR-094, ADR-095, ADR-098 and ADR-100 | done |
| M2.2e1 | The flight report adds how far HPR Sim’s mass and center of mass are from OpenRocket’s, at launch and as the rocket leaves the rod (ADR-070, results) | done |
| M2.2e2 | OpenRocket flies the private designs, kept out of the repository; only counts are published (ADR-071, results) | done |
| M2.2e3 | HPR Sim flies the private designs, in a report of anonymized ids that publishes differences, never a design’s values: 17 flights of 4 of 12 designs, so 9 designs with the public report’s 5 (ADR-072, results) | done |
| M2.2e4 | A written cause for every apogee more than 5% from OpenRocket’s, sized by OpenRocket’s own flight without it: four of the five within 5% after, the fifth +7.80% with the no-drag part removed from both programs (ADR-073, results) | done |
| M2.2e5 | A tilted launch rod flown as OpenRocket records it: its angle from the vertical and the compass bearing it leans toward, checked on four public probe designs (bearing at apogee within 0.03 degrees, the tilt’s apogee loss within 0.27 percentage points) and adding one private design, 15 in all (ADR-094, results) | done |
| M2.2e6 | The single override flag older OpenRocket files use for a part and everything inside it, read as OpenRocket 24.12 reads it, measured on eleven probe designs and held by a test; one more private design flies, 16 in all. Not met for the second design the flag held: it also waits on a stage separation HPR Sim can’t fly (#184) (ADR-095, results) | done |
| M2.2e7 | Fin fillets and an inner tube whose automatic radius has nothing to take, read as OpenRocket reads them, so that the two private designs they hold back fly (#174). Measured on 21 new probes: the fillets’ mass and center of mass to 1e-15, and every part inside a nose cone but one packed mass component (#186) at OpenRocket’s mass to 1e-14 and station to 1e-15. Both designs fly, 18 designs compared across both reports, of the 20 M2.2e10 needs. The one supersonic flight climbs 13.60% higher than OpenRocket’s; on OpenRocket’s own drag it is +1.11%, so its cause is in the drag (#222) (ADR-096, ADR-097, results) | done |
| M2.2e8 | Tube fins whose radius OpenRocket works out from the body, resolved as OpenRocket 24.12 does (#133). Measured on 19 new probes: the radius within 1e-15, the tube fins’ mass to 1e-14; OpenRocket’s tube fin example now reads, its mass within 5e-6 of OpenRocket’s. Its roll and pitch inertia are departures: OpenRocket’s roll is larger than any mass inside the ring could have, and its pitch leaves out how far the tubes sit from the axis. The example’s flight moved to M2.2e9 (ADR-098, results) | done |
| M2.2e9 | Tube fin aerodynamics: a cited method for the normal force and drag of tube fins, pinned by tests, so that OpenRocket’s tube fin example flies within M2.2e4’s bar: an apogee more than 5% off has a sized cause. Each tube flies as a ring wing below Mach 0.8. The example’s apogee is 6.95% above OpenRocket’s, sized as HPR Sim’s drag by flying OpenRocket’s; 19 designs compared across both reports (ADR-099, Tube fins) | done |
| M2.2e10 | At least 20 designs across the two reports with all five spreads (apogee, largest speed, margin, mass and center of mass), the bar M2.2e3 had, unchanged. Met by flying a motor whose ignition never comes unlit and loaded, as OpenRocket does, measured on five probes of its two-stage example: one more private design flies, 0.88% above OpenRocket’s in apogee, 20 in all (ADR-100, the rules) | done |
| M2.2f | The two lessons that kept the comparison open. Cases let off a pass-or-fail bar still count in the error statistics, against both references where a rocket has two (L82): tested. A tube fin set’s center of pressure within a quarter caliber of OpenRocket’s (L19): not met, measured and pinned by a test instead, as L18’s is. HPR Sim’s center is 1.07 calibers forward of OpenRocket’s on its Tube fin rocket, and no measurement says which is nearer (ADR-102) | done |
| M2.3 | Comparisons with real flights | not yet done |
| M2.3a | The weather over a launch site read from an ERA5 file, as RocketPy reads it (ADR-081, ERA5 weather files) | done |
| M2.3b | RocketPy’s logged flights flown in their ERA5 weather and compared with the logs (ADR-082, Accuracy: real flights) | done |
| M2.3c | The private designs that have a flight log, flown in their day’s weather, published as statistics. Blocked until 2026-10-04, when none of the private designs was the rocket of any logged flight (ADR-083); the private flight collection added that day has such pairs (ADR-151) | not yet done |
| M2.3c1 | Logged apogees: the private collection’s logged flights against HPR Sim’s and OpenRocket’s predictions | done |
| M2.3c2 | Logged traces: the same flights’ altitude traces, once their logs are read | not yet done |
| M2.3c3 | OpenRocket’s newest release | not yet done |
| M2.3c4 | One fixture repo | done |
| M2.3c5 | The corpus rechecked | done |
| M2.3c6 | The gap to OpenRocket, by cause | done |
| M2.3c7 | Faster than sound: published flights | not yet done |
| M2.3c9 | Every flight OpenRocket flies | not yet done |
| M2.3c10 | The fineness-3 nose probe | done |
| M2.3c11 | OpenRocket’s inputs along its flights, flown by HPR Sim | done |
| M2.3c12 | The split in the fixture report | done |
| M2.3c13 | The tangent-ogive nose’s line | done |
| M2.3d | Twelve public flights, predictions first | done |
| M2.3d1 | The predictions | done |
| M2.3d2 | The errors | done |
| M2.3d3 | The EuRoC 2022 predictions | done |
| M2.3d4 | A stage’s override that adds to its parts | not yet done |
| M2.3d5 | The Macie XL predictions | done |
| M2.3d6 | A stage’s added mass | done |
| M2.3d7 | The inertia beside an override that covers the parts | done |
| M2.3d8 | The stages an added mass is still refused on | not yet done |
| M2.3d9 | The inertia with a motor aboard | not yet done |
| M2.3d10 | A parallel stage’s added mass | done |
| M2.3d11 | The stage a parallel stage hangs on, weighed with it | not yet done |
| M2.3d12 | An added mass on parts that weigh nothing | not yet done |
| M2.3d13 | Flights that move, release or part | not yet done |
| M2.3d14 | The rocket’s inertia beside a parallel stage’s covering override | not yet done |
| M2.4 | A summary of accuracy for the README, and CI that fails on any regression (ADR-084, Accuracy: the census) | done |
| M2.6 | An open benchmark | not yet done |
| M2.7 | Held-out flights, predictions first | done |
| M2.7a | The halves and the fits’ guard | done |
| M2.7b | New flights predicted first | done |
| M2.8 | Honest uncertainty | not yet done |
| M2.9 | The other tools’ cells | not yet done |
| M2.10 | Evidence register | done |
| M2.11 | Fin flutter held to measurement | not yet done |
| M2.12 | Descent rates against the logs | not yet done |
| M2.12a | The rule and the predictions | not yet done |
| M2.12b | The errors | not yet done |
| M2.13 | Landing points against the tracked landings | not yet done |
| M2.13a | The rule, the readings and the predictions | not yet done |
| M2.13b | The errors | not yet done |
| M2.14 | Speed off the rail against the accelerometer logs | not yet done |
| M2.14a | The rule, the readings and the predictions | not yet done |
| M2.14b | The errors | not yet done |
| M2.15 | Drag in the coast against the logs | not yet done |
| M2.15a | The rule, the readings and the predictions | not yet done |
| M2.15b | The errors | not yet done |
| M3.1 | Reading OpenRocket .ork design files | done |
| M3.1a | The container a .ork arrives in, and its design document read whole | done |
| M3.1b | The component tree: parts, shapes, materials, finishes and overrides into a design | done |
| M3.1b1 | What a .ork value means: dimensions OpenRocket works out for itself, tags written under two names, and overrides | done |
| M3.1b2 | The spine: the stages and the body components stacked in them, with their automatic radii marked for the layout to resolve | done |
| M3.1b3 | The parts on and inside the body, with their positions and the dimensions they take from their parents | done |
| M3.1b4 | The three designs of the 76 whose rocket still did not lay out: a radius with nothing to take, and a document with no design | done |
| M3.1c | Motors, recovery, stages, and what OpenRocket last simulated | done |
| M3.1c1 | A design’s motor configurations, the motors in them, and their thrust curves | done |
| M3.1c2 | When each parachute and streamer opens, and when each stage separates | done |
| M3.1c3 | The launch conditions and results of the simulations OpenRocket stored | done |
| M3.1c4 | Pods, parallel stages, and every part, section, tag and attribute HPR Sim does not read, kept for writing the file back | done |
| M3.1d | The corpus and the cross-check against RocketSerializer | done |
| M3.1d1 | Snapshots of what HPR Sim reads from public .ork designs | done |
| M3.1d2 | Every .ork imports without an error, and the cross-check against RocketSerializer | done |
| M3.2 | Writing OpenRocket .ork files | done |
| M3.2a | The writer: a design written back out as a .ork, reading back as the same design (ADR-109, Writing a .ork) | done |
| M3.2b | OpenRocket 24.12 loading and flying the written files, within 0.5% of the original’s apogee (ADR-110, Checked in OpenRocket) | done |
| M3.3 | The HPR design format, an open design file format of the project’s own | done |
| M3.3a | The document: a design as canonical JSON with its schema, every corpus design through it and back to .ork flying to the same apogee (ADR-111, The HPR design format) | done |
| M3.3b | The zip container (.hprz), the first migration (0.1 to 0.2), the comparison with other formats, and hpr convert and hpr sim taking .hpr and .hprz (ADR-112, The HPR design format) | done |
| M3.3c | TypeScript and Python types generated from the schema, each with a reader that checks a document (ADR-113, TypeScript and Python) | done |
| M4.1 | A simpler interface, with a builder for environments, motors, rockets and flights | done |
| M4.1a | The builder: environments, motors, rockets part by part, and flights, over the crates’ own types (ADR-103, The builder) | done |
| M4.1b | Models of your own: a drag model the flight calls in place of the simulator’s, through a trait, with a guide in the API reference (ADR-104, Models of your own) | done |
| M4.2 | A command-line tool | done |
| M4.2a | The command line’s commands, its JSON output and exit codes, shell completions, and looking up motors (ADR-105, The command line) | done |
| M4.2b | Flying a design from the command line (hpr sim), with its recording exported (ADR-106, The command line) | done |
| M4.2c | Checking the validation cases (hpr validate) and converting motor files (hpr convert) from the command line (ADR-107, hpr convert; hpr validate has since left the published hpr for cargo xtask validate --check, ADR-187, what it checks) | done |
| M4.2d | Reading a flight log from the command line (hpr analyze), with no design file: PerfectFlite’s .pf2 first, and liftoff, apogee, the top speed and landing (ADR-108, Reading a flight log) | done |
| M4.3 | Python bindings | done |
| M4.3a | The hpr Python package: the builder’s environment, motor, rocket and flight, designs read from files, recordings as NumPy arrays, and wheels built and tested on three operating systems (ADR-114, Python) | done |
| M4.3b | A drag table on a flight, and RocketPy’s example rocket, Calisto, flown from Python within 3% of RocketPy (ADR-115, Python) | done |
| M4.3c | Drag and wind models written as Python functions, their exceptions raised in Python (ADR-116, Python) | done |
| M4.5 | Fly my .ork: OpenRocket’s example designs fly as saved in hpr sim, with their recovery, offline after one motor download (ADR-144); Base drag hack’s E12-4 not met (M4.5o) | done |
| M4.5a | Parachutes and streamers from a .ork flown, with their triggers (issue #240) | done |
| M4.5b | A missing motor fetched from ThrustCurve and kept, and the exact command to fetch it printed when offline | done |
| M4.5c | Design checks that warn, with a cited tolerance, on fits builders make every day, and refuse only impossible ones | done |
| M4.5d | Output a person reads: configurations by name, results in sentences, the summary led by margin, apogee and rail exit speed | done |
| M4.5e | hpr sim --plot: a flight’s altitude, speed and acceleration drawn as an SVG figure | done |
| M4.5f | How-to guides: fly your .ork, pick a motor, check stability for a certification flight | done |
| M4.5g | Then unpowered separations, freeform fins and several separations, in order of how many designs each holds back | done |
| M4.5g1 | A powered separation in hpr sim | done |
| M4.5g2 | Several separations | done |
| M4.5g3 | An unpowered separation before apogee | done |
| M4.5g4 | Freeform fins | done |
| M4.5h | A part’s drag override | done |
| M4.5i | A powered pods example | done |
| M4.5j | The CLI’s corpus count | done |
| M4.5k | A ring around its tube | done |
| M4.5l | A packed part wider than its bore | done |
| M4.5m | Parallel booster staging | done |
| M4.5n | Pods--powered’s first configuration | done |
| M4.5o | Base drag hack’s E12-4: an elliptical nose’s subsonic drag taken from Hoerner’s measurement and pinned by a test; the E12-4 stays 7.80% above OpenRocket’s apogee, so the 5% bar is not met (ADR-173) | done |
| M4.6 | Monte Carlo from the CLI and Python: apogee and landing spreads without writing Rust | done |
| M4.6a | hpr mc | done |
| M4.6b | Monte Carlo in Python | done |
| M5.1 | The online layer, with an on-disk cache for working offline | done |
| M5.1a | The cache, its freshness rule and an offline mode that never fetches, tested with a hand-written sample response (ADR-117, Online data and the cache) | done |
| M5.1b | The HTTP transport, with rustls, behind a cargo feature, and the platform’s cache folder, tested against a server on the loopback address (ADR-118, Online data and the cache) | done |
| M5.2 | Weather forecasts, turned into atmosphere and wind profiles | done |
| M5.2a | A launch site’s weather from Open-Meteo, forecast or archived, as a sounding: the ground and the pressure levels above it (ADR-119, Launch-day weather) | done |
| M5.2b | Weather-balloon soundings from the University of Wyoming’s archive, as a sounding: the ground and every level above it (ADR-120, Weather-balloon soundings) | done |
| M5.2c | NOAA’s GFS and RAP forecasts from NOMADS, as a sounding: a small GRIB2 cut around the site, read by the project’s own decoder and checked value for value against ecCodes (ADR-121, NOAA forecasts: GFS and RAP) | done |
| M5.2d | Weather files you download, and the hpr weather command: the command done in M5.2d1; NOAA’s whole files in M5.2d2, complex packing and M5.2d3, JPEG 2000 | done |
| M5.2d1 | hpr weather: a launch site’s profile from Open-Meteo, a Wyoming sounding, GFS, RAP or an ERA5 file, fetched, from the cache, or from a saved answer (ADR-122, The command line) | done |
| M5.2d2 | NOAA’s whole GRIB2 files: complex packing, checked against ecCodes on every value of a whole GFS file (ADR-123, A whole GFS file) | done |
| M5.2d3 | NOAA’s whole GRIB2 files: JPEG 2000, checked against ecCodes on four public RAP fields (ADR-124, Files in JPEG 2000) | done |
| M5.3 | Launch-site data: magnetic declination in M5.3a, ground elevation in M5.3b, distances between places and a user’s elevation file in M5.3c | done |
| M5.3a | Magnetic declination from the World Magnetic Model, WMM2025, checked against NOAA’s test values (ADR-125, The magnetic field) | done |
| M5.3b | A launch site’s ground elevation from Open-Meteo, cached so it works offline after the first lookup (ADR-126, A launch site’s elevation) | done |
| M5.3c | Distance and bearing between two places on the WGS 84 ellipsoid, and a site’s elevation from a GeoTIFF file the user gives; split in two (ADR-127) | done |
| M5.3c1 | Distance and bearing between two places on WGS 84, checked against Karney’s published set of 500,000 geodesics (ADR-127, Geodesy) | done |
| M5.3c2 | A launch site’s elevation from a GeoTIFF file the user gives, checked against GDAL’s reading through rasterio on seven files and a whole USGS tile (ADR-128, A launch site’s elevation) | done |
| M5.4 | Motor stock and prices from motor.fusionspace.co, joined with ThrustCurve.org’s motors; split in three (ADR-129) | done |
| M5.4a | The motor finder’s files (its build, every motor, those in stock, the vendors, one motor’s page) read through the cache, so they work offline, each carrying the credit the site asks for (ADR-129; its CC BY 4.0 credit, ADR-145; Motor stock and prices) | done |
| M5.4b | ThrustCurve.org’s search and a motor’s thrust curve through the cache, and the motors in stock matched to ThrustCurve.org’s by name, with a report of the misses: 282 of 282 matched (ADR-130; the tests’ stand-in searches, ADR-145; Motor stock and prices) | done |
| M5.4c | hpr motors search: motors in stock by class and price, from the network, a saved list or offline, with both sources’ credit on every list (ADR-131, Motors you can buy) | done |
| M5.5 | A catalog of parts: OpenRocket’s parts files, looked up by maker and part number, and parts from them in a design; split in two (ADR-132) | done |
| M5.5a | The 16 .orc parts files OpenRocket ships, bundled and read, every part held to OpenRocket’s own reading: 3,449 parts, 17,911 values to the bit, the rest counted with their causes (ADR-132, OpenRocket .orc parts catalogs) | done |
| M5.5b | Catalog parts in the builder, and a rocket of them flown: all 3,449 parts built and held to what OpenRocket builds, the departures counted with their causes (ADR-133, parts from a catalog) | done |
| M5.6 | A catalog of the project’s own | not yet done |
| M5.6a | Format, search and a parts list | not yet done |
| M5.6b | Parachutes and recovery hardware | not yet done |
| M5.6c | Motor hardware and rail buttons | not yet done |
| M5.6d | More makers and electronics | not yet done |
| M5.7 | Every solid motor, offline | done |
| M5.7a | Each file’s check and the default file | done |
| M5.7b1 | The whole catalog compiled in | done |
| M5.7b2 | Every motor by name, offline | done |
| M5.7c | Every passing file held to the oracles | done |
| M5.7d | Newer motors online, and the bundle described | done |
| M6.1 | Monte Carlo runs and sensitivity; split in four (ADR-134) | done |
| M6.1a | Seeded dispersion of mass, center of mass, drag, motor, wind, rail and recovery delays; each flight the same whatever the run’s size or thread count; failed flights counted; the apogee’s spread (ADR-134, Monte Carlo dispersion) | done |
| M6.1b | Landing ellipses holding a chosen share of the landings, checked against normal spreads with known answers; the next flight’s ellipse; the landings each holds counted (ADR-135, Landing ellipses) | done |
| M6.1c | Sensitivity analysis, Morris screening and Sobol’ indices, checked against functions with known answers within their own standard errors (ADR-136, Sensitivity analysis) | done |
| M6.1d | 10,000 flights of a Level 2 rocket (one on a J, K or L motor) in 10 s or less, timed and recorded: 3.0 s for Valetudo, 9.4 s for a rocket past Mach 1.6, a run’s flights sharing one layout and one supersonic table (ADR-137, How long a run takes) | done |
| M6.2 | Design optimization; split in five (ADR-138) | not yet done |
| M6.2a | CMA-ES over continuous design variables, held to four test functions’ known minima and to pycma, its author’s implementation; a rocket’s ballast and body length found for a 3,048 m (10,000 ft) apogee and a 2.2-caliber margin, and checked by flying it again (ADR-138, Optimization) | done |
| M6.2b | Discrete choices (a motor, a catalog part) and limits such as a minimum stability margin; split in two (ADR-139) | done |
| M6.2b1 | Limits on a design, such as a minimum stability margin: candidates that break one rank below those that don’t (Deb’s rules); held to three test problems whose limited minima are known | done |
| M6.2b2 | Discrete choices (a motor, a catalog part) as whole-number variables, by CMA-ES with margin; held to three mixed test functions’ known minima and to an outside implementation; a motor and a Madcow nose cone chosen for a 3,048 m (10,000 ft) apogee under margin and rail-exit limits, and checked by flying the winner again (ADR-140, Optimization) | done |
| M6.2c | Several goals at once: NSGA-II finds a Pareto front; held to the known fronts of three standard test problems (ZDT1 to ZDT3) and to an outside implementation (pymoo), and a rocket’s trade-off between apogee and static margin, flown again and checked against CMA-ES (ADR-141, Optimization) | done |
| M6.2d | Bayesian optimization (EGO) for costly flights, split d1, d2 (ADR-142) | done |
| M6.2d1 | EGO: a surrogate (kriging) fitted to the designs tried, and the next design where it expects the most improvement; Branin’s and Hartmann 3’s minima within 1% in 50 evaluations from 20 seeds (ADR-142, Optimization) | done |
| M6.2d2 | EGO on Hartmann 6, a six-variable test function whose local minimum traps M6.2d1’s EGO in 7 runs of 10; one attempt (ADR-142, ADR-144, Optimization) | done |
| M6.2e | Robust designs: a Monte Carlo run inside the optimizer | not yet done |
| M6.3 | Competition rules as files, with scoring, limits and presets | not yet done |
| M6.4 | Airbrakes, with a controller that aims for a target apogee | not yet done |
| M6.5 | Roll control, roll only: tail-fin tabs first, then canards | not yet done |
| M6.6 | Submission packs: the numbers Student Launch and IREC ask for, from one design | not yet done |
| M6.7 | Ejection charges: black-powder size for a bay, always “ground test first” | not yet done |
| M6.8 | Field kit: checklists, the settings check and the ground-test log | not yet done |
| M3.4 | RockSim .rkt files in and out | not yet done |
| M3.5 | RASAero .CDX1 files in and out | not yet done |
| M3.6 | RocketPy scripts and files in and out | not yet done |
| M4.4 | Use from C, and in the browser through WebAssembly | not yet done |
| M7.1 | Reading flight logs from altimeters and trackers, with no design file and no simulation | done |
| M7.1a | The flight record every reader fills, a survey of the sample logs, and the PerfectFlite, AltOS and Raven readers | done |
| M7.1b | The RRC3’s, Eggtimer’s and the Blue Raven’s CSV, each unit a header leaves out decided from the file or stated as assumed | done |
| M7.1c | The other loggers’ formats, spreadsheets and generic CSV | done |
| M7.1c1 | GPS tracks | done |
| M7.1c2 | The rest | done |
| M7.1c3 | Club layouts | done |
| M7.1c4 | AerospaceNU’s board, a phone app’s CSV, Eggtimer RTF | done |
| M7.1c5 | Raw downloads, checked against their makers’ exports | done |
| M7.1c6 | Featherweight’s summaries | done |
| M7.1c7 | Archives and two readers’ variants | done |
| M7.1c8 | The R-DAS’s raw text | done |
| M7.1c9 | AltOS telemetry | done |
| M7.1c10 | AltOS raw downloads | done |
| M7.1c11 | ARTS2 raw data | done |
| M7.1c12 | Missile Works’ RTx GPS tracker | done |
| M7.1c13 | Tables read by their headers | done |
| M7.1c14 | Excel workbooks | done |
| M7.1c15 | EuRoC exports and mappings a publisher states | done |
| M7.1c16 | Binary records by a stated layout | done |
| M7.1c17 | The Blue Raven’s USB download | done |
| M7.1c18 | A course’s Teensy data logger | done |
| M7.1c19 | Radio packets, 255:…:254 | done |
| M7.1c20 | Workbooks with a reading beside | done |
| M7.1c21 | Altimeters’ other text | done |
| M7.1c22 | Tables by mapping, and files that aren’t logs | done |
| M7.1c23 | The last binaries; formats with no sample | done |
| M7.1d | A flyer’s own logger and GPX tracks | done |
| M7.1d1 | GPX tracks | done |
| M7.1d2 | Your own logger from the command line and Python | done |
| M7.2 | The readings a flight gives, each with where it came from, and reconstructing the flight from its log | done |
| M7.2a | The synthetic flights, each with its truth and its logger’s log | done |
| M7.2b | The readings on every logger | done |
| M7.2c | The rest of the readings | done |
| M7.2d | Reconstructing the flight: a smoother over the barometer, accelerometer and GNSS | done |
| M7.2e | 90% intervals on the readings, tested on the synthetic flights | done |
| M7.2e1 | The test, on the apogee | done |
| M7.2e2 | The height track’s other readings | done |
| M7.2e3 | The accelerometer’s readings and the canopies’ | done |
| M7.2e4 | The intervals in hpr analyze and Python | done |
| M7.2f | Two recordings of one flight, and stages | done |
| M7.2g | Ghost files: the flight as JSON, CZML and glTF | done |
| M7.3 | A flight against its simulation: residuals, and fitting drag, mass, impulse and wind to the log | not yet done |
| M7.3a | Residuals | done |
| M7.3b | The least-squares fit | done |
| M7.3c | The Bayesian option | not yet done |
| M7.3c1 | The posterior’s sampler | done |
| M7.3c2 | The Bayesian fit under the test | not yet done |
| M7.3c3 | The Bayesian option, counted | done |
| M7.3c4 | The Bayesian intervals pass | not yet done |
| M7.3c5 | The wind on a track | done |
| M7.3c6 | The drag on heights alone | not yet done |
| M7.3c7 | Every count | not yet done |
| M7.3d | From the boost | done |
| M7.3d1 | The prediction from the boost | done |
| M7.3d2 | The public flights | done |
| M7.3d3 | The collection by halves | done |
| M7.3d4 | The halves sealed | done |
| M7.3d5 | The cut on a real barometer | done |
| M7.3d6 | The collection’s errors by halves | done |
| M7.3d7 | The scoreboard row | done |
| M7.3e | The post-flight comparison | not yet done |
| M7.4 | Diagnosing what went wrong in a flight | not yet done |
| M7.5 | The bias every simulator shares | done |
| M7.5a | The rule before the fit | done |
| M7.5b | The correction, fitted and judged | done |
| M8.1 | A design assistant | not yet done |
| M8.2 | An editing model for apps: commands, undo and stable ids | not yet done |
| M8.3 | CAD interop: parts and designs out to meshes, drawings, FreeCAD and STEP, and meshes or STEP solids in as custom parts, through files only (ADR-144) | not yet done |
| M8.3a | Any part or the whole design written as a watertight mesh in millimeters: STL, 3MF or OBJ | not yet done |
| M8.3b | Dimensioned drawings (SVG, DXF, PDF): fins with bevels, rings, nose profiles and tube cut lists | not yet done |
| M8.3c | A generated FreeCAD script that rebuilds the design as a parametric feature tree, driven by a spreadsheet of its dimensions | not yet done |
| M8.3d | STEP export as solids, through a permissively licensed geometry kernel | not yet done |
| M8.3e | A mesh read in as a custom part: its mass properties computed exactly from the closed mesh and a material, its aerodynamics recognized as a body profile, a fin or a protuberance, or else marked as not modeled | not yet done |
| M8.3f | STEP solids read in as custom parts, once a reader with a suitable license is found | not yet done |
| M8.3g | Warnings for parts printed on a 3D printer: heat limits, layer direction, unvalidated flutter | not yet done |
| M9.0 | Choosing how the app is built, with trial builds | not yet done |
| M9.1 | A desktop app | not yet done |
| M9.2 | 3D flight replay, the real flight beside the simulated one | not yet done |
| M9.3 | A web app that works offline | not yet done |
| M9.4 | Mobile apps | not yet done |
| M9.5 | Optional accounts that save designs and flights and sync them across devices | not yet done |
| M9.6 | Neer’s four web tools (Motor Finder, Charge, Window, Muster) rebuilt as library code and app screens | not yet done |
| M9.7 | Field equipment and frequencies | not yet done |
| M9.8 | fusionspace.co, rebuilt | done |
| M9.8a | The page and its checks | done |
| M9.8b | The maintainer’s use | done |
| M10.1 | Release 0.1: the simulator | done |
| M10.1a | The flight and design fixes | done |
| M10.1b | The data, network and Python fixes | done |
| M10.1c | The release workflow | done |
| M10.1d1 | The release notes and the install pages | done |
| M10.1d2 | The missing warnings and the checklist | done |
| M10.1d3 | The friction and freeform fin warnings | done |
| M10.1d4 | The checklist | done |
| M10.1d5 | The separated parts’ warnings | done |
| M10.1d6 | The unknown signs | done |
| M10.1d7 | The designation and the design pin | done |
| M10.1d8 | The new name’s URLs | done |
| M10.1d9 | FusionSpace HPR | done |
| M10.2 | Release 0.2: the flight analyzer | not yet done |
| M10.3 | Release 0.3: accuracy and diagnosis | not yet done |
| M10.4 | Release 0.4: the competition kit | not yet done |
| M10.5 | Release 0.5: the app preview | not yet done |
| M10.6 | Release 1.0: the app | not yet done |
| M11.1 | A motor of your own | not yet done |
| M11.2 | Experimental solids | not yet done |
| M11.3 | Certified hybrids | not yet done |
| M11.4 | Nitrous blowdown | not yet done |
| M11.5 | Hybrid and liquid design | not yet done |
| M12.1 | Gores | not yet done |
| M12.2 | Opening loads | not yet done |
| M13.1 | Ground station | not yet done |
| M13.2 | GPS tracker logic | not yet done |
| M13.3 | Flight computer logic | not yet done |
| M13.4 | Hardware | not yet done |
| M13.5 | More tracker and flight-computer boards on one firmware | not yet done |
| M13.6 | Control hardware: drag-only airbrakes and roll-only tabs, held for a ruling | not yet done |
| M13.7 | Ground-test bench | not yet done |
Lessons from Loft
Loft was the project that came before this one. Its mistakes are listed as numbered lessons, such as Loft lesson L18, its made-up transonic drag curve, each with the test that guards against it here, or the milestone that will add one. The list of lessons says what went wrong, where in Loft, and how this project avoids it.
The lessons these pages name
Each lesson that a page of this site names has a row here. Its label opens its section of the list of lessons, which gives Loft’s evidence and the name of the test that guards it; the last column is the milestone that added or will add that test.
| lesson | what went wrong in Loft, or what the lesson records | guarded by |
|---|---|---|
| L1 | Loft used one constant gravity on a flat Earth, so it read low against RocketPy | M1.1 |
| L2 | Loft treated geometric altitude as geopotential, so its temperature and pressure were off at 11 km (6.8 mi) | M1.2 |
| L3 | Loft’s atmosphere had four layers, and its last temperature gradient ran on forever: 335 K at 70 km (43 mi), against 219.6 K | M1.2 |
| L4 | Loft’s air viscosity constants weren’t the 1976 standard’s, 1.3% high at sea level | M1.2 |
| L5 | Loft’s “today’s conditions” kept the standard temperature gradient above the field, with dry air and no sounding temperatures | M1.2 |
| L6 | Loft flew one wind vector; forecast profiles stepped at the lowest level; no gusts | M1.2 |
| L7 | Loft’s fin lift had no compressibility factor, so its slope and center of pressure never changed with Mach | M1.8a |
| L8 | Loft’s fin lift grew in proportion to the fin count, with no correction for 5 to 8 fins | M1.5a |
| L9 | Loft used the conical transition’s center-of-pressure formula for every transition shape | M1.5a |
| L10 | Loft took elliptical fins’ lift from an equal-area trapezoid with the wrong sweep | M1.5a |
| L11 | Loft merged fin sets into one for drag, so the result depended on their order | M1.5b |
| L12 | Loft’s drag used uncited constants, such as a body form factor of 1.95 where Niskanen gives 1.13 | M1.5b |
| L13 | Loft had no power-on base drag relief, which Niskanen’s drag method includes | M1.5b |
| L14 | Loft’s launch-lug drag was uncited, and rail buttons dragged as lugs | M1.5b |
| L15 | Loft gave a bare step in diameter no drag, and shoulder drag jumped to zero as a transition shrank | M1.5b |
| L16 | Loft silently capped the drag coefficient at 10, which hid malformed designs | M1.5b |
| L17 | Loft froze the fins’ leading-edge drag at its Mach 1 value, and gave nose and shoulder pressure drag no Mach term | M1.8 |
| L18 | Loft’s transonic wave drag was an invented curve, never checked against RASAero | M1.8 |
| L19 | Loft put a tube fin set’s center of pressure about 0.9 calibers forward of OpenRocket’s, and left out ring tails (a ring joining the fins’ tips). HPR Sim’s is 1.07 calibers forward, measured and pinned, not within the lesson’s quarter caliber (ADR-102) | M2.2f |
| L20 | Loft flew in 3-DOF: no angle of attack, body lift, damping or roll, and no weathercocking | M1.6b |
| L21 | Loft stepped with RK4 without error control, and never tested that the apogee converges | M1.6a |
| L22 | Loft didn’t locate events exactly: apogee fell on a step, altitude deployments overshot, landings were below ground | M1.6a |
| L23 | Loft let discontinuities such as burnout fall inside steps, and checked its vacuum case to only ±2% | M1.6a |
| L24 | Loft’s simulate() changed its inputs, so a second run of the same flight differed from the first | M1.6b |
| L25 | Loft labeled any early stop “step budget”, even a rocket that never lifted off | M1.6b |
| L26 | Loft’s launch rail had no friction and no button geometry | M1.6b |
| L30 | Loft fixed the staging before the flight, so an apogee or height separation fell back to the burnout, and it never flew the booster | M1.9a |
| L31 | Loft’s clusters sat on the axis only, so a motor out turned nothing, and it sent a mixed cluster to its oracle as copies of the first motor | M1.9b |
| L32 | Loft’s flutter constant was half of NACA TN 4197’s, so its flutter speeds were √2 too high, on the unsafe side, and 7 of its shear moduli had no source | M1.10b |
| L33 | Loft published static margins of ±12 to 15 calibers where the normal-force slope had all but cancelled and the margin meant nothing | M1.10a |
| L34 | Loft counted the opening shock as the peak acceleration, and read thrust spikes low from a finite difference of the speed | M1.10a |
| L35 | Loft used zeros for “never happened”, and never said which height apogee was measured from | M1.10a |
| L36 | Loft’s .eng reader read only the first header, and appended a second motor’s points to the first curve | M1.3 |
| L37 | Loft’s delay parsing lost P (plugged) and lists of delays, and read marker values as seconds | M1.3 |
| L38 | Loft’s impulse class letter was off by one at the top of each band | M1.3 |
| L39 | Loft didn’t check that a curve’s times increase, and took the last point as burnout instead of NFPA 1125’s rule | M1.3 |
| L40 | Loft fixed the motor’s center of gravity at the casing’s middle, with no inertia of its own | M1.3 |
| L41 | Loft bundled thrust curves under mixed or unknown licenses | M1.3 |
| L42 | Loft’s impulse checks were loose (±8%); a mis-sourced curve flew about 26% high until caught | M1.3 |
| L43 | ThrustCurve’s data must override a .eng header’s size: one listed a 54 mm motor as a 75 mm motor | M1.3 |
| L56 | Loft told a design file’s container apart by its first bytes, and a malformed one had to give an error rather than crash | M3.1a |
| L57 | Loft threw away the thrust curves stored inside a .ork archive | M3.1a, M3.1c1 |
| L59 | Loft resolved an automatic radius within a stage only, so a booster’s first component took a stale number | M3.1b2 |
| L60 | Loft resolved automatic dimensions as it walked the tree, so a ring’s bore depended on sibling order and a bulkhead inside a coupler stayed NaN | M3.1b3 |
| L61 | Loft weighed a ring with an automatic bore at 0 g, and dropped a stated wall when the outer radius was automatic | M3.1b2, M3.1b3 |
| L58 | Loft kept an automatic dimension’s number but lost the flag, so saving turned it into a hand-typed one | M3.1b1 |
| L62 | Loft met a tag written under two names, and read a stated 0 as a missing value | M3.1b1 |
| L63 | Loft read neither the drag override nor the subcomponent flags, so a part set to no drag was still charged drag | M3.1b1 |
| L64 | Loft read the wind’s direction from the launch rod’s, and dropped it from the stored conditions | M3.1c3 |
| L65 | Loft read a configuration from only one of the two places a .ork keeps it, and fired a motor whose mount it could not find from the top stage | M3.1c1 |
| L66 | Loft dropped pods, parallel stages and booster sets, and its export then lost the note that the rocket was reduced | M3.1c4 |
| L67 | Loft exported a plugged delay as 0 s, ignition only for the whole mount, no launch conditions, and masses it had worked out as overrides | M3.2a |
| L68 | Loft exported a freeform fin as a trapezoid of the same area (42% too big), lost a cluster’s scale and rotation, and rounded every number to six decimals | M3.2a |
| L44 | Loft’s inertia was pitch only, with simplified formulas, and zero for rings and masses | M1.4a |
| L45 | Loft put a hollow transition’s center of gravity at the solid’s centroid | M1.4a |
| L46 | Loft never read fin tabs (100 to 120 g lost on two designs), and rail buttons weighed nothing | M1.4a |
| L47 | Loft’s reference diameter was the widest part, even an internal one | M1.4b |
| L48 | Loft had tangent ogives only, a silent default nose shape, and swapped Haack names | M1.4a |
| L49 | Loft’s transitions used a kinked profile, never checked against what OpenRocket means | M1.4a, M3.1 |
| L50 | Loft let a motor wider than its mount fly (+69% apogee), and fins could sit off the airframe | M1.4b |
| L51 | Loft’s rule for which center-of-gravity override wins was unsettled (up to 133 mm (5.2 in)) and came from OpenRocket’s source | M2.2b1 |
| L75 | Loft’s RocketPy check wasn’t like for like: a different atmosphere, unstated latitude and gravity, and Loft’s own drag and mass fed to RocketPy | M2.1b, M2.1b2 |
| L76 | Loft’s advice to regenerate a reference when a check failed let the reference follow Loft’s own drag | M2.1a |
| L77 | Loft shipped hand-written “stored” results, one set inconsistent with itself | M2.1a |
| L78 | Loft’s test suites skipped themselves when their data was missing, and still reported a pass | M2.1a |
| L79 | Only 2 of Loft’s 12 metrics had a tolerance per case; a deployment speed 204% off passed as “ungated” | M2.1a |
| L80 | Same word, different quantity: Loft found the deployment and ground-hit speeds and the optimum delay differ by tool and OpenRocket version; this project has measured OpenRocket 24.12 only | M2.2d1 |
| L81 | Metrics for events that never happened, such as a deployment speed with no deployment, were scored as 0 | M2.2d1 |
| L82 | References 60% apart were excused as “no single target”, and known issues excused the two largest misses. Tested: every compared case counts, whatever explains a miss, against both references where a rocket has two | M2.2f |
| L84 | Loft wrote its counts by hand, for populations it didn’t name, and counted one disagreement 15 times | M2.4 |
| L85 | Loft’s check that a known gap had closed used half the tolerance, so it missed gaps that closed in between | M2.1b2, M2.4 |
| L86 | Loft published a headline accuracy figure without saying what it was compared with, over which rockets, or at what speeds | M2.4 |
| L88 | Loft’s only independent check held drag equal, so its own aerodynamics were never held to another code | M2.4 |
| L89 | Barrowman’s hand-worked values for a cone, a conical transition and an elliptical fin, which the project’s tests check | M1.5a |
| L90 | Properties any drag model must keep, such as split fin sets dragging like one set, which the project’s tests check | M1.5b |
| L91 | Exact volumes of nose cones (cone, tangent ogive, Haack), which the project’s tests check | M1.4a |
| L93 | Staging: the sustainer lights at the booster’s burnout plus its delay, the mass steps at the separation, and a trigger never reached lights nothing | M1.9a |
| L94 | The optimum ejection delay must come out the same whether the delay flown opens the parachute early or late | M1.10a |
| L95 | A degenerate design, with a zero radius, a NaN, no fins or a negative mass, must be refused or fly to finite numbers, never to a NaN | M4.1a |
Plan
Read the order of FusionSpace HPR’s releases, what each one will include, and how likely each goal is to work out.
The plan was made on October 6, 2026, from the roadmap as it stood that day. It goes out of date as work ships or the roadmap changes. It gives no dates: releases come at product boundaries.
In short
Releases come in this order. A release is out once Neer, the project’s owner, publishes it.
- Release 0.1, the simulator.
- Release 0.2, the flight analyzer.
- Release 0.3, accuracy and fault diagnosis.
- Release 0.4, the competition kit.
- Release 0.5, the app preview. It’s out once the project’s own acceptance pass is done and any changes it turns up are made.
- Release 1.0, the app. It’s out, again, once its acceptance pass is done.
- Everything else on the roadmap that’s software comes after 1.0.
The one goal that isn’t only software, an avionics board built and flown, follows Neer’s build and the launch calendar. So it comes in spring 2027 at the earliest.
The releases
| release | what it adds | also waits on |
|---|---|---|
| 0.1 the simulator | Monte Carlo from the command line and Python (Monte Carlo flies many copies of a flight with its inputs scattered); logged apogees from real flights; release builds and named fixes | nothing: it came out on 2026-10-08 (How a release is built) |
| 0.2 the flight analyzer | flight-log importers; readings and smoothing; a flight against its simulation | Neer publishing it |
| 0.3 accuracy and diagnosis | the accuracy campaign from Mach 0 to 2.5 (M1.14b to M1.14g and M1.14i); logged traces; fault diagnosis | Neer publishing it |
| 0.4 the competition kit | optimizing a Monte Carlo result; challenge presets; airbrakes; submission packs; ejection charges; RASAero and RocketPy files | Neer publishing it |
| 0.5 the app preview | C and WebAssembly bindings; the user-interface choice; 3D replay of a real flight beside its simulated ghost | Neer seeing it, then publishing it |
| 1.0 the app | the desktop editor; the web app that works offline; the design assistant; undo and edits; RockSim files | Neer seeing it, then publishing it |
| after 1.0 | canards, CAD files, phone apps, accounts, the extended Mach band, motor, parachute and avionics design | see below |
A release is out when Neer publishes it. For 0.5 and 1.0 it also takes the project’s own acceptance pass, and any changes that pass turns up.
How feasible each goal is
| goal | outlook | why |
|---|---|---|
| A simulation library on par with RocketPy | high; mostly done | The physics, staging, pods, Monte Carlo, optimization and Python bindings have shipped. |
| Accuracy: 5% mean apogee error on real flights, at least as good as OpenRocket | medium | Against 12 public real flights, HPR Sim’s apogees miss by 8.88% on average (Accuracy). Against 60 more from a private collection, rechecked against its catalog, HPR Sim’s apogees miss by 12.09% on average (mean absolute) and OpenRocket’s by 11.26%. Signed, HPR Sim’s are +8.01% above the logs and OpenRocket’s +6.72%. Neither meets 5%, and HPR Sim is close to OpenRocket (Accuracy). On real flights, the inputs limit accuracy too: motors vary in impulse, logged masses are off, the weather is uncertain. Matching OpenRocket is likely; the 5% mean may not hold everywhere. If the campaign stalls, its gaps are written down rather than hidden (the stopping rule). |
| Accuracy above Mach 1 | medium | Few real flights go supersonic. Of the 12 public flights, only Andromeda passes Mach 1, at Mach 1.019 in the simulation. In the project’s private collection of flight logs (not published), 5 of the 42 flights that state a top speed reach about Mach 1 or more, and more may show up when the rest of its logs are read. Flights near Mach 2 are rare. |
| File interop: OpenRocket, RockSim, RASAero, RocketPy | high | OpenRocket’s files fly today. The others follow known formats and earlier work. |
| Competition design and submission packs | high | Mostly well-defined calculations from cited models. Testing that each safety number errs the safe way adds work, not risk. |
| Flight forensics: logs, fits, diagnosis | high; medium for diagnosis | Importers and fits are well defined. Diagnosis must name the right fault first for at least 80% of 200 simulated faulty flights; real anomalous flights depend on finding logs of them. |
| The app: editor, 3D replay, web app | medium | The code can be built steadily. Whether it is good to use is judged by the project’s own acceptance pass on each milestone. |
| Phone apps and accounts | medium | They need an app-store account and a hosting provider, both Neer’s choices. Neither is part of 1.0. |
| CAD files | high for meshes and drawings; medium-low for STEP | Few permissively licensed libraries read or write STEP’s exact solids. STEP import may need a licensing decision. |
| Motor design | high for solid motors; medium for hybrids and liquids | Hybrid and liquid design waits first on a decision about US export rules for rocket propulsion. |
| Parachute design and avionics software | high | Each is checked against closed forms, published tables or exact round trips. |
| An avionics board | depends on Neer | It needs a board built, bench-tested and flown beside a commercial flight computer. |
What only Neer can do
- Publish each release.
- See the 0.5 and 1.0 apps before they go out. His look never holds up their milestones.
- Choose an app-store account and a hosting provider, when phone apps and accounts come up.
- Decide how US export rules apply, before hybrid and liquid design.
- Build and fly the avionics board.
None of these blocks the work before release 0.5.
What could change the plan
- New goals, since the plan covers the roadmap as it stood on October 6, 2026.
- Bug reports. On that day 96 issues were open, 29 of them high priority. Critical ones come before milestone work.
- Hard milestones growing more than expected. Accuracy, diagnosis and the app are the most open-ended.
What 1.0 includes, and what comes after
Release 1.0 is the simulator, the flight analyzer, the competition kit and the desktop and web app. Phone apps, accounts, canards, CAD files and the Mach 2.5–3.5 band come after 1.0. Motor, parachute and avionics design come after that, one at a time (the suite decision record). Until 1.0, HPR Sim flies only commercial solid motors.