Route selection methods for dry bulk terminals

(1)

Delft University of Technology

Literature Research

Route Selection Methods for Dry

Bulk Terminals

Author:

Robbert Dijkstra

1358928

Supervisor:

Ir. T. van Vianen

(2)

(3)

Introduction

Dry bulk terminals are used to disconnect two modes of transportation, offering temporary storage of goods. In a dry bulk terminal the products are transported by a set of belt conveyors to their location at the stockyard. When the products enter the system they are stored on a stockpile, which is a pile of dry bulk of the same quality and type. In Figure 1.1 one can see the stockpiles in the stockyard, some belt conveyors and a ship used to transport dry bulk. Transport in the terminal is done by belt conveyors. The belt conveyors form a set of routes, and multiple routes can end at the same destination. Not all routes have the same length however, only one or a few of them can be seen as the optimal solution. The optimal solution in this situation would the fastest route, and since all speeds in the terminal are the same, the fastest route would be the shortest route.

Figure 1.1: A photo of a dry bulk terminal

(6)

the efficiency at which it operates. An efficient system yields an economical advantage, since a smaller system would be able to offer the same performance as a less efficient bigger system, reducing the investment costs and operating costs. Since the shortest path uses a lower number of moving parts it could result in lower maintenance costs, since parts operate less often and therefore will have to be replaced less frequently.

Careful planning and routing can improve the efficiency of the system and increase the performance. This optimization can be done in two different ways. Either every route is calculated individually, or the whole system is taken into account. In the latter the individual routes may be suboptimal, but the solution for the whole system would be optimal, resulting the highest performance.

In current literature there is a lack of documentation how routes are currently determined and which algorithms are used in bulk terminals. However, there is a lot of literature available for situations that could be used for routing in a bulk terminal. It is questionable which algorithms can be adapted and which would offer the best performance.

During this literature research report an overview will be made of route selection methods and algorithms that can be adapted for use in a bulk terminal, both for the individual solution as for the total solution. The algorithms listed will be discussed and a recommendation for further research will be made.

(7)

Chapter 2

General

In this chapter the current situation will be presented and the goals of a route selection method will be discussed. The purpose of these methods or algorithms is to find the optimal route between two points which can be defined as the shortest route, the fastest route or the route with the lowest costs.

2.1 Situation

Before being able to solve the problem, first the problem needs to examined. What is the current situation and what are we trying to solve? In a bulk terminal a network of belt conveyors is made to transport the goods from the input to a storage location, or a the storage location to a output.

This network of belt conveyors is represented by a figure, also known as a weighted graph, see an example in Figure 2.1. In general, a weighted graph is defined by G(V,E), which contains a set of vertices V and set a of edges E. Edges are defined as a connection from vertex to vertex, often written as {(a,b)} which indicates there is a connection from vertex a to vertex b. In shortest path problems the start vertex or the source vertex is denoted as s and the destination node as t.

I1 I2 I3 1 2 3 7 8 9 13 14 15 O1 O2 O3 4 5 6 10 11 12 16 17 18 S1 S2 S3 S4 S5 S6 S7

Figure 2.1: A bulk terminal layout represented in a weighted graph. In the weighted graph the inputs I (I1 to I3), the outputs O (O1 to O3), stockpiles S (S1 to S7) and the transfer stations (1 to 18).

(8)

number on the edges, which is known as the weights, represent the distance or travel time on each edge. So by looking at the figure we can determine how vertices are connected and what the distance of these connections are. For example, in Figure 2.1 there is a route possible from I3 to S4, with the path of I3-3-9-S3-S4. The distance of this path is the summarized weights of all the edges, which is 26.

In Figure 2.1 a weighted graph is is made of a typical lay out of a dry bulk terminal. Here we can see the input I, the stockpiles S and the outputs O. The rest of the numbered vertices are connection points for multiple belt conveyors. The lay out of dry bulk terminals can be much more complex than this situation, however, the way how the problem is solved does not change. More complex situations require more calculations to find the solution.

2.2 Problem definition

2.2.1 Goal

Given a directed weighted graph similar to Figure 2.1, which represent the bulk terminal and its belt conveyors, the algorithm has to find a solution which should be optimal, or present a short proof none exists.

2.2.2 In- and outputs

Most algorithms works as follows, which can be seen in chapter 3. The algorithm first learns the layout of the terminal by creating the vertices, the edges and the weights, which also known as the initialization of the algorithm. When the algorithm knows how the vertices are connected the route can be calculated. A source vertex and a destination vertex are given to the algorithm, and the (sub)optimal solution is returned.

2.2.3 Measuring performance

The throughput of the terminal is very important when considering the perfor-mance of the terminal. However, this might not be a proper indication of the total performance annually. When the terminal has no ship or train to either load or unload the performance will appear to decrease. A better indication of performance would be the average port time, in this case the time is measured between the moment the ship or train arrives and the moment it leaves. The port time exists out of two parts: the waiting time before it can be serviced and the time it takes to service. If the ship or train has a lower port time it indicates that the terminal operates at a higher performance.

Dry bulk terminals have agreed with ship operators on a certain service rate, in tons per hour. By calculating the average service rate it can be checked if this promise is kept. Depending on the capacity of the ship the agreed port time can be found as well. If the port time of the ship or train is compared with the agreed port time we can find the percent of ships or trains that were serviced within time. The same can be found for trains instead of ships.

Indications of performance will be: • Mean ship port time (in hours)

(9)

• Mean train port time (in hours) • Average throughput (in ton per hour) • Average ship service rate (in ton per hour) • Average train service rate (in ton per hour) • Realized ship targets (in percent)

• Realized train targets (in percent)

A combination of the seven will be used to determine the best performance routing algorithm. However, one can choose to give a higher priority to either ship or train waiting times, due to economic reasons. Ships will be more likely to be more expensive to have waiting.

(10)

Chapter 3

Shortest Path Problem

