Released mass

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, its mass, center of mass and inertia changing 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. This is new with M1.12b (a mass released in flight).
• 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, within the tests’ bound of 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, and its angular momentum to 7.3e-12.
• What it leaves out: a push that throws the part out; a release in a flight that also separates, ejects pieces or moves a mass; a release before the rocket leaves the rail; parachutes on the part; and the part’s own spin once it is out. Where and how fast the part lands depends on its drag area, which you give. hpr doesn’t warn when a release leaves the rocket unstable: dropping a part forward of the center of mass moves the center aft, and the stability margin falls by 1.683 calibres in the example below. Read it from the flight’s metrics (Flight metrics).

Describing a release

A MassRelease names the part, when it leaves, and its drag area once it is out:

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 id that 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, because 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. With M the rocket’s mass and cg its center, m the part’s mass, c its center and I_p its own inertia about c, the rest has

M'  = M − m
cg' = (M cg − m c) / M'
I'  = I_about_cg' − (I_p + m (|c − cg'|² E − (c − cg')(c − cg')ᵀ))

where I_about_cg' is the rocket’s inertia moved to the new center by the parallel-axis theorem, E is the identity matrix, and the bracket is the part’s inertia about that center. It is 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, and the integrator (the numerical method that steps the flight forward in time) starts afresh at the same instant, as it does when a sustainer flies on after a separation (Staging). What the flight reports about the center of mass steps too: its position moves by cg' − cg (9.5 cm 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 v_O + ω × r, with v_O the nose tip’s velocity, ω the rocket’s turning rate and r the point’s place in the rocket. The part leaves from where it was, with its center’s velocity v_O + ω × c, and the rest’s center goes on at v_O + ω × cg'. 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, and the same holds 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 cg' − cg, so the drift’s share of the velocity steps too. The reported momenta then differ by Ṁ (cg' − cg), 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 already be falling when a part leaves just before it. 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, even when another part leaving first sets the rest rising again, and whatever order the parts are listed in. 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. A part let go just above the ground, forward of the center of mass of a rocket falling nose up, 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:

m a = −½ ρ (C_D S) |v − w| (v − w) + m (g + a_Coriolis)

with v and a the part’s velocity and acceleration, ρ the air’s density, w the wind, g gravity and a_Coriolis 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 across falling at 5 to 6.6 m/s, and 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. hpr 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 i (its place in the list given to with_releases); its sample is the rocket just before the part left.
• FlightResult::released holds each part’s flight (ReleasedFlight): its start, its events, its landing. The separated bodies of a separation or an ejection are elsewhere, in FlightResult::bodies.
• Simulation::mass_properties(&flight, t) gives the rocket’s mass properties at time t as the flight flew it, without every part released at or before t.

A worked example

The example released_ballast.rs flies the project’s 54 mm test design (synthetic-54mm-three-fin.json, a body 56.3 mm across) on an I175 motor (motor designation), with 200 g of ballast in its airframe: a cylinder 50 mm long and 30 mm across, on the axis, its center 0.375 m aft of the nose tip. It flies in calm standard air from a site in New Mexico 1,400 m up, and 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 0.56 × 0.05 × 0.03 = 0.00084 m², 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:

By hand, the rest’s center is at (0.8188 × 0.6681 − 0.2 × 0.375) / 0.6188 = 0.7628 m aft of the tip. It moves 0.09474 m aft, because the ballast sat forward of the center, and the static margin falls by 0.09474 / 0.05630 = 1.683 calibres (the body’s diameter is 0.05630 m), 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 v_O + ω × r, so it divides between the rest, 99.4433, and the ballast, 32.1406; the free-flight test below checks that the flight keeps it so.

• The rocket climbs 80 m 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: 7.07 × √(0.6188 / 0.8188) = 6.15 m/s.
• The ballast peaks lower than the rocket, having more drag for its mass. Its terminal speed at the ground is √(2 × 0.2 × 9.79 / (1.069 × 0.00084)) = 66.0 m/s, with the standard air’s density 1.069 kg/m³ at the site, 1,400 m up (Atmosphere), and gravity 9.79 m/s² there (Gravity). It lands a little faster, 66.74 m/s, because it is still slowing as the air thickens.

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.

In the free-flight test the ballast leaves 0.146 m/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

• A push. 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).
• Releases with a separation, ejections or mass shifts. hpr can’t combine these yet.
• Releases on the pad or the rail, as above.
• Parachutes on the part. It falls under one drag area from the instant it leaves; it has no devices of its own, and no opening time.
• The part’s spin. Its spin is dropped: 1.5e-3 of the rocket’s angular momentum in the free-flight test.
• Warnings. hpr doesn’t warn when a release leaves the rocket unstable, as above.

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, and 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: the momentum and angular momentum of a system summed over its particles, and their conservation with no external force) and appendix B (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).