Optimal 4-D Aircraft Trajectories in a Contrail-sensitive Environment

Abstract

Aircraft induced contrails present an important source and a growing concern for climate change in aviation. This paper develops a methodology to determine optimal flight trajectories that minimize the total flying cost in a dynamic, contrail-sensitive environment. The total flying costs consist of costs due to fuel burn, crew, passenger travel time, CO₂ emission, and contrail formation. By constructing a multi-layer hexagonal grid structure to represent the airspace, we formulate the single aircraft trajectory optimization problem as a binary integer program that allows for flight altitude and heading adjustment, and contrail information update. Various cost factors are quantified, in particular the one corresponding to aviation-generated contrails, using the Global Warming Potential concept. Computational analyses show that optimal trajectories depend critically upon the time horizon choice for calculating the CO₂ climate impact. Shifting flights to periods with low contrail effect is not justified, given the limited benefit but potentially large passenger schedule delay cost increase. The analyses are further extended to determining the optimal trajectories for multiple flights using a successive optimization procedure.

Appendices

Appendix A: Algorithm to solve for the optimal trajectory for a single flight

o :

origin node

q :

destination node

d :

flight departure time from o

A :

set of links

N :

set of nodes

T :

maximum allowed time (6000 deca-seconds)

C :

candidate set storing node-time pairs

λ(i,t):

cost for the minimum cost path from o to q through the node-time pair (i, t)

π(i,t):

cost for the minimum cost path found so far from node o and arriving at node i at time t

m(q):

minimum cost to reach node q from o

$\widehat{e}(i)$ :

approximate cost (lower bound) to destination node q from any node i

c _i,j (t _i ):

unit travel cost ($/sec) on link (i,j) when the aircraft leaves node i at time t _i for node j

h _i,j :

travel time (in deca-second) on link (i,j)

${\tilde{c}}_{i,j}\left({t}_i\right)$ :

link travel cost when the aircraft leaves node i at time t _i for node j, equal to c _i,j (t _i )h _i,j

p(j,t _j ):

set of node–time pairs, indicating the best way to reach node j at time t _j from a connected node

x _i,j (t):

binary variable indicating whether the flight leaves node i at time t for node j.

1.1 Algorithm

• Step 1 Compute a lower bound of travel cost from any node in the network to the destination:

  • a. Calculate link travel cost ${\tilde{c}}_{i,j}\left({t}_i\right)={c}_{i,j}\left({t}_i\right){h}_{i,j},\forall \left(i,j\right)\in A\forall {t}_i\in \Big\{1,2,\dots,$ T-h _i,j };

  • b. Define a static network where ${\widehat{c}}_{i,j}=\underset{t}{ \min }{\widehat{c}}_{i,j}(t)$;

  • c. Determine $\widehat{e}(i),\forall i\in N/\left\{q\right\}$ on the static network using Dijkstra’s shortest-path algorithm.

• Step 2 Initialization:

  • a. λ(i,t) = ∞, π(i,t) = ∞, ∀ (i,t) ∈ N × {1,2, …,T};

  • b. x _i,j (t) = 0, ∀ (i,j) ∈ A, t ∈ T;

  • c. t _o = d, $\lambda \left(o,d\right)=\widehat{e}(o)$, π(o,d) = 0, m(q) = ∞, C = {(o,d)};

• Step 3 Select a node-time pair with minimum label λ(i,t _i ):

  • a. $\left(i,{t}_i\right)= \arg \underset{\left(j,{t}_j\right)\in C}{ \min}\lambda \left(j,{t}_j\right)$;

  • b. Update C: C = C\{(i,t _i )}.

• Step 4 Stopping criterion:

  If i = q, then Stop. Otherwise, go to Step 5.

