Files

JimmyBinoculars 1b15384c10 Trajectories

2026-03-04 20:29:19 +00:00

12 KiB

Raw Blame History

Trajectory Simulation Guide

Overview

The Trajectory Simulator predicts rocket flight paths using physics-based 4th-order Runge-Kutta integration. It accounts for atmospheric drag, gravity, thrust, and user-defined events to compute complete vehicle trajectories from liftoff to landing.

Quick Start

Configure Vehicle
- Import engine (from Engine Designer) or specify manually
- Enter vehicle mass (wet & dry), reference area, drag coefficient
Configure Atmosphere
- Select model (US Standard, exponential)
- Set sea-level conditions (temperature, pressure)
Set Pitch Program
- Vertical hold duration or altitude
- Then gravity turn (pitch follows velocity vector)
Add Events (optional)
- Guidance commands (pitch changes)
- Jettison (drop mass during flight)
- Markers (annotations)
Run Simulation
- Click "Run Simulation"
- Wait for RK4 integration to complete
Playback
- Watch animation (1×, 5×, 10× speed)
- Scrub timeline to jump to time
- Click on plot to jump to position

Physics Model

State Vector

At each timestep, we track:

state = [x, y, vx, vy, m]

x — downrange distance (m)
y — altitude above sea level (m)
vx — horizontal velocity (m/s, positive = downrange)
vy — vertical velocity (m/s, positive = up)
m — vehicle mass (kg)

Forces

Thrust:

F_thrust = thrust(t) × cos(pitch_angle)  [horizontal component]
F_thrust = thrust(t) × sin(pitch_angle)  [vertical component]

Direction depends on pitch program (see below).

Gravity (altitude-dependent):

g(h) = g0 × (R_earth / (R_earth + h))²

Where:

g0 = 9.81 m/s²
R_earth = 6.371×10⁶ m
h = altitude (m)

Drag:

F_drag = 0.5 × ρ(h) × v² × Cd × A_ref

Opposed to velocity direction:

F_drag_x = -F_drag × (vx / v)
F_drag_y = -F_drag × (vy / v)

Where v = √(vx² + vy²) is total velocity.

Atmosphere

US Standard Model (default):

Piecewise linear layers
Troposphere: 0–8500 m (temperature decreases 6.5 K/km)
Stratosphere: 8500–15000 m (isothermal at 216.5 K)
Higher: exponential decay

Exponential Model:

ρ(h) = ρ0 × exp(-h / H)

Where:

ρ0 = sea-level density (1.225 kg/m³)
H = scale height (~8500 m)

Pressure & Temperature:

US Standard uses table lookup
Temperature affects gas density (lower T = higher ρ at same P)

Equations of Motion

Acceleration:

a_x = (F_thrust_x + F_drag_x) / m
a_y = (F_thrust_y + F_drag_y - m×g(h)) / m

Mass Change (during burn):

dm/dt = -mass_flow_rate

Mass only changes during engine burn phase (after liftoff, before MECO).

Numerical Integration (RK4)

The integrator advances state by small timesteps (default: dt = 0.05 s):

k1 = derivatives(t, state)
k2 = derivatives(t + dt/2, state + k1×dt/2)
k3 = derivatives(t + dt/2, state + k2×dt/2)
k4 = derivatives(t + dt, state + k3×dt)

state_new = state + (k1 + 2×k2 + 2×k3 + k4) × dt/6

Accuracy: RK4 is 4th-order accurate; typical error scales as O(dt⁵).

Advantages:

More accurate than Euler method
Reasonable computational speed
Standard in trajectory software

Limitations:

No adaptive timestep (dt is fixed)
Cannot handle stiff equations
Small dt needed for accuracy (0.01–0.1 s typical)

Inputs

Vehicle Configuration

From Engine Designer (auto-populated if imported):

thrust — engine thrust curve or constant
isp — specific impulse (vacuum)
mdot — mass flow rate (kg/s)
burnTime — engine burn duration (s)
dryMass — engine dry mass (kg)

Vehicle Properties (manual input):

wetMass — total mass with propellant (kg)
dryMass — mass without propellant (kg)
- Note: Used after engine shutdown
referenceArea — cross-sectional area for drag (m²)
dragCoefficient — Cd (typically 0.2–0.3 for rockets)
payloadMass — payload (kg, contributes to dry mass)

Atmospheric Conditions

atmosphereModel — US Standard or Exponential
seaLevelTemperature — T0 (K), default 288.15 K (15°C)
seaLevelPressure — P0 (Pa), default 101325 Pa
windSpeed — not yet implemented

Pitch Program

Vertical Hold Phase:

pitchStartAlt — altitude to begin gravity turn (m)
Duration: liftoff until altitude > pitchStartAlt
Pitch angle: 90° (straight up)

Gravity Turn Phase:

Pitch angle follows velocity vector
pitch = atan2(vy, vx)
Vehicle points along flight path (min drag)

Advanced Programs (future):

Custom pitch schedule vs. time
Thrust vector control
Angle of attack constraints

Outputs

Trajectory States

Array of state vectors at each timestep:

[
  {time: 0, x: 0, y: 0, vx: 0, vy: 0.1, m: 2000},
  {time: 0.05, x: 0, y: 0.005, vx: 0.2, vy: 15.0, m: 1999.5},
  ...
  {time: 60, x: 5000, y: 50000, vx: 2000, vy: 0, m: 800}
]

Total states: ~1200 for 60 second flight (0.05 s dt)

Auto-Detected Events

Liftoff:

First time y > 0 and vy > 0
Time, altitude, velocity logged

Main Engine Cutoff (MECO):

