Trajectory-Based Optimization for Air Traffic Control in the Terminal Maneuvering Area

Abstract: We present a trajectory-based optimization framework for arrival sequencing and scheduling in the terminal maneuvering area (TMA). Unlike node-link scheduling models that reduce trajectories to time-delay variables, the proposed method computes implementable per-aircraft speed profiles and path extensions that achieve required landing separation through terminal air traffic control actions. The framework combines an analytic TMA path model, consisting of a tangent leg, a radius-to-fix turn, and a final-approach segment, with a nonlinear program (NLP) that jointly optimizes path stretch and segment speeds under a weighted objective. Three landing-order policies are examined: First-Entry-First-Serve (FEFS), First-on-Final-First-Serve (FOFFS), and FOFFS with Constrained Position Shifting (CPS) up to $k$ positions. CPS is implemented through a two-phase approach coupling mixed-integer linear programming (MILP) with NLP to select an optimized landing order before trajectory optimization. The aircraft population follows a realistic weight-class fleet mix with pair-specific wake-turbulence separation, and each scenario is perturbed by a Gaussian wind sample projected onto each segment to convert commanded airspeeds into ground speeds. An online rolling-horizon formulation commits each aircraft trajectory irrevocably upon entry, enabling real-time decision-making. Monte Carlo experiments on the simplified A80 TMA show that: (i) FOFFS consistently outperforms FEFS in delay, path stretch, and fuel burn by exploiting geometric asymmetries among arrival streams; (ii) CPS further reduces separation violations and path stretch, though with diminishing returns and rapidly increasing solver cost; (iii) fuel estimates from BADA 3 and OpenAP show consistent qualitative trends; and (iv) per-entry optimization completes in near real-time, supporting practical deployment.

• The paper introduces a closed-form three-segment arrival model that optimizes base-leg extension and segment speeds, producing FMS-loadable trajectories rather than abstract runway schedules.
• The two-phase MILP-NLP framework supports online scheduling for heterogeneous aircraft, with FOFFS outperforming FEFS and CPS1 reducing separation violations by about 50% at 60 aircraft per hour.
• Monte Carlo tests across nearly 200,000 runs show path-stretch resolution affects performance more than speed resolution, while CPS1 and CPS2 meet real-time targets but CPS3 can create severe runtime spikes.

Motivation and positioning

This paper addresses a structural gap in terminal airspace scheduling research: most existing formulations of the Terminal Airspace Scheduling Problem (TASP) abstract arrival routes into node-link networks with edge travel-time envelopes, producing runway-time schedules that are not guaranteed to be flyable by any specific aircraft type from a given entry geometry. The authors instead make the opposite abstraction choice, sacrificing flow-network generality in exchange for an analytic, closed-form trajectory geometry whose decision variables—the base-leg extension $d_i$ and segment-wise speeds—are exactly the controls available to a TRACON controller. The output is therefore not merely a landing schedule but an implementable set of speed profiles and FAF-extension auxiliary waypoints. The work is situated within the Trajectory-Based Operations (TBO) paradigm adopted by NextGen and SESAR, and it directly targets the consistency problem between airborne FMS trajectories and ground-based schedules.

The case study is single-runway arrivals to runway 9R at KATL within the Atlanta A80 TRACON, with four feeder gates (DALAS, LOGEN, HUSKY, TIROE) and BURNY as the Final Approach Fix.

Analytic path model

The central technical contribution is a closed-form, vector-product derivation of the three-segment arrival path—tangent leg, radius-to-fix (RF) arc, and final straight-in segment—as a smooth nonlinear function of $d_i$ alone. The tangent point on the RF turn circle is expressed via the center-to-entry vector $\mathbf{v}_i$ and its perpendicular; the RF arc angle $\theta_i(d_i)$ follows from the cross- and dot-products of the two radius vectors at the turn center. Total travel time is then a sum of three terms, each a ratio of a geometric length (all functions of $d_i$) to a segment speed. This formulation makes the geometric coupling between path stretch and arrival time explicit and differentiable, which is precisely what enables the NLP-based optimization that node-link models cannot support.

Wind is incorporated by sampling a scalar wind speed $w \sim \mathcal{N}(5, 2^2)$ knots per scenario and projecting it per segment onto the aircraft heading to convert commanded airspeeds into ground speeds. The RF-turn heading is approximated by the chord direction, which the authors argue is accurate to first order given sweep angles below $\pi$ radians and small wind-to-airspeed ratios. For NLP tractability, the $d_i$-dependent wind components are frozen at $d_i = 0$ in the constraint Jacobian; because discretization post-processing uses exact ground speeds, this approximation has negligible effect on committed solutions.

Sequencing policies and two-phase decomposition

Three ordering policies are evaluated: First-Entry-First-Serve (FEFS), First-on-Final-First-Serve (FOFFS), and FOFFS with Constrained Position Shifting up to $k$ positions (FOFFS-CPS$d_i$0, $d_i$1). All policies enforce same-stream non-overtaking precedence along shared jet routes, which both shrinks the feasible permutation space and substantially reduces the CPS MILP's branch-and-bound tree by pre-fixing binaries for same-stream pairs.