• Step 5 Explore forward route:

  For j ∈ {(i,j) ∈ A and j ≠ o}

  • a. Update time: t _j  = t _i  + h _i,j (t _i );

  • b. If t _j  ≤ T and $\left(\pi \left(i,{t}_i\right)+{\tilde{c}}_{i,j}\left({t}_i\right)<\pi \left(j,{t}_j\right)\right)$ and $\left(\pi \left(i,{t}_i\right)+{\tilde{c}}_{i,j}\left({t}_i\right)+\widehat{e}(j)<m(q)\right)$

    • i. Update minimum cost to j from o at t _j : $\pi \left(j,{t}_j\right)=\pi \left(i,{t}_i\right)+{\tilde{c}}_{i,j}\left({t}_i\right)$;

    • ii. Update minimum cost from o to q through node-time pair (j,t _j ): $\lambda \left(j,{t}_j\right)=\pi \left(j,{t}_j\right)+\widehat{e}(j)$;

    • iii. Record the node-time pair connection: p(j,t _j ) = (i,t _i );

    • iv. Augment candidate set C: if (j,t _j ) ∉ C then C = C ∪ {(j,t _j )};

    • v. If j = q, update the minimum cost from o to q: m(q) = π(j,t _j ).

• Step 6 Check if the candidate set is empty:

  If C=∅,

Stop. Trace out the optimal trajectory starting from p(q,t _q ), and update x _i,j (t).

Otherwise, go to Step 3.

Appendix B

Table 6 Scheduled flights among the five airports (JFK, DTW, STL, ORD, IAD) between 5 and 9 pm on May 24, 2007

Appendix C: Algorithm to solve for the optimal trajectory for multiple flights

f :

flight index after sorting by scheduled departure time

o _f :

origin node for flight f

d ^f :

scheduled departure time for flight f

a ^f :

actual arrival time at the final destination for flight f (in deca-seconds)

x ^l _i,j (t):

binary variable indicating whether flight l leaves node i at time t for node j.

3.1 Algorithm

• Step 1 Initialization: sort the N flights by their scheduled departure time, such that d ^f < d ^f + 1 (f = 1, 2, …, N − 1).

• Step 2 Determine the optimal trajectory for the first flight (f = 1) by solving the program (1)–(5) in Section 4.

• Step 3 Determine the optimal trajectories of the subsequent flights:

  • a. Update f: f = f + 1;

  • b. Update the cost matrix by imposing the minimum separation requirement constraint and allowing ground delays:

    • i. Two-minute minimum separation constraints:

      If x ^l _i,j (t) = 1, ∀ t ∈ (1,2,..,a ^l) and l ∈ (1, 2,.., f − 1), then

      ${\tilde{c}}_{k,i}\left(t+s\right)=\infty, \forall \left(k,i\right)\in A,i\in N/\left\{{o}_f\right\},s\in \left\{-12,-11,\dots, 11,12\right\}$ ¹⁰;

    • ii. Allowing ground delays by adding a virtual node o ^v _f which is connected to the departure airport node o _f , such that ${\tilde{c}}_{o_f,{o}_f^v}(t)={\tilde{c}}_{o_f^v,{o}_f}(t)=\frac{1}{3}{c}_{cruise}^{24000}{h}_{o_f,{o}_f^v}$, ∀ t ∈ {0, 1, 2…, T}, where c ²⁴⁰⁰⁰ _cruise denotes the aircraft unit cost ($/sec, excluding cost due to contrails) during cruise at 24,000 ft, and ${h}_{o_f,{o}_f^v}=10\ \sec$. Augment N and A: N = {N,o ^v _f }; A = {A, (o _f ,o ^v _f ), (o ^v _f ,o _f )}.

    • c. Determine the optimal trajectory for flight f by solving the program (1)-(5) in Section 4 with updated cost matrix information and augmented node and link space from b;

    • d. Termination check: if f = N, then stop; otherwise go to step a.

Appendix D

Table 7 Total travel cost, time, time spent in PCFA and on the ground for each flight under various scenarios (no PCFA, contrail cost multiplier equals 1, 5, and 10)