Many mathematical methods exist for solving shortest path problems, but dur-ing this literature research only a limited number can be discussed. This is due to the fact that there are many algorithms and in this report there is not the need nor the time to discuss them all. In this chapter the selection of short-est path problem algorithms will be done and the selected algorithms will be presented.

The problem that is given by the weighted graph in section 2.1 is not complex when compared to standard routing problems. Only when the number of vertices increase to several hundred thousands, significant differences in performance can be found [1]. In the bulk terminal problem, no negative cycles exist and the problem has a rather low number of vertices and edges, so it is not a complex problem. All shortest path algorithms should be able to solve the problem quickly.

Algorithms differ in the way how they find the optimal solution, and if this is the optimal solution or a suboptimal. They can either work by applying brute force, exploring all possible routes and have definite proof that they selected the optimal route, or only explore the most promising routes. In the latter it could be possible that they would miss the optimal route, returning only a suboptimal route instead of the optimal route.

For further research a decision should be made which algorithms should be examined. This is done by studying earlier published works on shortest path algorithms, and their comparisons [1, 2, 3, 4, 5]. Since the problem that will be solved is simple in comparison to normal shortest path problems, a limitation is made to the core algorithms and simple variations.

3.1 Dijkstra algorithm

3.1.1 In general

One of the most well known algorithms for shortest path problems is Dijkstra’s algorithm [6]. There are many adaptations of Dijkstra’s algorithm to make the search process smarter, and due to the smarter algorithm the computations that are needed to find the solution will decrease. Dijkstra’s algorithm takes a start node, and expands through all possible routes until it has found a possible route to the destination. It stops when the unfinished routes (that are still being

(11)

expanded) have a longer length than the already found route to the destination vertex. These unfinished routes will never be finished since they will never be an optimal solution. It can be compared to planting a seed in the initial vertex and having the roots grow in all directions at equal speed. The algorithm stops when one of roots has reached the destination vertex, the path of these roots will be the optimal solution.

3.1.2 Theory of the Dijkstra algorithm

So the Dijkstra algorithm starts at the initial node, and progresses it search outwards. The steps that the algorithm takes are as follows:

1. Reset the distances. All vertices v will have a certain distance to the initial vertex s. First the distance for the source vertex is set so zero, and for all other vertices to infinity. This distance label will work as an upper bound for the optimal solution.

d(s) = 0 d(v) = ∞

2. Set all vertices to unvisited and the initial vertex as current. Two sets are created, one containing all unvisited vertices U and one containing all visited vertices I (currently just the initial vertex s). To start the process the source vertex s is made the current vertex c, as the search process will start here.

c = s I = [s]

U = [v1 v2 ... vi]

3. Explore the vertices w around the current vertex c. Calculate the distance to the adjacent unvisited vertices from the initial vertex s. If the distance total distance from the initial vertex s through the current vertex c is shorter than the distance with an other path, it will overwrite the distance. For each edge (c,w), check if d(w) >d(c) + l(c,w)

If it is, set d(w) = d(c) + l(c,w)

4. Set the current vertex c to visited. Since all adjacent vertices are explored, the current vertex c is visited and it can be transferred from the unvisited U set to the visited set I.

Move c from U to I

5. Check termination criteria. If the destination vertex t has the lowest distance in the unvisited set U the algorithm terminates, the route has been found. Another option is that all vertices in the unvisited set have a distance of infinity to the initial vertex s, which means that all possible routes are examined, and no route is possible.

terminate algorithm if d(s,t) = min(d(s,v) in U) or min(d(s,v) in U) = ∞

(12)

6. Mark a new vertex as current. A new current vertex should be found. The one with the lowest distance to the initial vertex s from the unvisited set U will be the new current node c and process will repeat itself from step 3.

min(d(s,v) in U) = c

When this process is repeated and a possible route exists from the source vertex to the destination vertex, than the optimal route will be found.

3.1.3 Implementation in the original situation

Dijkstra’s algorithm can be implemented in the situation that was show in Figure 2.1 on page 6. In the example underneath the fastest route from vertex I3 to S5 will be calculated using the steps in section 3.1.2.

I1 I2 I3 1 2 3 7 8 9 13 14 15 O1 O2 O3 4 5 6 10 11 12 16 17 18 S1 S2 S3 S4 S5 S6 S7

Figure 3.1: The original weighted graph with the green source vertex s and the red destination vertex t.

0

(13)

0

Figure 3.3: Step 2 of Dijkstra’s algorithm. Vertices are set to unvisited and the source vertex to current. In the images the current vertex is purple, unvisited are yellow and the visited vertices blue.

0 6 ! ! " !

Figure 3.4: Step 3 of Dijkstra’s algorithm. Update the distances around the current vertex. 0 6 # # # # # # $ %$ # & & & ' ' ' ' & & & ' ' ( ( & & ) ' ' %( ' ' & & & & & & ' ' '

Figure 3.5: Step 4 and 5 of Dijkstra’s algorithm. Current vertex is now visited. Termination criteria are checked, but both expressions are not true.

(14)

0 6 * * * * * * + ,+ * -. . . . -. . / / - - 0 . . ,/ . . -- -. . .

Figure 3.6: Step 6 of Dijkstra’s algorithm. New vertex is marked as current vertex.

Now the process will continue from step 3 again, as long until the expressions in step 5 are met. In Figure 3.7 the situation is shown when the expressions in step 5 are true, in other words, when the solution is found. Here can be seen that all unvisited vertices have a higher distance to the source vertex than 17, which is the distance that is found to the destination vertex, thus it is the optimal route. In order words routes in all directions have been explored, until they had a distance of higher than 17.

20 16 0 14 10 6 17 13 9 20 16 12 26 1 1 1 1 1 1 12 14 24 17 2 32 1 4 4 4 5 5 5 5 4 4 4 5 5 6 6 4 4 7 5 5 36 5 5 4 4 4 4 4 4 5 5 5

Figure 3.7: Final solution using Dijkstra’s algorithm.

3.2 A* algorithm

