An A algorithm for the “1 versus n” problem

Chapter 2. Air Route Optimization

2.3. A network of separate 3D-tubes for the main traffic flows

2.3.3. An A algorithm for the “1 versus n” problem

2.3.3.1. General description of tree-search or graph-search methods

The A algorithm belongs to the class of tree-search or graph-search methods which explore a state space represented by a tree or a graph. Starting from an initial state u₀– the tree root in the case of tree-search algorithms or a source node when using a graph representation – the objective of such problem-solving methods is to find a final state that is a solution to the problem being addressed. This final state is represented by a tree leaf, or by a sink node, depending on the chosen representation.

The general principle of these methods is quite simple: a frontier F, initially containing onlyu0, is iteratively expanded until a solution state is obtained. At each iteration, a node uis chosen in the frontierF and removed from F. If uis not a solution state, it is developed by applying a set of production rules in order to obtain a set of successor states. These successor states are then inserted in the frontierF, and the process is repeated until a solution is found, or until the frontierFis empty.

The main difference between tree-search and graph-search methods is that in the case of a graph representation, we need to memorize the states that have already been developed, storing them in a set D. If a successor v of the current stateualready belongs toD, there is no need to insertvin the frontierF, unless the path tovpassing throughuhas a lower cost.

Different exploration strategies can be used – e.g. breadth-first, depth-first, or best-first for the tree-search methods – depending on how the current nodeuis chosen in the frontierF.

2.3.3.2. TheA algorithm

TheA algorithm uses a best-first strategy to find the path of minimum cost from an initial stateu0(tree root or source node, depending on the chosen representation) to a final state (tree leaf or sink node). A heuristic function is used to estimate the cost of the path between the current state and a terminal state. The cost of the successive state transitions betweenu₀ and the stateuis cumulated, and summed with the heuristic estimationh(u). This sumcost(u) +h(u)determines the priority of nodeuinF, which is implemented as a priority queue. The best element inFis then simply the one with the lowest cost estimate. This is the node which is taken first inFand developed.

A simple illustration of this algorithm is the path-finding problem in a road network. Let us assumeu₀ is the departure town, and the objective is to find the shortest path to a destination town u_f. The set of terminal states is then simply T = fu_fg. In this problem, the cost k(u_i; u_i+1) of a transition between two successive statesui andui+1 (here two neighboring towns connected by a road) is simply the travel distance by road betweenuiandui+1. The heuristich(u)of a node ucan be chosen as the distance as the crow flies betweenuand the destinationuf. The cost of the path from u0 to a node u is the sum cost(u) = P