When burnTime expires
Last time mass changes
Marks end of powered flight

Max Q (Dynamic Pressure):

Maximum value of q = 0.5 × ρ × v²
Often a structural design point
Time, altitude, velocity, q value

Apogee:

Highest altitude reached
First time vy changes from positive to negative
Last point of ascending flight

Landing:

First time y ≤ 0 after apogee
Final altitude, downrange, velocity

User-Defined Events

Guidance (Pitch Command):

{type: 'guidance', time: 30, pitchAngle: 45}

At t=30s, change pitch to 45° (overrides gravity turn)

Jettison (Mass Drop):

{type: 'jettison', time: 25, massDropped: 50}

Drop 50 kg (e.g., fairings) at t=25s

Reduces drag & inertia
Affects apogee & downrange

Marker (Annotation):

{type: 'marker', time: 15, label: 'Separation'}

Just marks event on timeline; no physics change

Workflow: Simulate LOX/RP1 Rocket

Step 1: Design Engine

Go to Design > Engine
LOX/RP1, 200 bar → ~150 kN thrust, 310 s Isp, 60 s burn
Export JSON

Step 2: Design Rocket

Go to Design > Rocket
Import engine JSON (gets thrust, Isp, burn time)
Configure tanks (5000 L, tandem)
Set payload (50 kg) → Result: Wet mass 1550 kg, dry mass 450 kg

Step 3: Run Trajectory

Go to Design > Trajectory
Import rocket JSON (gets wet/dry mass, reference area)
Import engine JSON (gets thrust, Isp, burn time)
Set pitch start altitude: 1000 m
Click "Run Simulation" → Result: ~5000 m downrange, 50 km apogee, 180 s flight time

Step 4: Analyze Results

Plot: Shows altitude vs. downrange (parabolic path)
Timeline: Mark apogee, MECO, Max Q
Playback: Watch animation in real time
Scrub: Jump to specific times to see position/velocity

Step 5: Optimize

Try different masses (remove payload → higher apogee)
Try different pitch programs (start gravity turn later → longer range)
Try jettison events (drop fairings at MECO → save mass)

Event System

Event Structure

{
  type: 'liftoff' | 'meco' | 'maxQ' | 'apogee' | 'landing' | 'guidance' | 'jettison' | 'marker',
  time: number,           // seconds
  altitude?: number,      // meters
  downrange?: number,     // meters
  velocity?: number,      // m/s
  label?: string,         // display name
  value?: any             // event-specific data
}

Auto-Detected Events (Read-Only)

Computed during simulation; user cannot edit.

Liftoff: {type: 'liftoff', time: 0.05, altitude: 0.1, velocity: 1.5}

Max Q: {type: 'maxQ', time: 5.2, altitude: 1000, q: 50000}

Apogee: {type: 'apogee', time: 120, altitude: 50000, velocity: 0}

Landing: {type: 'landing', time: 180, altitude: 0, downrange: 5000, velocity: -50}

User Events

Guidance Command:

{type: 'guidance', time: 30, pitchAngle: 45, label: 'Pitch over'}

Changes pitch at specified time
Overrides gravity turn
Can be used for coast phase burn starts, etc.

Jettison:

{type: 'jettison', time: 25, massDropped: 50, label: 'Fairing separation'}

Removes mass from trajectory
Affects drag & inertia
Typically after Max Q (fairing drag not needed)

Marker:

{type: 'marker', time: 60, label: 'Engine cutoff'}

Pure annotation
No physics effect
Useful for documentation

3D Visualization

Trajectory Plot

HTML5 Canvas rendering of flight path:

Axes:

X: downrange (0 to max)
Y: altitude (0 to apogee + margin)
Aspect ratio: ~2:1 (wider than tall)

Elements:

Trajectory curve (light blue line)
Event markers (circles at key points)
Grid (light gray, 10 km spacing)
Labels (altitude, downrange at axis)
Legend (event types & colors)

Interactivity:

Click on plot → jump to that time
Hover on point → show values (alt, range, velocity)
Hover on event marker → show label
Zoom (mousewheel) — not yet implemented

3D Flight Animation

Top-down view showing:

Vehicle model (small rocket symbol or sphere)
Flight path (line from start to current position)
Current altitude/range indicators
Compass heading

Implementation: Canvas 2D or Three.js (current: Canvas)

Playback Controls

Timeline Bar

Located below trajectory plot:

Play/Pause Button:

Starts/stops animation
Keyboard: Space bar

Speed Selector:

1× — real time
5× — 5× faster
10× — 10× faster

Scrubber (Time Slider):

Drag to jump to any time
Release to play from that point
Shows current time in seconds

Event Timeline:

Vertical lines at event times
Hover to see event name
Click to jump to event

Keyboard Shortcuts

Space: Play/pause
→: Jump forward 10 seconds
←: Jump backward 10 seconds
Home: Jump to start
End: Jump to end

Advanced Features

Thrust Curves (Future)

Instead of constant thrust, can import actual thrust vs. time:

{
  type: 'thrustCurve',
  data: [
    {time: 0, thrust: 150000},
    {time: 5, thrust: 145000},
    {time: 60, thrust: 0}
  ]
}

Would enable:

Throttling analysis (variable thrust)
Solid rocket motor curves
Multi-engine clustering

Stage Separation

Currently single-stage only. Multi-stage would require:

Stage definition (separate vehicle configs)
Coast phase between stages
Staging logic (when to ignite next stage)
Updated mass calculations

Wind Effects

Could add:

Constant wind (direction, magnitude)
Turbulence (atmospheric gusts)
Wind shear (altitude-dependent)
Affects trajectory & landing site

Control Systems