3.2.1 In general

The A* algorithm [7] (pronounced as A star) is one of the many extensions of Dijkstra’s algorithm. It differs from Dijkstra’s algorithm in the way how it finds the path which will be explored. A* uses a best-first search to find the next node, while the Dijkstra algorithm explores in all directions. In other words, the A* algorithm only explores paths that have a high possibility of being the shortest one. Needless to say, the A* algorithm yields much better performance than Dijkstra’s algorithm, but it could settle for a suboptimal route. The A* algorithm and its adaptations is currently the most used solution for shortest path problems.

(15)

3.2.2 Theory of the A* algorithm

Similar to Dijkstra’s algorithms, the A* algorithm starts at the initial node, but it only explores the most promising nodes to mark as current to continue. If this route does not lead to a result, it will continue with the most promising node along the already traveled path. The way how it decides which node should be explored next is done by using a cost function, which is based on previous data and future predictions.

(3.1) f(v) = d(v) + π(v)

The two components in this cost function are:

• d(v) Past path-cost function. This part of the cost function takes the past into account, which is the known distance from the initial node to the current node v.

• π(v) Future path-cost function. A estimation for the future, what the distance will be from the current node to the destination node.

The formula 3.1 returns the estimated distance from the initial node v to the destination node t. The rest of the implementation of the algorithm is identical to Dijkstra’s algorithm, except for step 6.

1. Reset the distances. All vertices v will have a certain distance to the initial vertex s. First the distance for the source vertex is set so zero, and for all other vertices to infinity. This distance label will work as an upper bound for the optimal solution.

d(s) = 0 d(v) = ∞

2. Set all vertices to unvisited and the initial vertex as current. Two sets are created, one containing all unvisited vertices U and one containing all visited vertices I (currently just the initial vertex s). To start the process the source vertex s is marked as the current vertex c, as the search process will start here.

c = s I = [s]

U = [v1 v2 ... vi]

3. Explore the vertices w around the current vertex c. Calculate the distance to the adjacent unvisited vertices from the initial vertex s. If the distance total distance from the initial vertex s through the current vertex c is shorter than the distance with an other path, it will overwrite the distance. For each edge (c,w), if d(w) >d(c) + l(c,w)

then d(w) = d(c) + l(c,w)

4. Set the current vertex c to visited. Since all adjacent vertices are checked out, the current vertex c is visited and it can be transferred from the unvisited set to the visited set.

(16)

5. Check termination criteria. If the destination vertex t has the lowest distance in the unvisited set U the algorithm terminates, the route has been found. Another option is that all vertices in the unvisited set have a distance of infinity to the initial vertex s, which means that all possible routes are examined, and no route is possible.

terminate algorithm if d(s,t) = min(d(s,v) in U) or min(d(s,v) in U) = ∞

6. Mark a new vertex as current. A new current vertex should be found to continue to search process. This is done by selecting a vertex from the unvisited set U that has the smallest value of f(v). Now the process continues from step 3 again.

min(f(v) in U) = c

3.2.3 Implementation in the original situation

Similar to the implementation of Dijkstra’s algorithm, now the A* algorithm will be used to solve the original weighted graph. In the example underneath the fastest route from vertex I3 to S5 will be calculated using the steps in section 3.2.2. 0 8 8 8 8 8 8 9 :9 8 ; ; ; < < < < ; ; ; < < = = ; ; > < < := < < ; ; ; ; ; ; < < <

Figure 3.8: Step 1 of the A* algorithm. Reset the distances.

0 ? ? ? ? ? ? @ A@ ? B B B C C C C B B B C C D D B B E C C AD C C B B B B B B C C C

Figure 3.9: Step 2 of the A* algorithm. Vertices are set to unvisited and the source vertex to current. In the images the current vertex is purple, unvisited are yellow and the visited vertices blue.

(17)

0 6 F F F F F F G HG F I I I J J J J I I I J J K K I I L J J HK J J I I I I I I J J J

Figure 3.10: Step 3 of the A* algorithm. Update the distances around the current vertex. 0 6 M M M M M M N ON M P P P Q Q Q Q P P P Q Q R R P P S Q Q OR Q Q P P P P P P Q Q Q

Figure 3.11: Step 4 and 5 of the A* algorithm. Current vertex is now visited. Termination criteria are checked, but both expressions are not true.

0 6 T T T T T T U VU T W W W X X X X W W W X X Y Y W W Z X X VY X X W W W W W W X X X

Figure 3.12: Step 6 of the A* algorithm. New vertex is marked as current vertex.

Now the process will continue from step 3 again, as long as the expressions in step 5 are met. As can be seen in the steps, there are no differences at the start how Dijkstra’s algorithm and the A* algorithm begins the solve the prob-lem. However when we look at the final solution we can see quite a significant difference. In Figure 3.13 the final solution can be seen. We see that all vertices on the left are not explored, while Dijkstra’s algorithm explored them. Before coming to the optimal solution the A* algorithm needed less than half of the iterations that Dijkstra’s algorithm needed.

(18)

