Rocket Math Book — Table of Contents

---

A working book, chapter by chapter. Chapters are written as they're finished — most of this table of contents is still a planning outline, not finished prose. Part 8 is the only chapter currently written.

Part 1: Getting your hands dirty Not yet written

• International System of Units (SI),
• Measurement tools - rulers, scales, micrometers
• Measuring and documenting a 'school rocket'
• Putting these measurements into Open Rocket
• simple tutorial on how to do each step
• Open Rocket - auditing your components, choosing motors, simulation
• Building your school rocket - Auditing weight and finish, update Open Rocket
• Fly your rocket
• Forces of flight - thrust, gravity, drag
• Logging a real flight with the Jolly Logic altimeter/accelerometer
• this data becomes the "ground truth" flight we validate against in Part 8

Part 2: Aerodynamic Fundamentals - Drag (Cd) Not yet written

• Why a single constant Cd (e.g. 0.75) isn't good enough
• biggest single source of apogee error in early simulator work
• The three pieces of drag: friction + pressure + base (OpenRocket's model)
• Skin friction drag - Reynolds number, critical Reynolds transition, surface roughness
• Base drag - Mach-dependent behavior
• Pressure drag - nose cone and per-fin contributions
• Explain rocket_aero.js:getCd() in detail, term by term
• Atmosphere model - ISA lapse rate, speed of sound vs. altitude (atmosphere.js)
• why Mach number can't use a fixed sea-level speed of sound

Part 3: Aerodynamic Fundamentals - Stability & Center of Pressure Not yet written

• What CP is and why stability margin depends on CP relative to CG
• Classic Barrowman method (trapezoidal fins)
• OpenRocket's Diederich-based method - how and why it differs from classic Barrowman
• Elliptical fin CP as a third comparison case
• Explain rocket_aero.js CP functions in detail
• Why CP is independent of angle of attack in the linear model (and where that assumption breaks down, ~20 deg AoA)
• CG shifts aft during burn while CP shifts too - stability margin is doubly dynamic
• The 1-caliber rule and where it breaks down - short/fat rockets (Pringles rocket, fineness ratio < ~7:1) need margin-as-percent-of-length instead
• NAR safety note - calculated stability is never a substitute for physical CG balance-point verification before flight

Part 4: Closed-Form Performance Equations Not yet written

• Gather the 'school rocket' performace numbers from Open Rocket
• Calculate Rocket Attributes - Total Mass, CG (closed form), compare to Open Rocket numbers
• (Cd and CP now come from Parts 2 and 3)
• Calculate Rocket Performance - Off Rod, Apogee, Velocity at deployment, optimum_delay, max velocity, max acceleration, time to apogee, flight time (closed_form)
• Explain how these equations were derived in an easy to follow format
• Basically explain closed_form.js in detail
• Explain why these numbers are not the same as Open Rocket's
• Integrated quantities (altitude, velocity, time) vs. point-sample quantities (peak acceleration) - why averaging tolerates one and breaks the other

Part 5: Recovery Math Not yet written

• Descent rate under canopy - vertical-only velocity vs. wind-inflated ground-hit velocity
• Parachute reefing - representing effective reefed diameter in OpenRocket
• Explain closed_form.js:ground_hit_velocity() in detail
• JLCR two-stage deployment strategy - why vertical descent velocity, not ground-hit velocity, is the right metric to tune against

Part 6: Euler's Method for Rocket Performance Not yet written

• Basically explain how Euler.js works
• State machine walkthrough - PAD, BOOST, COAST, APOGEE, DESCENT, TOUCHDOWN
• Integrating the actual thrust curve instead of assuming constant/average thrust
• The "shadow" trajectory trick for finding optimum delay without a second full pass
• Choosing a time step (dt) - accuracy vs. computation tradeoffs

Part 7: RK4 Not yet written

• Why forward Euler accumulates error - local vs. global truncation error
• The four-stage RK4 update, explained geometrically (not just algebra)
• Step-size sensitivity - how much coarser can dt be with RK4 vs. Euler for the same accuracy
• Three-way comparison - closed form vs. Euler vs. RK4 against the same Open Rocket reference flight
• Separating the derivative function f(t, state, params) from the integrator
• RK4 evaluates f() four times per step, at intermediate/fictitious states that never physically occur
• params (Cd, thrust, etc.) must be held constant across all four stage evaluations within one step
• this separation is what makes the integrator itself plugin-agnostic (see Part 8)
• Event detection - snapping to the nearest sample vs. interpolating the true crossing
• a threshold event (e.g. rod clearance) almost never lands exactly on a step boundary
• reporting the value at the nearest sample after the crossing is a real, structural bias - not solved by a smaller dt
• linear interpolation between the two bracketing samples recovers most of the accuracy for free (no new derivative evaluations)
• cubic Hermite goes further, using the derivative (slope) already computed at each bracketing sample, not just the two values
• worth checking: even reference tools you're validating against may report the nearest-sample value rather than the true interpolated crossing

Part 8: Case Study - Closed-Loop Airbrake Control (and the Plugin Architecture) → Read this chapter

• From simulation to control - using the validated numerical model as the plant model
• The 'plugin' concept - controllers that observe flight state and modify params (Cd, thrust, etc.) between steps
• one plugin 'tick' per completed integration step, never mid-RK4-stage
• ties directly to the f(t, state, params) boundary established in Part 7
• control-loop rate vs. integration dt - a real flight computer's sample rate is independent of the step size chosen for numerical accuracy
• zero plugins registered = default no-op, must reproduce the Part 6/7 baseline exactly
• ownership/conflict handling when multiple plugins want to touch the same param
• ARC 2027 airbrake problem - hitting a precise target altitude
• Two-phase validation approach - hand-derived ballistic trajectory vs. Open Rocket, then RocketPy for airbrake control
• Validating the whole book's math against the real flight data logged back in Part 1

Appendix A - Debugging War Stories Not yet written

• Real bugs found while building this simulator
• function call-order bug: rocket_opt_delay = 0 consumed before calc_optimum_delay() ran
• mass_ex_prop vs. M mismatch in calc_velocity_at_deployment()
• nosecone_elipsoid constant (0.5 vs. 0.333) - dead code today, latent bug if fin type changes
• the off-rod velocity chase: RK4 vs. Euler vs. Open Rocket disagreed by ~4%, survived dt=0.001, survived cubic Hermite event interpolation
• root cause wasn't in our code at all - Open Rocket's own reported statistic snaps to the next saved sample instead of interpolating the true crossing
• confirmed by pulling Open Rocket's raw saved flight data out of the .ork file and interpolating it the same way - our simulator was right, the reference number we were chasing wasn't the true answer
• lesson: when a well-validated model won't converge to a reference under any amount of numerical refinement, question whether the reference value itself is a true instantaneous quantity or a sampled/reported approximation

Appendix B - Kerbal Mode: Physics You Can Simulate But Never Fly Not yet written

• Sandbox-only chapter, explicitly NOT NAR/TRA flyable - clearly labeled as such
• Active thrust control / throttling a motor mid-flight
• real certified motors burn exactly as certified, unmodified - no legal path to this
• Other 'what if' plugins for fun - retro-propulsion, exotic control schemes, etc.
• Purpose: give the plugin architecture room to play without muddying the flight-legal chapters

Appendix C Not yet written

• Glossary of symbols and terms
• Full code listings