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.