0 10 6 13 9 16 12 [ [ [ [ [ [ 12 14 17 \ ]\ [ ^ ^ ^ _ _ _ _ ^ ^ ^ _ _ ` ` ^ ^ a _ _ ]` _ _ ^ ^ ^ ^ ^ ^ _ _ _

Figure 3.13: Final solution using the A* algorithm.

3.3 Bellman-Ford-Moore

3.3.1 In general

Like Dijkstra’s algorithm, the Bellman-Ford-Moore algorithm [8] has a signifi-cant contribution to other algorithms. Many adaptations exist, making it worth-while to consider as well. The Bellman-Ford-More and Dijkstra’s algorithm are quite similar, but differ in robustness. When in the weighted graph arcs exist with negative lengths they can create a negative loop. Some shortest path algo-rithms would remain stuck in this loop, never finding a solution. The Bellman-Ford-Moore algorithm is able to deal with these problems, instead if returning a wrong solution it gives the result that negative cycles exist. However it is slower than Dijkstra’s algorithm for the same problem, the stability comes at a price. In a dry bulk terminal no negative cycles will exist, so no stability is required and a algorithm with a higher performance is preferred.

3.3.2 Theory of the Bellman-Ford-Moore algorithm

The process of the Bellman-Ford-Moore algorithm works as follows:

1. Initialize the algorithm. For all vertices v the estimate of the distance is set to infinity, and the direction to the parent vertex π in the shortest path is set to NIL since no routes have been formed yet. The distance to the start vertex s is set to zero.

d(s) = 0 d(v) = ∞ π(v) = NIL

2. Relax edges. In this step vertices are explored, and is checked if the newly found distance is less than the already found distance. If it is less the distance will be updated and the parent vertex of this new route also has the be updated. This process is repeated for V - 1 times. For every iteration, the path lengths that are considered are increased by one. For each edge (c,w), if d(w) >d(c) + l(c,w)

then d(w) = d(c) + l(c,w) π(w) = c

(19)

3. Check results for negative cycles. In order to detect negative cycles all edges in the weighted graph are relaxed another time. If no vertices were updated with a smaller value for the shortest distance than there were no negative cycles.

Repeat step 2, if d(v)bef ore = d(v)af ter

Then solution is found

Else negative loop is present, no solution is possible.

Due to the fact that step 2 is repeated for V - 1 times it is no surprise that this algorithm is slower than the one from Dijkstra. Another difference between Dijkstra’s algorithm is that the Bellman-Ford-Moore algorithm expands through all possible edges, while the Dijkstra only expands at the vertex with the lowest distance. Instead of considering the distance, the Bellman-Ford-Moore algorithm considers the number of edges.

3.3.3 Implementation in the original situation

Again, algorithm is implemented in the original situation using the steps de-scribed in section 3.2.2. The desire is again to find the optimal solution for the fastest route from I3 to S5.

0 b b b b b b c dc b e e e f f f f e e e f f g g e e h f f dg f f e e e e e e f f f

Figure 3.14: Step 1 of the Bellman-Ford-Moore algorithm. The algorithm is initialized. 0 6 i i i i i i j kj i l l l m m m m l l l m m n n l l o m m kn m m l l l l l l m m m

Figure 3.15: First iteratation of step 2 of the Bellman-Ford-Moore algorithm. The vertices on which the edges were relaxed are indicated by yellow. Maximum path length of 1

(20)

0 10 6 9 p p p p p p 12 q rq p s s s t t t t s s s t t u u s s v t t ru t t s s s s s s t t t

Figure 3.16: Second iteratation of step 2 of the Bellman-Ford-Moore algorithm. Maximum path length of 2

16 0 14 10 6 13 9 12 w w w w w w 12 14 24 x yx w z z z { { { { z z z { { | | z z } { { y| { { z z z z z z { { {

Figure 3.17: Third iteratation of step 2 of the Bellman-Ford-Moore algorithm. Maximum path length of 3

20 16 0 14 10 6 17 13 9 16 12 26 ~ ~ ~ ~ ~ ~ 12 14 24 17 ~

Figure 3.18: Fourth iteratation of step 2 of the Bellman-Ford-Moore algorithm. Maximum path length of 4

(21)

20 16 0 14 10 6 17 13 9 20 16 12 32 36 40 26 30 34 29 33 37 32 36 40 12 14 24 26 17 21 25

Figure 3.19: Final result after the 30 iterations during step 2. This is also the result of step 3 since another relaxation of the edges will not change the distance values found.

Since the weighted graph has 31 vertices, step 2 will be repeated for 30 times. In the example above iterations 5 to 30 are not displayed. What is important to notice is that after 4 iterations the algorithm already found a possible route, but it does not know if this is the optimal route. The optimal route found after the competition of the algorithm can be found in Figure 3.20.

20 16 0 14 10 6 17 13 9 20 16 12 32 36 40 26 30 34 29 33 37 32 36 40 12 14 24 26 17 21 25

Figure 3.20: Final situation of the Bellman-Ford-Moore algorithm, fastest route indicated with the red line.

(22)

Chapter 4

Multiple shortest path

problems

In the previous chapter we have discussed how the fastest route can be found when the source and destination vertex are known. However, when two tasks will be calculated sequential the first task could block the next task, while with a different solution both tasks could be executed at the same time.

Again the same situation is used as described in section 2.1, but now with multiple tasks at the same time. These tasks are defined by the start and end vertex, their starting time and duration. Assumed is that the time horizon where tasks will be needed to plan is similar to container terminals. No infor-mation can be found on the used time horizon of dry bulk terminals, but in container terminals this varies from 18 to 24 hours [9]. If something changes in the planning due to an unforeseen event, the optimization is recalculated with the new data. The algorithm will consider each time instant, and calculates the optimal solution for that time instant. The calculations are repeated for each time instant so a solution can be formed for the time horizon of 24 hours. All algorithms that will be mentioned will be for one time instant, in order to come to a complete solution need will need to repeated.

As in the shortest path problem section a selection of algorithms should be made which will be discussed. However, the difficulty is that unlike the shortest path problem, there are not a lot of algorithms that are designed for this problem. In literature there are no comparisons made between multiple shortest path algorithms, because the problem is very specific for each situation. There are many algorithms that could be adapted for use to the situation of a dry bulk terminal, but it is unsure which ones would yield have the highest performance. The selection is done by how well the algorithm can be adapted and a rough estimation what kind of performance it could offer.

While this might seem like a maximum flow problem, the weighted graph is not specifically capacity limited. It could be the case that multiple solutions do exist, but only one has the shortest total distance, hence the name multiple shortest path problem.

(23)

4.1 Ford-Fulkerson algorithm

4.1.1 Introduction

The Ford-Fulkerson algorithm [10] is a solution for the multiple shortest path problem, but it is not an optimal one since it computes the shortest paths sequentially, not simultaneously. Normally it computes the maximum flow in a flow network, but if the capacity of the edges are equal to the in- or output into the network than the algorithm checks how many tasks can be executed at the same time. The idea of the algorithm is very simple, as long as there is a path with available capacity on all edges of the path, the algorithm will use this path. The algorithm is written to have have just a single source and destination vertex, but can easily adapted to used at a dry bulk terminal.

4.1.2 Theory of the Ford-Fulkerson algorithm

G(V,E) is again the weighted graph where the solution will take place. On each edge {a,b} there is a capacity c(a,b) and a flow f(a,b). The algorithm normally returns the value of the maximum flow from the source s to the destination ver-tex t; however, our interest are the routes that correspond with this maximum flow. After every step in the algorithm the following constrains should be kept: • Capacity constraint: the flow cannot exceed the capacity along the edges

of the path.

(4.1) f(u, v) ≤ c(u, v)

• Skew symmetry: flow in the opposite direction should have exactly the negative amount.

(4.2) f(u, v) = −f (v, u)

• Flow conservation: the net flow to a vertex is 0, except for the vertices s and t. The source vertex s and the destination vertex t create and consume flow.

(4.3) X

wǫV

f(u, w) = 0 for all u 6= s, t

• Required flow: (4.4) X wǫV f(s, w) = d (4.5) X wǫV f(w, t) = d

To have a clear view on the available capacity of the network a modified weighted graph is created, known as the residual network Gf(V,Ef) where the

(24)

1. Set the flow f(u,v) = 0 for all edges (u,v).

2. While there is a path p (found with Breath-first search) from si to ti in

the modified weighted graph Gf, such that cf(u,v) > 0 for all edges.

(a) Find the capacity of the found path. cp = min{cf(u,v)}

(b) For each edge update the new flows. f(u,v) = f(u,v) + cf(p)

f(v,u) = f(v,u) - cf(p)

The paths in the algorithm are found using a Breadth-first search, which works in a similar way as the Bellman-Ford-Moore algorithm. Each iteration the search space for a solution is increased by one edge, until the solution is found.

4.2 Minimum-cost flow problem

4.2.1 Introduction

The problem of minimum-cost flow [11] is to find the cheapest way of sending maximum flow through a flow network from the source vertex s to the destina-tion vertex t. Similarly to the Ford-Fulkerson algorithm, the theory is designed to use a single source and destination vertex, but can be adapted for multiple source and destination vertices. The core of the Minimum-cost flow problem is essentially the same as the Ford-Fulkerson algorithm, however the way how the paths are found differs.

4.2.2 Theory of minimum-cost flow

As with all other algorithms, there is a weighted graph G = V(V,E) with vertices V, edges E, source vertex s and destination vertex t. Each edge has a capacity c(a,b), flow f(a,b) and a cost k(a,b). The cost of sending flow through a path from a to b is defined as:

(4.6) X

(a,b)ǫE

k(a, b) · f (a, b)

In the algorithm the total cost is defined as the flow over an edge multiplied by the the costs. To adapt it for use in the situation of the dry bulk terminal all flows are 1, and the costs are the weights on the edges, so the total costs would be the summarized distances of all paths.

There are some constraints before the solution can be found, which are the same as with the Ford-Fulkerson algorithm:

• Capacity constraint: the flow cannot exceed the capacity along the edges of the path.

(25)

• Skew symmetry: flow in the opposite direction should have exactly the negative amount.

(4.8) f(u, v) = −f (v, u)

• Flow conservation: the net flow to a vertex is 0, except for the vertices s and t. The source vertex s and the destination vertex t create and consume flow.

(4.9) X

wǫV

f(u, w) = 0 for all u 6= s, t

• Required flow: (4.10) X wǫV f(s, w) = d (4.11) X wǫV f(w, t) = d

In order to solve the problem the algorithm uses several steps to come to its solution, these steps are again very similar to the Ford-Fulkerson algorithm, only during step 2 is different in the method how the path is found:

1. Set the flow f(u,v) = 0 for all edges (u,v).

2. While there is a path p (found with shortest path algorithm) from sito ti

in the modified weighted graph Gf, such that cf(u,v) > 0 for all edges.

(a) Find the capacity of the found path. cp = min{cf(u,v)}

(b) For each edge update the new flows. f(u,v) = f(u,v) + cf(p)

f(v,u) = f(v,u) - cf(p)

Almost all applications of the minimum-cost flow problem use Dijkstra’s al-gorithm to calculate the shortest path. Results of the alal-gorithm for our situation will be similar to using an algorithm for shortest path problems multiple times after each other. After each route solution the edges that are in that path are removed from the weighted graph. The algorithm is the mathematical formula-tion of the problem to remove the possibility using a path for two tasks at the same time.

4.3 Linear programming

4.3.1 Introduction

Linear programming [12] is a method to determine the best desired outcome in a model. Given is a set of linear relationships and constraints, after which software can be used to find the best outcome of the model. The goal can be

(26)

In the case of the dry bulk terminal we want to minimize the summarized total distance.

The way how these sets of agents or paths are found can be done in multiple ways, either in a smart way or by using brute force. With brute force it is implied that all possible routes are calculated that start at the source vertex and end at the destination vertex, limited to a certain number of edges to limit the search space. However, it could take quite some time to calculate all these paths for a complex weighted graph, and especially, when all these paths have to be considered as possible solution the computational time could increase significantly.

It would be smarter to just consider the paths that could contribute to a solution, instead of considering everything. One of these methods would be to find paths that do not share their edges. Routes that do not share their edges are more likely to be able to provide an alternative route when the first option is not available anymore. One of these methods to find disjoint paths could be Suurballe’s algorithm [13]. This algorithm works by using Dijkstra’s algorithm to find an initial path, and repeating the algorithm with a modified weighted graph to find additional routes.

4.3.2 Theory of of linear programming

The formulation of a linear programming includes several components, these are:

• The decision variables. Decision variables are used the specify how many units will be used, these can be adapted in such a way that the desired minimum or maximum is achieved.

• The objective function. As the name says, this is the goal of the method to either minimize or maximize the outcome of this function. • The constraints. By including constraints it can be prevented that too

many or too little decision variables are used. blabla

4.3.3 Implementation of linear programming

The method of linear programming is already quite old, but it seems that it is well suited to solve the transportation problem we have here. Before solving the problem we need to define the problem itself. In the example underneath a simple representation is made of the problem in the dry bulk terminal introduced in section 2.1. The desire is to find two routes, one from the yellow vertex I1 to the orange vertex S7 and one from the blue vertex I2 to the purple vertex S1, see also Figure 4.1. To give an indication how the problem is defined we will consider 3 routes for both destination vertices, as can be seen in Figure 4.2 to Figure 4.7.

(27)

I1 I2 I3 1 2 3 7 8 9 13 14 15 O1 O2 O3 4 5 6 10 11 12 16 17 18 S1 S2 S3 S4 S5 S6 S7

Figure 4.1: The source (yellow and blue) and destination (orange and purple) vertices that will be used.

I1 I2 I3 1 2 3 7 8 9 13 14 15 O1 O2 O3 4 5 6 10 11 12 16 17 18 S1 S2 S3 S4 S5 S6 S7

Figure 4.2: First route P1 of the 3 total possible routes for the first transporta-tion task. I1 I2 I3 1 2 3 7 8 9 13 14 15 O1 O2 O3 4 5 6 10 11 12 16 17 18 ¡ ¡ ¡ ¡ ¡ ¡ S1 S2 S3 S4 S5 S6 S7 ¢ £¢ ¡ ¤ ¤ ¤ ¥ ¥ ¥ ¥ ¤ ¤ ¤ ¥ ¥ ¦ ¦ ¤ ¤ § ¥ ¥ £¦ ¥ ¥ ¤ ¤ ¤ ¤ ¤ ¤ ¥ ¥ ¥

Figure 4.3: Second route P2 of the 3 total possible routes for the first trans-portation task. I1 I2 I3 1 2 3 7 8 9 13 14 15 O1 O2 O3 4 5 6 10 11 12 16 17 18 ¨ ¨ ¨ ¨ ¨ ¨ S1 S2 S3 S4 S5 S6 S7 © ª© ¨ « « « ¬ ¬ ¬ ¬ « « « ¬ ¬ « « ® ¬ ¬ ª ¬ ¬ « « « « « « ¬ ¬ ¬

Figure 4.4: Third route P3 of the 3 total possible routes for the first transporta-tion task.

(28)

I1 I2 I3 1 2 3 7 8 9 13 14 15 O1 O2 O3 4 5 6 10 11 12 16 17 18 ¯ ¯ ¯ ¯ ¯ ¯ S1 S2 S3 S4 S5 S6 S7 ° ±° ¯ ² ² ² ³ ³ ³ ³ ² ² ² ³ ³ ´ ´ ² ² µ ³ ³ ±´ ³ ³ ² ² ² ² ² ² ³ ³ ³

Figure 4.5: First route P4 of the 3 total possible routes for the second trans-portation task. I1 I2 I3 1 2 3 7 8 9 13 14 15 O1 O2 O3 4 5 6 10 11 12 16 17 18 ¶ ¶ ¶ ¶ ¶ ¶ S1 S2 S3 S4 S5 S6 S7 · ¸· ¶ ¹ ¹ ¹ º º º º ¹ ¹ ¹ º º » » ¹ ¹ ¼ º º ¸» º º ¹ ¹ ¹ ¹ ¹ ¹ º º º

Figure 4.6: Second route P5 of the 3 total possible routes for the second trans-portation task. I1 I2 I3 1 2 3 7 8 9 13 14 15 O1 O2 O3 4 5 6 10 11 12 16 17 18 ½ ½ ½ ½ ½ ½ S1 S2 S3 S4 S5 S6 S7 ¾ ¿¾ ½ À À À Á Á Á Á À À À Á Á Â Â À À Ã Á Á ¿Â Á Á À À À À À À Á Á Á

Figure 4.7: Third route P6 of the 3 total possible routes for the second trans-portation task.

The decision variables will be the paths that are listed above, that are either are used or not. We wish to minimize the summarized distances of the path, this is the objective function. The constraints are that a path for both routes should be found and they are not allowed to use the same edge twice.

Selected paths have a certain cost when it is included in the solution, these costs are of using one of the decision variables and are the length of the path. These lengths can be found by looking at the weighted graph. The routes of P1 to P6 can be found respectively in Figure 4.2 to 4.7.

• P1: 33 • P2: 47 • P3: 33 • P4: 30 • P5: 16 • P6: 49

(29)

Now the linear programming problem at by formulated as:

Minimize the total distance: D = 33 · P1 + 47 · P2 + 33 · P3 + 30 · P4 + 16 · P5 + 49 · P6

Subject to: p1 + p2 + p3 = 1

p4 + p5 + p6 = 1 p1 + p4 ≤ 1

p2 + p3 + p4 + p5 + p6 ≤ 1 p3 + p4 + p5 ≤ 1

Now for example the simplex algorithm [14] can be used to solve the problem. This is done with the following steps:

1. Initialization

(a) Define the objective function, the decision variables and the con-straints. The problem should be written in such a that corresponds with the problem. The decision variables will be changed in such a way to achieve maximum result for the objective function.

(b) Introduce slack variables. Slack variables are used to transform in-equalities constraints into in-equalities, so it can be solved.

(c) Construct the tabular form. The tabular form is used to find the optimal solution, during each iteration the table is updated in such a way that at the end it gives the desired result. If the objective function should be minimized, the problem is rewritten to a problem that needs to be maximized.

2. Optimization

(a) Optimality test. The current solution is optimal if every coefficient in the row that is represent that objective function is non-negative. (b) Select the a negative coefficient for the pivot column. In row of the

objective look for the a negative coefficient of the decision variables, this column will be the pivot column. Steps 2a to 2d a repeated until the conditions for optimality are found.

(c) Apply minimum ratio test.

i. Pick out each coefficient in the pivot column that is strictly pos-itive ( 0).

ii. Divide each of these coefficients into the right side entry (which is the resulting solution for the basic variables) for the same row. iii. Find the row that has the smallest of these ratios.

iv. This row will be the pivot row. (d) Transformation

i. Divide the pivot row by the the coefficient that is found at the intersection of the pivot row and the pivot column, also know as the pivot number. Use this new pivot row in the new two steps. ii. For each other row that has a negative coefficient in the pivot column, add to this row the product of the absolute value of this

(30)

iii. For each other row that has a positive coefficient in the pivot column, subtract from this row the product of the just found coefficient and the new pivot row.

The result that is returned by the simplex method is that p1 and p5 should be selected, and that the optimal solution has a length of 49. The tableaus that were used can be found in appendix A.

(31)

Chapter 5

Conclusion

As stated in the introduction, the desire was to find the optimal route planning for a dry bulk terminal. For shortest path problem it was noticed that the networks of belt conveyors in dry bulk terminals are not complex enough to present real challenges to these algorithms. Since computational speed is not an issue, it is preferred to select an algorithm that always converges to the global optimum, and not in some cases to the local optimum. From the discussed shortest path algorithms Dijkstra’s algorithm is best suited for the situation in a dry bulk terminal.

When multiple tasks have to be planned simultaneously optimal results are not found by running the shortest path algorithm in succession. The Ford-Fulkerson algorithm and minimum-cost flow problem do this and are unlikely to find the best solution for multiple routes. There is a lack of suitable literature that would be able to solve the problem in this configuration, most of them cannot be adapted or without the performance that is desired. With linear programming all routes have to be entered manually, but in the end the optimal solution is always found. It is without a doubt that this is also the preferred algorithm for a multiple shortest path problem.

(32)

Chapter 6

Recommendations

There are still some problems that have to be solved before the algorithms can be used. Some assumptions and simplifications were made that are not entirely correct and should be changed before the algorithm can offer the results which are desired.

6.1 Representation of terminal

Currently the dry bulk terminal is represented by a weighted graph which indi-cates which routes are possible. One of the problems by using a simple weighted graph are the transfer stations. In order to transfer the material from one belt conveyor to the next one a transfer station is used. Currently these transfer stations are represented in the weighted graph as a vertex, and the algorithm allows that multiple routes can use the same vertices, but not the same edges. In reality this is not feasible, the transfer station cannot be used by multiple paths simultaneously. A check that the vertices are not used twice should be implemented.

Also, transfer stations work by dropping the bulk goods on another set of belt conveyors. This process is not reversible, so in the weighted graph the edges have to be directed edges. The direction of the edges indicate that there is only flow of material possible in that direction.

6.2 Implementation of linear programming

During the solution for the linear programming problem a set of paths is selected to consider as potential solutions for the problem. The way how the set of paths are found can be done in multiple ways. It is important that potential solutions are not missed, but also that routes that would never lead to a solution are not considered. Removing the unfeasible routes from the set reduces the complexity of the problem, and therefore also the computational time. Routes can be found for example with Dijkstra’s algorithm, and removing the shortest path every time it comes with a solution. Suurballe’s algorithm can find the edge disjoint paths and there are some other alternatives that could provide the most promising paths. Most of these are relaxations of the shortest path problem. Further research should be done which one strategy yields the most useful paths.

(33)

The way how the constrains are currently implemented are be quite complex when a large number of routes are possible. Instead it would be preferred that the routes are defined by which edges and vertices it uses, so the algorithm can check if they not used twice, instead of defining which routes are possible simultaneously.

Linear programming can either come up with a optimal solution, or no so-lution when the problem is unsolvable. By adding some sinks (fictional routes) with a very high cost a solution still can be found, but they will be never selected unless the problem could not be solved.

6.3 Planning

The multiple shortest path problem considers each time instant in the time horizon and does an optimization for that time instant. However, this could be a suboptimal solution for the whole time horizon. If the whole time horizon would be considered, tasks with a longer duration could be routed in such way that other tasks are not prevented from being executed. The only discussed algorithm that would be able to provide an optimal solution for the whole time horizon would be linear programming. Instead of running the algorithm for each time instant, we can implement the algorithm in such a way that the whole time horizon is optimized. The constraints can be adapted that it not only prevents from two edges being used at the same time, but that it also checks that the edge cannot be used by the same task in the next time instant. Every task will have a set of routes and every time instant will have a set of constraints. The global solution considers the total cost (length multiplied by duration) while satisfying all constraints. Additionally, one can implement the possibility to change routes in the middle of a task to be able to executed another task simultaneously. This would be penalized with extra costs due to the fact that it will take time to change the route.

(34)

(35)

Appendix A

Results of simplex method

Tableaus found using online Simplex method tool devolped by Stefan Waner [15]. Tableau #1 p1 p2 p3 p4 p5 p6 s1 s2 s3 s4 s5 s6 s7 -p 1 1 1 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 1 1 1 0 1 0 0 0 0 0 0 1 1 0 0 1 0 0 0 0 1 0 0 0 0 0 1 0 1 1 1 1 1 0 0 0 1 0 0 0 0 1 0 0 1 1 1 0 0 0 0 0 1 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 -1 0 0 1 0 0 0 1 1 1 0 0 0 0 0 0 -1 0 1 33 47 33 30 16 49 0 0 0 0 0 0 0 1 0 Tableau #2 p1 p2 p3 p4 p5 p6 s1 s2 s3 s4 s5 s6 s7 -p 0 0 0 0 0 0 1 0 0 0 0 1 0 0 0 0 0 0 1 1 1 0 1 0 0 0 0 0 0 1 0 -1 -1 1 0 0 0 0 1 0 0 1 0 0 0 0 1 1 1 1 1 0 0 0 1 0 0 0 0 1 0 0 1 1 1 0 0 0 0 0 1 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 -1 0 0 1 0 0 0 1 1 1 0 0 0 0 0 0 -1 0 1 0 14 0 30 16 49 0 0 0 0 0 33 0 1 -33 Tableau #3 p1 p2 p3 p4 p5 p6 s1 s2 s3 s4 s5 s6 s7 -p 0 0 0 0 0 0 1 0 0 0 0 1 0 0 0 0 1 1 0 1 1 0 1 -1 0 0 -1 0 0 1 0 -1 -1 1 0 0 0 0 1 0 0 1 0 0 0 0 2 2 0 1 1 0 0 -1 1 0 -1 0 0 1 0 1 2 0 1 0 0 0 -1 0 1 -1 0 0 1 1 1 1 0 0 0 0 0 0 0 0 -1 0 0 1 0 1 1 0 1 1 0 0 -1 0 0 -1 -1 0 1 0 44 30 0 16 49 0 0 -30 0 0 3 0 1 -33 Tableau #4 p1 p2 p3 p4 p5 p6 s1 s2 s3 s4 s5 s6 s7 -p 0 0 0 0 0 0 1 0 0 0 0 1 0 0 0 0 0 0 0 1 1 0 2 -1 -1 0 -1 0 0 1 0 0 0 2 1 1 0 0 1 1 0 1 0 0 1 0 2 2 0 1 1 0 0 -1 1 0 -1 0 0 1 0 0 2 0 1 -1 0 0 -1 -1 2 -1 0 0 1 2 0 0 0 -1 -1 0 0 1 -1 0 -1 0 0 1 0 0 0 0 1 1 0 0 -1 -1 0 -1 -2 0 1 0 0 -14 0 -6 27 0 0 -8 -22 0 25 0 1 -55

(36)

Tableau #5 p1 p2 p3 p4 p5 p6 s1 s2 s3 s4 s5 s6 s7 -p 0 0 0 0 0 0 1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 1 1 0 1 1 0 0 0 1 1 0 0 0 0 0 0 1 0 0 1 0 0 0 0 1 0 0 -1 0 0 0 0 1 0 1 0 0 1 0 0 0 0 0 0 0 0 -1 0 -1 -1 0 1 0 0 0 0 1 1 0 0 -1 -1 0 -1 -2 0 1 0 0 -14 0 0 33 0 0 -14 -28 0 19 -12 1 -49 Tableau #6 p1 p2 p3 p4 p5 p6 s1 s2 s3 s4 s5 s6 s7 -p 0 0 0 0 0 0 1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 0 0 0 -1 -1 1 0 0 0 0 1 0 0 1 0 0 0 0 1 1 0 0 0 0 0 0 1 0 0 1 0 0 0 0 1 0 0 -1 0 0 0 0 1 0 1 0 0 1 1 1 0 0 0 0 0 0 0 0 -1 0 0 1 0 1 1 0 1 1 0 0 -1 0 0 -1 -1 0 1 0 28 14 0 0 33 0 0 -14 0 0 19 16 1 -49 Tableau #7 p1 p2 p3 p4 p5 p6 s1 s2 s3 s4 s5 s6 s7 -p 0 0 0 0 0 0 1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 0 0 0 -1 -1 1 0 0 0 0 1 0 0 1 0 0 0 0 1 1 0 0 0 0 0 0 1 0 0 1 0 0 0 0 1 0 0 -1 0 0 0 0 1 0 1 0 0 1 1 1 0 0 0 0 0 0 0 0 -1 0 0 1 0 0 0 1 1 1 0 0 0 0 0 0 -1 0 1 0 14 0 14 0 33 0 0 0 0 0 33 16 1 -49

(37)

Bibliography

[1] B. V. Cherkassky, L. Georgiadis, A. V. Goldberg, R. E. Tarjan, and R. F. F. Werneck, “Shortest Path Feasibility Algorithms: An Experimental Evalu-ation,” ACM Journal of Experimental Algorithms, vol. 14, pp. 118–132, 2008.

[2] G. Gallo and S. Pallottino, “Shortest path algorithms,” Annals of Opera-tions Research, vol. 13, pp. 1–79, 1988.

[3] M. Nonato, S. Pallottino, and B. Xuewen, “SP TLshortest path algorithms:

review, new proposals and some experimental results,” 1999.

[4] B. V. Cherkassky, A. V. Goldberg, and T. Radzikt, “Shortest paths algo-rithms: theory and experimental evaluation,” in ACM-SIAM Symposium on Discrete Algorithms, pp. 516–525, 1994.

[5] D. Delling, P. Sanders, D. Schultes, and D. Wagner, Engineering Route Planning Algorithms. 2009.

[6] E. W. Dijkstra, “A note on two problems in connexion with graphs,” Nu-merische Mathematik, vol. 1, pp. 269–271, 1959.

[7] P. E. Hart, N. J. Nilsson, and B. Raphael, “A formal basis for heuristic determination of minimum path cost,” in Sequences, Subsequences, and Consequences, 1968.

[8] R. Bellman, “On a routing problem,” Quart. Appl. Math., vol. 16, pp. 87– 90, 1958.

[9] Y. Saanen and R. Dekker, “Intelligent stacking as way out of congested yards? part 2,” Port Technology International, vol. 31, pp. 87–92, 2007. [10] L. R. Ford and D. R. Fulkerson, Maximal Flow Through a Network. [11] G. Ruhe, Algorithmic Aspects of Flows in Networks. 1991.

[12] L. V. Kantorovich, “Mathematical methods of organizing and planning production,” Management Science, vol. 6, no. 4, pp. pp. 366–422, 1960. [13] J. W. Suurballe, “Disjoint paths in a network,” Networks, vol. 4, pp. 125–

145, 1974.

[14] G. B. Dantzig, “Linear Programming,” Operations Research, vol. 50, pp. 42–47, 2002.

Route selection methods for dry bulk terminals

Delft University of Technology

Literature Research