Fixed-Step Solver | Events, Orbits, and Drag

Why this matters

A fixed-step solver only checks the world at sample instants

Many GNC simulations are not just continuous motion. They include threshold events, mode switching, orbital propagation, drag decay, and fast actuator or sensor dynamics.

A fixed-step solver can be useful for real-time simulation and flight-software logic, but it does not continuously watch the system. It checks the state at discrete times: \(t_0,t_1,t_2,\dots\). That means a threshold crossing can be detected late, or completely missed.

Core warning: In mission simulation, timestep error is not just numerical error. It can become a delayed mode switch, missed safety event, false orbital energy, wrong drag decay, or unstable fast dynamics.

Problem roadmap

One page, five mission-level fixed-step failures

A · Chaser response
Small timestep gives smooth convergence. Large timestep can create overshoot, oscillation, or divergence.

B · Event switching
Threshold events are detected late because fixed-step logic only checks sampled points.

C · Orbit propagation
Euler integration injects false energy, so a circular orbit can spiral outward.

D · Drag + BC
Coarse integration can amplify orbital decay prediction error when drag is present.

E · Stiff systems
A timestep safe for slow orbital motion can be unsafe for fast actuator or sensor dynamics.

Upgrades
Event delay, missed event, and energy error vs timestep are included as explicit interactive diagnostics.

Part A

Chaser control: discrete only

A one-dimensional chaser moves toward a target using a sampled PD-like controller. The controller is simple, but the result depends strongly on update rate.

\ddot{x}=\frac{u}{m},\qquad u_k=-K_p x_k-K_d v_k

v_{k+1}=v_k+\frac{u_k}{m}\Delta t,\qquad x_{k+1}=x_k+v_k\Delta t

Initial position \(x_0\)

Initial velocity \(v_0\)

Small timestep

Large timestep

Simulation time

Small dt result—

Large dt result—

Small final |x|—

Large final |x|—

Insight: The controller is not only defined by \(K_p\) and \(K_d\). It is also defined by how often it is allowed to act.

Part B

Event switching: late detection

A chaser approaches a docking threshold. In continuous reality, the threshold crossing can happen between two fixed-step samples. The simulation only detects the event at the next sampled point, so the mode switch is delayed.

|x|\leq x_{threshold}\quad \Rightarrow \quad \text{switch from approach mode to docking mode}

\Delta t_{event}=t_{detected}-t_{true}

Initial distance

Closing speed

Switch threshold

Fixed timestep

True crossing time—

Detected crossing time—

Event delay—

Mode switch—

Critical GNC insight: Fixed-step solvers detect events late, which can cause incorrect mode switching.

Upgrade 2

Missed event: threshold window skipped in one step

A late event is eventually detected. A missed event is worse: bad logic can fail completely if no sampled point lands inside the event window.

x_k=10.5,\qquad x_{k+1}=9.4

The system passed through the threshold region, but no sampled point landed inside it. This is dangerous for contact detection, burn cutoff, docking thresholds, sensor handover, safe-mode triggers, and altitude crossings.

Initial distance

Closing speed

Fixed timestep

Event window low

Event window high

Event status—

Closest sample—

Window—

Bug type—

Part C

Orbit propagation: Euler orbit spirals out

A circular two-body orbit should remain circular if no drag or perturbation exists. If the simulated orbit spirals outward, the spacecraft did not gain energy. The numerical method created it.

\ddot{\mathbf r}=-\mu\frac{\mathbf r}{r^3},\qquad v_0=\sqrt{\frac{\mu}{r_0}}

\mathbf v_{k+1}=\mathbf v_k+\mathbf a_k\Delta t,\qquad \mathbf r_{k+1}=\mathbf r_k+\mathbf v_k\Delta t

Orbit radius [km]

Euler timestep [s]

Number of orbits

Initial energy—

Final energy—

Energy error—

Final radius error—

Upgrade 3

Energy conservation comparison: error vs timestep

In ideal two-body motion, specific orbital energy should remain constant:

\epsilon=\frac{v^2}{2}-\frac{\mu}{r}

This sweep turns the visual orbit drift into a numerical diagnostic. The larger the timestep, the faster energy conservation breaks down.

Orbit radius [km]

Number of orbits

Maximum dt [s]

Insight: Energy error grows rapidly with timestep size in fixed-step integration.

Part D

Drag + ballistic coefficient: decay error amplification

With drag, timestep error can change the predicted decay trend. Drag depends on velocity squared and atmospheric density, so coarse integration can over-predict or under-predict altitude loss.

\mathbf a_{drag}=-\frac{1}{2}\rho\frac{v^2}{B}\hat{\mathbf v},\qquad B=\frac{m}{C_DA}

Ballistic coefficient B

Density multiplier

Fine timestep [s]

Coarse timestep [s]

Propagation time [hours]

Fine final altitude—

Coarse final altitude—

Decay mismatch—

Driverdt + drag

Part E

Stiff systems: fixed dt fails completely

Some systems contain slow orbital motion and fast actuator, sensor, or control-loop dynamics. One timestep may be fine for the slow state but unsafe for the fast state.

\dot{x}_{slow}=-0.2x_{slow},\qquad \dot{x}_{fast}=-\lambda x_{fast}

x_{fast,k+1}=(1-\lambda\Delta t)x_{fast,k},\qquad |1-\lambda\Delta t|<1

Fast decay rate \(\lambda\)

Safe dt

Unsafe dt

Simulation time

Euler fast-mode limit—

Safe dt status—

Unsafe dt status—

Main lessonFast dynamics

Insight: A timestep acceptable for slow orbital motion may be completely unsafe for fast actuator, sensor, or control-loop dynamics.

Python / MATLAB snippets

Mission-level fixed-step snippets

These snippets show the page logic in compact engineering form: event delay, circular orbit energy drift, and stiff-mode instability.

# Fixed-step event delay
import numpy as np

x0 = 100.0
closing_speed = 7.0
threshold = 10.0
dt = 2.0

true_crossing = (x0 - threshold) / closing_speed
sample_times = np.arange(0, true_crossing + 5*dt, dt)
distance = x0 - closing_speed * sample_times

detected_index = np.where(distance <= threshold)[0][0]
detected_time = sample_times[detected_index]

event_delay = detected_time - true_crossing
print(true_crossing, detected_time, event_delay)

# Euler orbit propagation and energy error
import numpy as np

mu = 398600.4418
r0 = np.array([7000.0, 0.0])
v0 = np.array([0.0, np.sqrt(mu / np.linalg.norm(r0))])
dt = 60.0
steps = 200

r = r0.copy()
v = v0.copy()
energy0 = 0.5*np.dot(v,v) - mu/np.linalg.norm(r)

for k in range(steps):
    a = -mu * r / np.linalg.norm(r)**3
    v = v + a*dt
    r = r + v*dt

energy_final = 0.5*np.dot(v,v) - mu/np.linalg.norm(r)
print(abs(energy_final - energy0))

# Explicit Euler stability for a fast mode
lambda_fast = 50.0
stability_limit = 2.0 / lambda_fast

for dt in [0.01, 0.04, 0.08]:
    multiplier = 1.0 - lambda_fast*dt
    stable = abs(multiplier) < 1.0
    print(dt, multiplier, stable)

Teaching note: Fixed-step methods are not wrong. But event logic, energy conservation, drag decay, and fast modes must be checked against the chosen timestep.

Engineering takeaway

Fixed-step simulation is powerful only when timestep is treated as design

1 · Events are sampled

Threshold crossing can be detected late, and narrow event windows can be skipped entirely.

2 · Orbits reveal energy error

A circular orbit should conserve energy. If it spirals, the numerical method has changed the physics.

3 · Fast modes set dt limits

A timestep chosen for slow motion can be unstable for fast actuator or sensor dynamics.

Final insight: For GNC, fixed-step simulation is powerful only when the timestep is treated as part of the design.

← Back to Problem Bank