The full problem is a mixed-integer nonlinear program combining integer sequencing, nonlinear trajectory geometry, and continuous speeds—too expensive to solve monolithically at entry rate. The authors decompose it into two phases sharing a unified weighted objective $d_i$2 with hierarchy $d_i$3: Phase 1 is a MILP over binary ordering indicators under a scheduling surrogate (path-stretch and speed terms replaced by an excess-delay penalty that bounds unavoidable stretch), and Phase 2 is an IPOPT-solved NLP over trajectory variables with the order fixed. The swap-set construction yields $d_i$4 binaries and $d_i$5 constraints, but worst-case branch-and-bound remains exponential, consistent with established NP-hardness of type-dependent CPS.

The scheduler operates online: each aircraft's trajectory is computed upon TRACON entry using a lookahead window bounded by its free-flight time-to-FAF, committed irrevocably ("one-touch" commitment), with a preview cache that skips redundant solver calls when the window is unchanged. A greedy forward-pass repair rounds solutions onto an operational grid $d_i$6 so all committed outputs correspond to FMS-loadable waypoints and integer-knot speed commands.

Fleet heterogeneity is modeled explicitly: six aircraft types across Heavy/Large/Small classes with probabilities $d_i$7, pair-specific wake-turbulence separation (e.g., 150 s for Heavy-leading-Small versus 82 s for Heavy-following-Heavy), type-specific runway occupation times, and per-aircraft final-approach speed bounds anchored to $d_i$8. The heterogeneous fleet is essential to expose CPS benefit—a homogeneous fleet provides none.

Monte Carlo results

The evaluation spans five policies, a $d_i$9 discretization grid ($\mathbf{v}_i$0 nmi; $\mathbf{v}_i$1 kts), 1,000 demand seeds, and 10 wind samples per seed—nearly 200,000 runs—with aggregate gate rates from roughly 5 to 60 aircraft per hour.

Ordering policy effects. FOFFS consistently dominates FEFS in delay, path stretch, and fuel burn at all densities, exploiting geometric asymmetries among arrival streams; FEFS requires several nautical miles of extension even near 30 AC/hr while FOFFS stays near zero at low demand. CPS yields monotone but sharply diminishing returns: CPS$\mathbf{v}_i$2 provides the largest jump, cutting separation violations by approximately 50% relative to FOFFS at 60 AC/hr, CPS$\mathbf{v}_i$3 adds a meaningful further reduction, and CPS$\mathbf{v}_i$4 is marginal. All policies maintain essentially zero violation below a capacity knee near 40–45 AC/hr, above which FEFS degrades fastest—a pattern the authors interpret through single-server queuing dynamics as utilization approaches unity.

Discretization sensitivity. Path-stretch granularity is the dominant knob: halving $\mathbf{v}_i$5 from 1.0 to 0.5 nmi reduces average stretch by 10–20% at high demand, whereas doubling $\mathbf{v}_i$6 has only a small effect because the optimizer compensates through the continuous $\mathbf{v}_i$7. This supports coarse 5–10 kt speed quantization operationally.

Fuel cross-validation. BADA 3 and OpenAP agree on the qualitative policy ordering and knee location, with OpenAP uniformly about 8% higher on average (627 kg vs. 581 kg mean per-aircraft burn), attributed to drag-polar and TSFC parameterization differences. Wind shifts fuel burn by less than ±5%, second-order relative to both the inter-model gap and inter-policy gaps at high demand.

Runtime feasibility. FEFS, FOFFS, and CPS$\mathbf{v}_i$8 remain below 2 seconds per entry across the full demand range, satisfying the real-time budget. CPS$\mathbf{v}_i$9, however, exhibits heavy-tailed behavior above 50 AC/hr, with means exceeding 6 s/entry and occasional runs taking hundreds of seconds. The authors trace the outliers to symmetry in the wake matrix (many CPS-valid orderings with identical makespans defeat GLPK's branching heuristic) and to wind-induced perturbation of LP constants flipping branch selection—an instructive finding since the resulting schedules are essentially identical despite order-of-magnitude runtime differences. They identify two remedies outside the paper's scope: commercial MILP solvers with stronger cuts and symmetry breaking, or Balakrishnan and Chandran's dynamic-programming formulation with polynomial-in-$\theta_i(d_i)$0 scaling for fixed $\theta_i(d_i)$1.

Limitations

The most significant limitation, conceded explicitly, is that the vertical profile is decoupled from the lateral optimization and used only for fuel evaluation. The optimizer has no authority over top-of-descent, deceleration schedule, or glide-slope profile, despite tight physical coupling between vertical and lateral degrees of freedom. Vectoring-for-spacing via S-turns and holding patterns is also excluded, restricting the tactical action set to path stretch and speed control. The wind model is a scalar Gaussian projected onto headings rather than a spatiotemporal field, and uncertainty is handled by Monte Carlo evaluation rather than chance-constrained or robust formulations. Finally, the study covers single-runway arrivals only; parallel runways, airline-driven precedence, and departure interactions remain open.

Conclusion

The paper delivers a coherent trajectory-based alternative to node-link TMA scheduling: an analytic closed-form path model exposing base-leg extension and segment speeds as decision variables, a two-phase MILP/NLP decomposition of a unified safety-first objective embedded in an online rolling-horizon loop, and a large-scale Monte Carlo validation demonstrating near-real-time per-entry performance. Its principal operational findings—that FOFFS strictly dominates FEFS, that CPS gains concentrate in the first one or two position shifts, and that path-stretch granularity matters far more than speed granularity—are well supported across nearly 200,000 runs and two independent fuel models. The framework's practicality hinges on the vertical–lateral co-optimization the authors identify as their main planned extension, and on eliminating the CPS$\theta_i(d_i)$2 runtime tail via stronger solvers or dynamic programming.