Mixed-Fleet Runway Sequencing (3D)

Blender runway with heavy, medium and light aircraft on final: wake ribbons and gaps show how the order changes throughput.

Switch to 2D

Presets

Playback

Traffic

Separation and wind

Sequencing

View

Camera

Layers

Quality

Model check

The science

What this is. A neutral scheduling model of one runway landing a batch of mixed aircraft. Each aircraft is Heavy, Medium or Light. A wake separation matrix says how many nautical miles must separate a follower from a leader of a given class; the page turns that into a time gap and then asks which landing order uses the runway best.

From distance to time

Leader i and follower j fly the common final path of length gamma at ground speeds v_i and v_j (approach speed minus headwind). The required distance s_ij must hold when the leader is at the entry gate and when it is at the threshold. Entry-gate condition: T >= s_ij / v_j. Threshold condition (binding when the follower is faster): T >= s_ij / v_j + gamma (1/v_i - 1/v_j). So

T_ij = max( ROT, s_ij / v_j + gamma max(0, 1/v_i - 1/v_j) )

with the runway occupancy time ROT as a floor. The closing-speed term is why a Light aircraft behind a Heavy one costs more than the matrix alone suggests when the follower is faster.

Capacity of a first-come-first-served stream

If the classes arrive at random with shares p_i, the mean gap is E[T] = sum_ij p_i p_j T_ij and the long-run rate is 3600 / E[T] per hour. Perfect grouping of equal classes would approach 3600 / sum_i p_i T_ii, the dashed bound in graph 3.

Sequencing a batch

For a batch of n aircraft the total time to land them all is the sum of the n-1 gaps. Minimising it over orders is a travelling-salesman-style problem, solved exactly here by dynamic programming over subsets (Held-Karp, 2^n x n states). Constrained position shifting allows each aircraft to move at most k places from its first-come-first-served position, a fairness limit used in practice; k = 0 is FCFS and k = n is the exact optimum. Grouped by class sorts into one block per class, taking the better of heavy-first or light-first.

Checks run in this page

  • Monte Carlo over 200 000 random arrivals reproduces the formula for the FCFS rate.
  • The dynamic programme equals a brute-force search over all 5040 orders of a 7-aircraft batch.
  • Two aircraft flown in 0.05 s steps with the computed gap keep exactly the required distance at the binding point, for all nine class pairs.

What to try

  • Heavy-rich hub: reordering saves about a quarter of the time.
  • No wake rule: the gain shrinks, because only speed differences remain.
  • Raise k from 0 to 12 and watch graph 4 flatten at the optimum.

Honest simplifications. The matrix values are illustrative round numbers in the style of a three-class rule, not an authority's current rules; real systems use finer classes, time-based rules and wind-dependent wake behaviour. All aircraft are assumed available at once (no earliest-time constraints), a single runway, constant speeds on final, no go-arounds. Changing a slider generates the same random batch again; the button draws a new one. The 3D view exaggerates aircraft size, runway width and distance scale.

Loading model...
Loading Blender model...
Landing timeline: first-come-first-served against the chosen order
Time-gap matrix T(leader, follower) in seconds
Arrivals per hour against heavy share of traffic
Time saved against the allowed position shift
Made with 🟠 Blender · Three.js