path(u0;u)k(ui; ui+1). TheA algorithm picks up the nodeuinF for which the estimated path length cost(u) + h(u) is the shortest. This node is developed by computing its successorsS=fv1; v2; :::; vkg. Each successorv2Sis then added to the frontierF, with prioritycost(v) +h(v) =cost(u) +k(u; v) +h(v)if statevhas never been encountered before. If it has been encountered before (u2D[F), it is reinserted inF with its new priority only ifcost(u) +k(u; v), the cost of the path to vpassing throughu, is lower than the best cost ofvfound so far.

The formal description of theA algorithm is given in algorithm 1. The notations used in this algorithm are summarized in the following list:

u0: initial state;

T: set of terminal nodes (solutions);

D: set of developed nodes;

F: set of nodes on the frontier. These are the generated nodes not developed yet;

h(u): heuristic function estimating the cost of the path between the current stateu and a terminal state belonging toT;

cost(u): memorizes the best cost for the path fromu0tou;

f(u): estimate of the total cost of the path fromu0 to a terminal node, passing throughu. This quantityf(u) =cost(u) +h(u)is the sum of the cost of the path fromu0 touand the heuristich(u)estimating the cost of the path fromuto a terminal node;

k(u; v): cost of a transition from stateuto statev;

parent(v): memorizes the parent of nodevfor which the path fromu0tovis of lowest cost.

In addition to these notations, the three following functions implement the best- first strategy used by theA algorithm to explore the state space:

– EXPAND: function applying a set of production rulesfp1; p₂; :::; p_kgto a state u, in order to obtain a set of successorsS=fv1; v₂; :::; v_kg. In the example of a road network, the successors of a townuare simply the neighboring towns linked touby a road.

– BESTINFRONTIER: function returning the best nodeuin frontierF. This is the node for which the estimatef(u) =cost(u) +h(u)of the total cost of a path passing throughuis the lowest.

– ADDORREPLACE: add a nodevto the frontierF, or replace its priority by the new estimatef(v), ifvwas already inF.

ALGORITHM1.–A algorithm.

Require: Initial Stateu0

1: F fu0g 2: cost(u0) 0 3: whileF6=;do

4: u BESTINFRONTIER(F) .Takeu2F with the smallest valuef(u) 5: F Fn fug .Remove it from the frontier 6: ifu2T then .Case whereuis a terminal node: return full path 7: returnPATH(u0; u)=u::parent(u) ::parent(parent(u)) ::: : :::u0

8: else

9: D D[ fug .Add nodeuto the set of developed nodes 10: S EXPAND(u) .Developu(i.e. compute its successors) 11: for allv2Sdo

12: ifv =2D[Forcost(v)> cost(u) +k(u; v)then

13: cost(v) cost(u) +k(u; v) .Store the cost of pathu0; : : : ; u; v 14: f(v) cost(v) +h(v) .Cost estimatef(v)giving the priority ofv

15: parent(v) u .Storeuas the parent ofv

16: F ADDORREPLACE(v; f(v); F) .Insertvin frontierF

17: end if

18: end for

19: end if 20: end while

21: returnFAILURE .Case where the frontier is empty, and no solution was found

2.3.3.3. State space representation for the simplified 3D-trajectory model For the sake of brevity and clarity, in this section and the following sections, we shall only present the state space and the cost and heuristic functions for the simplified model, knowing that they are quite similar in the case of the more realistic model.

The state representing a 3D-trajectory in construction is a collection of the following variables:

r: a discrete variable encoding the choice of the 2D-route.

lc: the successive CFLs between the departure point and the end of the current trajectory segment.lc is a list of couples (dk; CF Lk), wheredk is the distance along routerat which begins a climb or descent toward flight levelCF Lk. status: the status at the current segment, represented as a categorical variable that can take one of the following values:Start,Cruise,Climb/descentorEnd.

cdata: additional data related to the current cruise segment, if any:

- ifstatus=Cruise, the fieldcdatacontains a couple(d_e; f inal)where d_eis the distance along routerat which it is planned to end the current cruise segment, andf inal is a boolean. The cruise end can correspond either to the beginning of the final descent, in which casef inalis set to T rue, or to the beginning of a new climb/descentsegment that is not fully defined yet. In that case, the booleanf inalis set toF alse;

- for any other value ofstatus, the fieldcdatashould be empty.

To summarize, a stateuis simply a tuple(r; l_c; status; cdata). The initial state u0 can be encoded by the tuple (_;[]; Start;_), where the underscore represents uninitialized variables and [] is an empty list.

The following rules are applied when computing the successors of stateu:

– Initial state u = u₀.– There are as many successors to the initial state as the number of possible routes. With the simplified model, there are three parallel 2D-routes, and thus three successors to the initial state, one for each route. For each successor, the listlcis initialized with[(0; CF L0)], whereCF L0is the highest flight level for which the first climb segment intersects no other previous 3D-trajectory. It is at most equal to theRF L.

– Climb/descent segment u = r; lc; Climb=descent;_ .– Assuming lc = [(d0; CF L0);: : :; (dj; CF Lj)], the successors ofucorrespond to two possible actions

on the 3D-trajectory: change the current target flight level CF Lj, or freeze the cruising segment at flight levelCF Lj. This gives us at most two successors:

-v1= r;[(d0; CF L0);: : :; (dj; CF Lj F L)]; Climb=descent;_ -v2= r;[(d0; CF L0);: : :; (dj; CF Lj)]; Cruise;(de; f inal)

The value of F L in the expression of v1 is set to 1;000 feet. The successor v1 is discarded if the new climbing or descending segment intersects with other 3D-trajectories, or if CF Lj F L is below a minimum value F Lmin. When computingv2, the distance de is chosen as the longest possible distance for which the new cruise segment intersects no other trajectory. The largest possible value forde

is when the cruise segment continues without intersecting other trajectories until the final descent toward the arrival airport begins. In this case, the booleanf inalis set to T rue, and otherwise toF alse.

– Cruise segment u = r; l_c; Cruise;(d_e; f inal) .– If the current trajectory segment is a cruising segment, the successor states correspond to one of the three following possibilities: a shortening of the current cruise segment, the addition of a climb/descent segment or the addition of the final descent segment iff inal =T rue and if this descent segment does not intersect with the other trajectories. Assuming lc = [(d0; CF L0);: : :; (dj; CF Lj)], this will give the three following successors:

-v1= r; lc; Cruise;(de ; F alse)

-v₂= r;[(d₀; CF L₀);: : :; (d_j; CF L_j); (d_e; CF L_j+1)]; Climb=descent;_ -v3= r;[(d0; CF L0);: : :; (dj; CF Lj); (de; CF Larr)]; End;_

When computing v1, the 2D-route is discretized and is chosen such that de

falls on the closest discretization point. For v2, corresponding to the addition of a new climb/descent segment, the flight levelCF L_j+1is chosen as the highest possible level, different fromCF L_jand within[F L_min; RF L], such that the climb or descent between levelsCF L_jandCF L_j+1is free of any intersection with other trajectories.

The successorv₃, which is a terminal state, is removed from the list of successors if the final descent to arrival intersects another trajectory.

– End segment.– This is a terminal state, with no successor.

Note that with these production rules, the algorithm always tries first to produce a vertical profile that is as close as possible to the ideal profile (cruise atRF L). The chosen value for any new CFL is by default the closest one to RF Lfor which the current 3D-trajectory (up to the current point) intersects with no other trajectory.

This is why theCF Lvalues are only decremented when computing the successors.

The same applies to the length of the cruising segments: the longest possible length

without intersection is chosen first, and the distances are decremented afterward, if required.

2.3.3.4. Cost and heuristic for the simplified 3D-trajectory model

The costk(u; v)of a transition from a parent stateuto a successorvdepends on the nature ofu:

– if u = u₀ is the initial state, only the cost of route lengthening is taken into account:

k(u₀; v) =K l lref

lref [2.3]

– if u = r; lc; Cruise;(dj+1; f inal) is a cruise segment ending at distance dj+1, with lc = [(d0; CF L0);: : :; (dj; CF Lj)], and if the next state v is a climb/descent segment, the cost of the transition is the area between the actual vertical profile delimited by distancesdjanddj+14, and theRF L, as shown in Figure 2.8;

– ifuis the final descent segment and vis a terminal state (End),k(u; v)is the surface between the final descent segment andRF L;

– In all other casesk(u; v) = 0.

The chosen heuristic function is computed by considering a vertical profile starting at the end of the current segment and joining the desired profile. Such a profile is illustrated in Figure 2.9.

Denoting A(u; arr) the area shown in Figure 2.9, delimited by the end of the current segmentu, the arrival point, the profile joining the ideal profile and flight levelRF L, the heuristic function is expressed as follows, wheredto_gois the distance remaining to be covered to the destination:

h(u) =A(u; arr)

d_{to_go} [2.4]

State u State v

Figure 2.8.Example of area used to compute the transition cost 4 The same applies withdjanddeiff inal=T rue.

¢ ¢ ¢ ¢ ¢

£ £ £ £

¤ ¤ ¤ ¤ ¤ ¤ ¤ ¤ ¤ ¤

¥ ¥ ¥ ¥ ¥ ¥ ¥ ¥ ¥ ¥

Ideal profile

Profile with smallest deviation cost Actual profile

Figure 2.9.Vertical profile with smallest deviation cost betweend3and arrival, and area used to compute the heuristic

By construction, this heuristic is a lower bound of the actual cost of any state transitions from the current state to a terminal state. Figure 2.9 shows an example of what these remaining transitions might be, with a descent toward flight levelCF L3, a cruise segment atCF L3, and the final descent to the arrival airport. We can see that the actual cost of this intermediate level atCF L3, which depends on the surface of the area above the actual profile, is higher thanh(u).

Note that by construction, the sum of the transition costsPk(u; v)for the whole profile is equal to the deviation cost defined in section 2.3.1.2.

2.3.4. A hybrid evolutionary algorithm for the global problem

Dalam dokumen Metaheuristics for Air Traffic Management (Halaman 49-55)