Airlines industry is labor intensive, thus more one-third of the daily revenue ...... Cairo. 6:55. 8:05. 3. Cairo. Luxor. 5:45. 6:55. 4. Luxor. Sharm El-sheikh. 7:25.
Alexandria University Faculty of Engineering Production Engineering Department
AIRLINE CREW SCHEDULING
Thesis Submitted to the Production Engineering Department Faculty of Engineering – Alexandria University In Partial fulfillment of the Requirements for the Degree of
Master of Science In
Production Engineering By
Ahmed Essam Mohammed Said El-Habashy B. Sc. in Production Engineering Faculty of Engineering Alexandria University 2009
2012
Alexandria University Faculty of Engineering Production Engineering Department
AIRLINE CREW SCHEDULING Presented by Ahmed Essam Mohammed Said El-Habashy For the Degree of Master of Science In Production Engineering
Examiners’ Committee:
Approved
Prof. Dr. Mohammed Hamdy Elwany Professor of Industrial Engineering – Faculty of Engineering, Alexandria University
Prof. Dr. Ibrahim Abdelsalam Awad Professor of Computer and Systems Engineering – Faculty of Engineering, Alexandria University
Prof. Dr. Azziz Ezzat Elsayed Professor of Industrial Engineering – Faculty of Engineering, Arab Academy for Science, Technology, and Maritime Transport
Prof. Dr. M. Nashat Fors Professor of Industrial Engineering – Faculty of Engineering, Alexandria University
Prof. Dr. Heba Wael Leheta Vice-Dean of Graduate Studies and Research Professor - Production Engineering Department Alexandria University
Advisors’ Committee of Ahmed Essam Mohamed Said Elhabashy thesis titled: “Airline Crew Scheduling” Prof. Dr. Mohammed Hamdy Elwany Professor of Industrial Engineering – Production Engineering Department – Faculty of Engineering, Alexandria University
Prof. Dr. M. Nashat Fors Professor of Industrial Engineering – Production Engineering Department – Faculty of Engineering, Alexandria University
Dr. Yasmine Abouelseoud Saleh Engineering Mathematics and Physics Department - Faculty of Engineering, Alexandria University
ACKNOWLEDEMENTS
First of all, I would like to thank God for enabling me to do this work and giving me enough strength to finish it. Secondly, I would like to express thanks to my family for their love and support along the way, in particular, to my sister for her help in the last stretch. Then I would like to express my sincere gratitude to my advisors, without whom this dissertation would not have been completed. I want to thank Prof. Dr. Hamdy Elwany Professor of Industrial Engineering in Alexandria University for his moral support and encouragement; Prof. Dr. Nashat Fors Professor of Industrial Engineering in Alexandria University for his technical advice and comments, especially in the last stages of this thesis; and Dr. Yasmine Abouelseoud, Assistant Professor, Engineering Mathematics and Physics Department in Alexandria University for her efforts, guidance, and assistance throughout all of the steps of this thesis, she was always there when needed and constantly provided me with valuable ideas. Finally, I would like to thank almost all of my colleagues in the Production Engineering Department in Alexandra University; every one of them had helped me in a certain way. However, I cannot help but to single out the efforts of one of them, Mr. Mohammed Shafae, and offer him special thanks for his unlimited academic support.
I
ABSTRACT Airlines industry is labor intensive, thus more one-third of the daily revenue goes to paying the wages, benefits and payroll taxes for its workforce. Moreover, the crew members are not salaried, but are rather paid for the time they spend flying plus other compensations for the time they spend away from home. Consequently, finding an optimal scheduling policy is an impelling need. This work addresses the foremost step in airline crew scheduling problem. More specifically, the cockpit crew pairing problem is studied with both of its sequential phases; which seeks to select the adequate set of pairings covering all available flights while achieving the minimum possible associated cost under various safety regulations and labor organizations agreements. A pairing simply refers to a sequence of flights that commence and end at the same crew base. A two-phase methodology is developed. The first phase uses a breadth-first search method to generate valid pairings, and then the second phase uses genetic algorithm to choose the optimum set of pairings. The implemented solution techniques of both phases were validated, using a number of different test problems including electronically available bench-mark instances and satisfactory results are reported. The methodology have been also applied to a case study in a local airline company in Egypt, where the results obtained are superior to the method currently in use by the company; cost savings ranging from 7.64% to 26.81% are obtained when applying the methodology on a daily basis for a whole week, with savings of 15.57% for the week as a whole.
ii
CONTENTS ACKNOWLEDEMENTS ........................................................................................................... I ABSTRACT ............................................................................................................................... ii CONTENTS .............................................................................................................................. iii LIST OF SYMBOLS ................................................................................................................ vi LIST OF ABBREVIATIONS .................................................................................................. vii LIST OF FIGURES ................................................................................................................. viii LIST OF TABLES ..................................................................................................................... x CHAPTER 1 INTRODUCTION ............................................................................................... 1 1.1 Overview .......................................................................................................................... 2 1.2 Motivations....................................................................................................................... 3 1.3 Main Objective ................................................................................................................. 4 1.4 Chapters Outline............................................................................................................... 5 CHAPTER 2 REVIEW OF RELATED LITERATURE........................................................... 6 2.1 Basic Key Terms .............................................................................................................. 7 2.2 The Crew Scheduling Problem ........................................................................................ 8 2.2.1 The Crew Pairing Problem ....................................................................................... 10 2.2.2 The Crew Rostering Problem ................................................................................... 11 2.3 Mathematical Representation......................................................................................... 12 2.3.1 The Crew Pairing Problem (Optimization Phase Only) .......................................... 12 2.3.2 Work Rules and Pay Structure ................................................................................. 14 2.3.3 The Nature of the Problem ....................................................................................... 15 2.4 Solution Approaches ...................................................................................................... 15 2.4.1 Mathematical Programming Techniques ................................................................. 16 2.4.2 Network-Based Models ............................................................................................ 19 2.4.3 Meta-Heuristics ........................................................................................................ 20 2.4.4 Other Solution Approaches ...................................................................................... 23 2.5 Adopted Solution Approaches ....................................................................................... 25 2.5.1 Depth-first approach for the Pairing Generation Phase ........................................... 25 2.5.2 GA for the Pairing Optimization Phase ................................................................... 28 2.6 Closing Remarks ............................................................................................................ 33 CHAPTER 3 METHODOLOGY ............................................................................................ 35
iii
3.1 Introduction .................................................................................................................... 36 3.2 The Pairing Generation Phase ........................................................................................ 36 3.2.1 Initialization.............................................................................................................. 36 3.2.2 Single-Legged Duties Generation ............................................................................ 37 3.2.3 Additional Duties Generation .................................................................................. 38 3.2.4 Overnight Duties Generation ................................................................................... 41 3.2.5 “Connected Duties” Generation ............................................................................... 41 3.2.6 Pairing Generation.................................................................................................... 42 3.3 The Optimization Phase ................................................................................................. 44 3.3.1 Algorithm Overview ................................................................................................ 44 3.3.2 Initialization.............................................................................................................. 46 3.3.3 Initial Population Generation ................................................................................... 46 3.3.4 Feasibility Operator Implementation ....................................................................... 48 3.3.5 Fitness Function Evaluation ..................................................................................... 51 3.3.6 Genetic Operators ..................................................................................................... 52 3.3.7 Optimum Solution Determination............................................................................ 53 3.3.8 Population Replacement........................................................................................... 54 3.3.9 Remarks on the Proposed GA .................................................................................. 54 CHAPTER
4
TESTING
AND
IMPLEMENTATION
OF
THE
PROPOSED
METHODOLOGY ................................................................................................................... 56 4.1 Introduction .................................................................................................................... 57 4.2 Test Problems ................................................................................................................. 57 4.2.1 The Pairing Generation Phase .................................................................................. 57 4.2.2 The Optimization Phase ........................................................................................... 62 4.3 Real-life Case Study....................................................................................................... 64 CHAPTER 5 CONCLUSION AND RECOMMENDATIONs............................................... 71 5.1 Conclusions .................................................................................................................... 72 5.2 Recommendations for Future Work .............................................................................. 74 REFERENCES ......................................................................................................................... 76 APPENDIX A C CODE ........................................................................................................... 80 A.1 Pairing Generation Algorithm Code ............................................................................. 80 A.2 Genetic Algoritm Code ................................................................................................. 91 APPENDIX B CASE-STUDY RELATED DATA ............................................................... 107 B.1 All Input Flights for Second Week In March 2011 .................................................... 107 iv
B.2 Generated Pairings for Sunday .................................................................................... 112 B.3 Generated Pairings for Monday .................................................................................. 113 B.4 Generated Pairings for Tuesday .................................................................................. 114 B.5 Generated Pairings for Wednesday ............................................................................. 115 B.6 Generated Pairings for Thursday................................................................................. 116 B.7 Generated Pairings for Friday ..................................................................................... 117 B.8 Generated Pairings for The Week as a Whole ............................................................ 118
v
LIST OF SYMBOLS F: Set of flights P: Set of pairings K: Set of crew home-base cities j: Pairing index (𝑗 ∈ 𝑃) i: Flight index (𝑖 ∈ 𝐹) k: Crew home-base index (𝑘 ∈ 𝐾) cj: Cost of crew pairing j aij: Binary parameter indicating whether flight i is covered by pairing j. hkj: Binary parameter indicating if city k is the crew base for pairing j. 𝒃𝒍𝒐𝒘𝒆𝒓𝒌 : Minimum number of crew to be used at home base city k 𝒃𝒖𝒑𝒑𝒆𝒓𝒌 : Maximum number of crew to be used at home base city k bd: Duty period cost, expressed in hours. mg1: A guaranteed minimum number of hours used in duty cost calculation. mg2: A guaranteed minimum number of hours used in pairing cost calculation. f1: A constant used in duty cost calculation. f2: A constant used in pairing cost calculation. A: An m x n matrix of zeroes and ones c: A vector of n (arbitrary) rational components
vi
LIST OF ABBREVIATIONS ACO
Ant Colony Optimization
ATA
Air Transport Association of America
BIP
Binary Integer Programming
ECAR
Egyptian Civil Aviation Regulations
FAA
Federal Aviation Administration
GA
Genetic Algorithm
IP
Integer Programming
LP
Linear Programming
NDP
Number of Duties in the Pairing
SCP
Set Covering Problem
SPP
Set Partitioning Problem
TAFB
Time Away From Base
vii
LIST OF FIGURES Figure 1.1: Airlines Schedule Planning ...................................................................................... 2 Figure 1.2: Operating Expenses in the Airline Industry [3] ....................................................... 4 Figure 2.1: An Example of a Crew Roster and its Components [5] ........................................... 8 Figure 2.2: Outline of the Crew Scheduling Problem ................................................................ 9 Figure 2.3: A Typical Pairing with Duty Periods, Sits Within Duty Periods, Overnight Rests, and Sign-In and Sign-Out Times [4] ......................................................................................... 10 Figure 2.4: Components of the Crew Scheduling Problem ...................................................... 12 Figure 2.5: The Flowchart of the “validDuty (currentDuty)” Function ................................... 26 Figure 2.6: The “searchForDuties” Function [24] .................................................................... 27 Figure 2.7: Column-based Chromosome Representation ......................................................... 28 Figure 2.8: Row-based Chromosome Representation .............................................................. 29 Figure 3.1: Overview of Modified Pairing Generation Algorithm........................................... 36 Figure 3.2: “DurationCalculation” Function............................................................................. 38 Figure 3.3: “ValidDuty(i)” Function ......................................................................................... 39 Figure 3.4: “SearchForDuties” Function .................................................................................. 40 Figure 3.5: “SearchForConnectedDuties” Function ................................................................. 43 Figure 3.6: “Valid Pairing” Function ........................................................................................ 44 Figure 3.7: GA Overview .......................................................................................................... 45 Figure 3.8: “FlightBasedInitialization” Function ..................................................................... 47 Figure 3.9: “FeasibilityOperator” Function Outline ................................................................. 49 Figure 3.10: The ADD Procedure ............................................................................................. 50 Figure 3.11: The DROP Procedure ........................................................................................... 51 Figure 3.12: Example of Implementation of Single-Point Crossover Operation at the Third Gene [18] ................................................................................................................................... 52 Figure 4.1: Different Solution Values for Saturday.................................................................. 68
viii
Figure 4.2: Comparison of Objective Function Value Obtained by the Proposed GA and Company for Everyday Crew Pairing Problems ....................................................................... 69 Figure 4.3: Different Case-Study Solutions for the Whole Week Pairing Problem. ............... 70 Figure 5.1: Range of Deviation from Optimal Values for Instances not Yielding Optimal Results. ...................................................................................................................................... 72 Figure 5.2: Comparison of the Everyday Crew Pairing Problems Case-Study Results to the Optimal Values .......................................................................................................................... 73 Figure 5.3: Difference from Optimal Objective Function Value for the Week as a Whole .... 74
ix
LIST OF TABLES Table 2.1: Summary of Reviewed Papers ................................................................................. 25 Table 4.1: Input Flight Schedule of Test Problem 1 [23] ......................................................... 57 Table 4.2: Pairings Resulting from Modified Algorithm for Test Problem 1 .......................... 58 Table 4.3: Input Flight Schedule of Test Problem 2 [12] ......................................................... 59 Table 4.4: Pairings Resulting from Modified Algorithm for Test Problem 2 .......................... 60 Table 4.5: Input Flight Schedule of Test Problem 3 [2] ........................................................... 61 Table 4.6: Pairings Resulting from Modified Algorithm for Test Problem 3 .......................... 62 Table 4.7: Results of the proposed GA on the Test Instances. ................................................. 63 Table 4.8: Range of deviation from optimal values for instances not yielding optimal. ......... 63 Table 4.9: Flights Schedule on Saturday .................................................................................. 65 Table 4.10: Generated Pairings for Saturday ............................................................................ 66 Table 4.11: Proposed GA crew pairing solution for Saturday. ................................................ 67 Table 4.12: Company’s crew pairing solution for Saturday. .................................................... 67 Table 4.13: Summary of Everyday Pairing Optimization Results ........................................... 69
x
CHAPTER 1 INTRODUCTION
CHAPTER 1 INTRODUCTION 1.1 OVERVIEW The term “crew scheduling” is a common term in a number of transportation industries, and according to Barnhart et al. [1] crew scheduling could be defined as the problem of assigning a group of workers (a crew) to a set of tasks. Usually crews are identical, although cases could occur where crews might have special characteristics, or acquire certain skills, influencing their assignment process. Regardless if these crews are for bus transport, railways freight transportation, airlines or any other transportation context, all those crew scheduling problems share the need to cover all tasks while seeking to minimize labor costs, taking into account safety regulations constraints and different labor considerations. As shown in Figure 1.1, crew scheduling is just one of a number of challenging planning problems faced by airlines; although these problems are closely interrelated, they are typically solved sequentially, due to their size and complexity [2].
Schedule Generation
Fleet Assignment Maintenance Routing Crew Scheduling Figure 1.1: Airlines Schedule Planning Airlines scheduling planning always begin by solving a schedule design problem, in which they determine the flights to be flown during a given time period. In the next step, the fleet assignment problem, they decide which type of aircraft (such as Boeing 767, 727, etc.) to assign to each flight, as a function of the forecasted demand for that flight. The maintenance routing problem follows, in which individual aircraft are assigned to flights so as to ensure that each aircraft spends adequate time at specific airports in order to undergo routine
2
maintenance checks. Having completed these three tasks, the airlines then address the problem of scheduling crews [2]. This work focuses on the crew scheduling problem for airline companies. Hereafter, the term “crew scheduling” will be used interchangeably with the term “airline crew scheduling”.
1.2 MOTIVATIONS As stated by Gopalakrishnan and Johnson [2], the crew scheduling problem continues to be challenging to solve due to the following reasons: 1. The number of pairings is extremely large for many airlines. It is not uncommon to generate 100 million legal pairings for moderate size fleets 2. Many complex work rules and safety regulations have to be satisfied. 3. Airline crews receive substantially higher salaries than equivalent personnel in other modes of transportation and the savings with an improved airline crew schedule could be quite significant. The last reason greatly helps in justifying the focus on the problem of crew scheduling in particular within airline schedule planning. Nonetheless, further exploration is required to understand why they receive such high salaries. Taking a detailed look at airlines expenses as a whole, it is found that, according to the Air Transport Association of America (ATA) [3], airline expenses, in general, could be grouped, as shown in Figure 1.2, into the following major categories:
Flying operations: essentially any cost associated with the operation of aircraft, such as fuel and pilot salaries (37%);
Maintenance: both parts and labor (10%);
Aircraft and Traffic Service: basically the cost of handling passengers, cargo and aircraft on the ground and including such things as the salaries of baggage handlers, dispatchers and airline gate representatives (14%);
Promotion/Sales: including advertising, reservations and travel agent commissions (6%);
Passenger Service: in-flight service, including such things as food and flight attendant salaries (6%);
Transport Related: outsourced regional capacity providers, in-flight sales (17%);
Others (10%)
3
Others 10%
Flying Operations 37%
Transport Related 17% Passenger Service 6% Promotion/Sales 6%
Aircraft & Traffic Service 14%
Maintenance 10%
Figure 1.2: Operating Expenses in the Airline Industry [3] In fact, the ATA [3] stated that more than one-third of the revenue generated each day by the airlines goes to pay the wages, benefits and payroll taxes of its workforce, and labor costs per employee are above average compared to other service industries. Moreover, since crew are not salaried, but are rather paid for the time that they spend flying, plus some added compensation for excess time spent on the ground between flights and during rest periods [1]; total crew cost, including salaries, benefits, and expenses, is the second largest cost figure, after the cost of fuel, for airlines. Unlike the fuel cost, a large portion of flight-crew expenses are controllable, and even a small percentage of savings in flight crew expenses through better scheduling translates into millions of dollars, which ultimately could determine the survival or demise of an airline [4].
1.3 MAIN OBJECTIVE The main objective of this work is to develop methodologies addressing the first part in airline crew scheduling, that is the airline crew scheduling problem for cockpit crew with its two phases; these methodologies could successfully turn scheduled flights within a certain time horizon into valid pairings and then selects the pairings having least possible cost while covering all available flights. This would be accomplished through:
Conducting a comprehensive study of the airline crew scheduling problem with it all of its different components.
4
Providing an accurate mathematical representation of the problem.
Reviewing the current solution methodologies, to find their various strengths and weaknesses.
Determining the solution methodology to be used.
Comparing the results of using the proposed solution methodology with other results obtained from benchmark instances.
Applying the proposed methodology to a real-life case study demonstrating the potential cost savings.
1.4 CHAPTERS OUTLINE The remainder of the thesis is organized as follows: Chapter 2 provides a review of related literature on the crew scheduling problem. It starts with presenting brief definitions of airlinerelated terminologies. Then a detailed description of the crew scheduling problem itself with its different constituents follows, accompanied by the corresponding mathematical formulation. Finally, different solution approaches that had been utilized to deal with the airline crew pairing problem are explained. Chapter 3 describes the proposed methodologies in the present study for the airline crew pairing problem; which deals with both phases of the problem. The chapter presents the detailed description of the procedures used within these methodologies, along with its necessary assumptions, definitions, and other relevant information. Chapter 4 presents the testing and implementation of the developed solution methodology. This is done by using a number of test problems (most are benchmark instances) and comparing their results with the ones obtained in the study. Finally, a real-life case study is carried out in a local airline company. The thesis is concluded in chapter 5 which presents the assessment for the solution methodology and recommendations for future work. A list of the various references used in the thesis follows, along with related appendices.
5
CHAPTER 2 REVIEW OF RELATED LITERATURE
CHAPTER 2 REVIEW OF RELATED LITERATURE 2.1 BASIC KEY TERMS The following terms are used when addressing crew scheduling problems as defined in [1], [2], [4], [5], and [6]; and their comprehension is a necessity. Flight leg: A flight leg is a trip of an aircraft, from take-off to landing. It consists of an origin station, a destination station, a departure time, and an arrival time. Flight: It is a number of several flight legs combined together. Duty periods: A sequence of flights that can be flown by a single crew member over the course of a work day with sit connection in between them; i.e., flights that are grouped together. Sit connection: A connection period during a duty is called a sit connection. This involves the waiting times, on the part of the crew, for changing planes onto their next leg of duty. Normally, airlines impose minimum and maximum sit connection times; typically Maximum and minimum values are called MaxSit & MinSit and are between 10 minutes and 3 hours. Elapse time: The number of minutes that elapse between the beginning of a duty and the end of the duty. The elapsed time includes a briefing period before the first leg of the duty, and a debriefing period after the last leg of the duty. It must be less than a maximum allowable value called MaxElapse. Pairings: They refer to duties that are strung together. They are crew trips spanning one or more work days separated by periods of rest. Rest: A connection between two duties is referred to as rest, overnight connection or layover; usually these rests are within permissible limits. MaxDuties: Maximum number of duty periods composing a legal pairing. MinRest: A minimum number of hours of rest between duties that must be allowed in a pairing. Crew bases: A crew base is the home station or city in which the crew actually lives. Pairings should start and end at the same crew bases. Time Away From Base (TAFB): it is the number of minutes that elapse between the beginning of the pairing and the end of the pairing. 7
Fly: The total number of hours of actual flying time. Maximum value called MaxFly. Roster: A roster is a list or plan showing turns of duty or leave for individuals or groups in an organization. In airline context, it represents a potential crew schedule for a dedicated crew member during the planning periods of usually two or four weeks. It contains assigned flight duties in addition to pre-scheduled activities and days off. Crew schedule: An optimal set of individual rosters flown by crew members. Deadheading crews: Flying crews as passengers on some of the airlines flights within their schedule in order to reposition them for future assignments. Figure 2.1 illustrates the difference between flights, duties, pairings, and rosters for a given crew member. The figure shows a roster spanning six days including three pairings, a prescheduled activity (simulator activity), and a day-off. Pairing 2 is composed of two flights duties spanning two days requiring a hotel stay (H) between them as well as a transit (T) back to crew base. Duty 1 is itself composed of three flights combined with rest, while flight 3 is in turn composed of two flight legs.
Figure 2.1: An Example of a Crew Roster and its Components [5]
2.2 THE CREW SCHEDULING PROBLEM The aim of the crew scheduling problem is to identify optimum schedules of airline crews by taking the set of flights that is needed to be covered as input and yielding corresponding duties, pairings, and eventually monthly schedules as output; while taking into consideration the associated cost structure involved and various imposed constraints. According to [2], those constraints typically come from three sources: 8
1. Governing agencies regulating and overseeing aspects of civil aviation such as the Federal Aviation Administration (FAA) in the U.S. which restricts crew scheduling, primarily for safety purposes. 2. Labor organizations often enter into collective bargaining agreements concerning the crews’ work conditions. 3. The airlines themselves pose added constraints. It should be noted that there are two types of airline crews with different scheduling approaches. First, there is the cockpit crew such as the captain and first officers, whom tend to remain together for much of their schedule. More specifically, cockpit crews are not qualified to fly all fleet types, as this depends on the flying license they have acquired. On the other hand, there is the cabin crew such as flight attendants, whom tend to vary more frequently and are not scheduled together but rather as individuals. Unlike cockpit crew, cabin crew members have no restrictions on fleet types in which they could staff making the size of their associated scheduling problem larger [6]. In the present study, the focus of attention will be on the cockpit crew only. The crew scheduling problem is typically solved in two sequential phases, crew pairing and crew rostering. This is mainly because the two problems are too large to address simultaneously [4]. As shown in Figure 2.2, the crew pairing problem is solved first with the scheduled flights as input, yielding optimum pairings. Then, those pairings act as input to the crew rostering problem that in turn yields different crew rosters that build up the different crew schedules.
Scheduled Flights
Crew Pairing Optimum Pairings
Optimum Schedules
Crew Rostering
Figure 2.2: Outline of the Crew Scheduling Problem
9
2.2.1 The Crew Pairing Problem A crew pairing is a sequence of flight legs, or more precisely a sequence of flight duties spanning one or more work days separated by periods of rest. A pairing must also start and end at the same crew base [2][4]. Figure 2.3 illustrates an example of a two-day crew pairing, showing duty periods, sits within duty periods, overnight rests, and sign-in and sign-out times,
assuming
the
crew
home-base
is
at
JFK
(airport
name:
John
F. Kennedy International Airport). As the figure presents the suggestion, the crew is staying
overnight, away from their home base, and in this case, as will be shown in details in the cost structure section, the airline has to pay for their per diems, transportation, accommodation, food, and so on.
JFK:
John F. Kennedy International Airport
MIA:
Miami International Airport
ATL:
Hartsfield-Jackson Atlanta International Airport
BOS:
Logan International Airport
Figure 2.3: A Typical Pairing with Duty Periods, Sits Within Duty Periods, Overnight Rests, and Sign-In and Sign-Out Times [4] The objective of crew pairing is to find a set of pairings such that each flight is included in exactly one pairing and the total crew cost is minimized [2][4]. In order to accomplish that, feasible (or legal) pairings have to be generated first, then, the resulting pairings are optimized to solve the problem. These two stages are of equivalent importance and, obviously, none of them could be skipped.
10
In the pairing generation stage, pairings are generated according to certain pairing rules and regulations, such as starting and ending at the same crew base and considering the values of Maxduties, MinRest, MaxFly, etc. Since all possible feasible pairings are generated in this stage, the number of generated pairings is usually huge [2], especially for large airlines. Hence, pairing generators could be coupled with extra rules and filters to choose potentially good pairings. As for the optimization stage, a number of pairings are selected from the set of all available pairings such that the selected pairings covers all available flights while achieving the minimum possible associated cost; this cost is essentially the cost of selecting a pairing, further details are presented in coming sections. It should be also noted that in the crew pairing phase, no individual crew member’s schedule have been yet made, only general optimum pairing which will then be combined together along with other things to form rosters that will be assigned to specific individuals in the next phase. 2.2.2 The Crew Rostering Problem Once the crew pairing problem is solved, the second phase is crew rostering (also known as the crew assigning problem), in which individual crew members are assigned to a duty roster. The resulting optimum pairing are directly used (no need for a generation stage) to find optimum schedules. In this problem, the chosen pairings are combined with rest periods, vacations, training time, and other breaks to create extended individual work schedules, typically spanning a period of about one month [1], [2],[4] and [5]. The crew rostering problem could be viewed as a crew pairing problem but instead of selecting optimum pairings (series of sequential flights satisfying a range of rules) covering every flight, it selects optimum schedules (series of sequential pairings satisfying a range of rules) covering every pairing. Although the crew pairing and rostering problems are similar, they are usually dealt with separately. According to [1], there are two primary reasons for this:
First, in the crew pairing problem complete crews are assigned to flights, while in the crew assignment problem crew members are scheduled individually, with each pairing being covered by multiple crew members.
11
Second, the crew pairing problem focuses on minimizing labor costs, while in the crew assignment problem greater emphasis is placed on satisfying crew requests and seeking a balanced distribution of work.
Figure 2.4 sums up the main constituents of the crew scheduling problem, the crew pairing problem with both of its phases and the crew rostering problem. It should be noted that although both problems are quite similar, the focus of the present study will be on the crew pairing problem with its two phases only. This is simply because it is the first problem to be addressed when scheduling an airline crew, and to explore the area of pairing generation as well in addition to the optimization stage.
Crew Scheduling
Crew Pairing
Pairing Generation
Crew Rostering
Optimization
Figure 2.4: Components of the Crew Scheduling Problem
2.3 MATHEMATICAL REPRESENTATION 2.3.1 The Crew Pairing Problem (Optimization Phase Only) Having valid crew pairings on hand, according to [2], [4] and [5], the crew pairing problem could be represented by the following mathematical formulation. a) Sets F = Set of flights P = Set of pairings K = Set of crew home-base cities b) Indices j = Pairing index i = Flight index
12
k = Crew home-base index c) Parameters 𝑐𝑗 = cost of crew pairing 𝑗 1 if flight 𝑖 is covered by pairing 𝑗 𝑎𝑖𝑗 = { 0 Otherwise ℎ𝑘𝑗 = {
1 if home base city (starting and ending flight)for pairing 𝑗 is city 𝑘 0 Otherwise
𝑏𝑙𝑜𝑤𝑒𝑟𝑘 = minimum number of crew to be used at home base city 𝑘 𝑏𝑢𝑝𝑝𝑒𝑟𝑘 = maximum number of crew to be used at home base city 𝑘 d) Decision Variables For the generated pairings P, the following binary decision variables are defined: 𝑥𝑗 = {
1 if pairing 𝑗 is selected, j = 1,2,3, … , P 0 Otherwise
e) Objective Function Objective function is based on the sum of all duty cost in the pairing, cost of time away from the base, and minimum guaranteed pay multiplied by the number of duties. The maximum of these three costs determines the cost function for each pairing. Minimize ∑ 𝑐𝑗 𝑥𝑗
(2-1)
𝑗 ∈𝑃
f) Constraints Each pairing candidate covers a certain number of flights (F). It must be ensured that the crew covers each flight exactly once, (i.e. for each flight, the sum of decision variables associated with it must be equal to unity). ∑ 𝑎𝑖𝑗 𝑥𝑗 = 1
∀ 𝑓𝑙𝑖𝑔ℎ𝑡 𝑙𝑒𝑔𝑠 𝑖 ∈ 𝐹
(2-2)
𝑗 ∈𝑃
Many airlines also add crew-base balancing constraints to the basic crew pairing model. These constraints ensure that the distribution of work over the set of crew-bases is matched to the crew resources. They require that the number of hours of work contained in the chosen pairings which originate at a given crew base must be between specified lower and upper bounds, which are a function of the number of crews stationed at that crew base.
13
Constraints of this form are known as two-sided knapsack constraints [2], [4] and [7]; however, this constraint will not be taken into consideration when dealing with the crew pairing problem in the present study. 𝑏𝑙𝑜𝑤𝑒𝑟𝑘 ≤ ∑ ℎ𝑘𝑗 𝑥𝑗 ≤ 𝑏𝑢𝑝𝑝𝑒𝑟𝑘
∀ ℎ𝑜𝑚𝑒 𝑏𝑎𝑠𝑒𝑠 𝑘 ∈ 𝐾,
(2-3)
𝑗 ∈𝑃
2.3.2 Work Rules and Pay Structure In the airline crew pairing problem, the most principal decision is to decide which crew to assign to a given flight. The cost of crew assignment to a given flight is a complex computation. Crews are not salaried, but rather are paid for the time that they spend flying, plus some added compensation for excess time spent on the ground between flights and during rest periods. Given this, the ‘cost’ associated with an individual flight could be simply thought of as the duration of that flight. Because individual crews for a given fleet family could not be distinguished in the crew pairing problem, crew costs are usually expressed in terms of time rather than cost. The total flying time in the system is clearly fixed and provides a lower bound on the optimal crew cost. The objective in crew scheduling is therefore to minimize pay-and-credit, the payments made above and beyond the cost of the actual flying time [1] & [2]. According to the work in [6] and [8], the cost of a duty period, bd, expressed in hours is the maximum of three quantities: a guaranteed minimum number of hours, mg1; a fraction, f1, times the elapsed time of the duty; and the actual flying time in the duty period. The cost could be expressed as: 𝑏𝑑 = 𝑚𝑎𝑥 {𝑚𝑔1 , 𝑓1 × 𝑒𝑙𝑎𝑝𝑠𝑒, 𝑓𝑙𝑦}
(2-4)
Authors of [6] and [8] suggest typical values of the parameters that define legal duty periods and their costs for a domestic carrier are maxsit = 4 hours, minsit = 0.5 hours, maxelapse = 12 hours, maxfly = 8 hours, mg1 = 3 hours, and f1 = 4/7. cp is the cost of a pairing p in hours, it is the maximum of three quantities: a minimum guarantee, mg2, times the number of duties in the pairing (NDP); a fraction, f2, times the total elapsed time of the pairing, i.e., the time away from base (TAFB); and the sum of the costs of the individual duties that make up the pairing. This cost could be expressed as:
14
𝑐𝑝 = 𝑚𝑎𝑥 {𝑁𝐷𝑃 × 𝑚𝑔2 , 𝑓2 × 𝑇𝐴𝐹𝐵, ∑ 𝑏𝑑 }
(2-5)
𝑑∈𝑗
Typical values here (also suggested by authors of [6] and [8]) are maxduties = 3, mg2 = 4.75, and f2 = 2/7. Because of the cost structure for duties and pairings, a lower bound on the cost of a given schedule is the total number of hours of flying in the schedule. Penalties are incurred by pairings that have high TAFB relative to the number of hours flown and pairings that have few hours of flying per duty. 2.3.3 The Nature of the Problem The crew pairing and crew rostering problems are 0-1 integer programs. The crew pairing problem without the crew-base balancing constraints and the crew rostering problem could be seen as a Set Partitioning Problem (SPP) or a Set Covering Problem (SCP). The main distinction between them is that the latter is with inequality constraints and the former is with equality constraints [9]. The mathematical formulations of the SPP and SCP are shown in Equations (2-6) and (2-7) respectively. Minimize 𝑐𝑥 subject to 𝐴𝑥 = 1, 𝑎𝑛𝑑 𝑥𝑗 = 0 𝑜𝑟 1 𝑓𝑜𝑟 𝑗 = 1, … , 𝑛
(2-6)
Minimize 𝑐𝑥 subject to 𝐴𝑥 ≥ 1, 𝑎𝑛𝑑 𝑥𝑗 = 0 𝑜𝑟 1 𝑓𝑜𝑟 𝑗 = 1, … , 𝑛
(2-7)
where A is an m x n matrix of zeroes and ones, c is a vector of n (arbitrary) rational components [10] [11] . When the inequalities of the set covering problem are replaced by equations the problem is called the set partitioning problem, and when all of the > constraints are replaced by < constraints, the problem is called the set packing problem. It is well known that all of these problems are considered to be NP-Hard [10] and hence there is no deterministic polynomial time algorithm known to solve them so far when the problem is large in size. It should also be noted that the crew pairing problem is usually dealt with as SPP; but they could also be modeled as SCP if it is desired to relax associated constraints a little, such as allowing deadheading; however, in the present study the crew pairing problem addressed will be dealt with as SPP only because no deadheading would be allowed.
2.4 SOLUTION APPROACHES There are two basic approaches to solving the crew pairing problem. In the first approach, the pairings generation phase and the optimization phase are dealt with as separate stages, as this
15
helps in considering the constraints and the associated cost functions only during the pairings generation stage. In this case, the pairings are traditionally generated from valid duties using a depth-first-search approach, which is further discussed later. However, this leads to a large number of pairings involved in the optimization stage, making it larger in size and more difficult to solve. Yet, some researchers suggest heuristics (or any other procedure) for trimming the set of generated pairings before feeding them as input to the optimization stage. In the second approach, an initial set of pairings is generated and then the optimization procedure is used to guide which pairings should be augmented to such an initial set. The former approach of dealing with each phase separately is the approach adopted in the present study. Regardless whether the pairings generation is dealt with as a separate phase or not, the crew pairing problem with the pairing optimization phase represented as a set partitioning (or covering) problem, according to Theil [5], could be solved by Mathematical Programming Techniques, Network-Based Models, Meta-Heuristics, or by other different approaches. 2.4.1 Mathematical Programming Techniques According to its mathematical formulation, the crew pairing problem could be considered as a Binary Integer Programming (BIP) model. In real life problems, these models involve a large number of variables which are the pairings represented by columns and the usually huge set of vertical constraints. Three of the known approaches for huge mathematical programs will be reviewed; branch-and-bound, branch-and-cut & branch-and price, and column generation. a) Branch-and-Bound For an integer programming problem, the branch-and-bound approach starts by solving its Linear Programming (LP) relaxation. Then, using the obtained solution (which is most probably not an integer) two sub-problems are created (branching) in order to narrow down the solution space. The solutions of these sub-problems bound the solution of the original problem they came from (bounding). Using certain fathoming rules together with a tree-like structure the approach is carried out until an optimum integer solution is reached. According to Potter [12], branching could be either on the variables or the constraints, which could affect both the difficulty of solving the sub-problems and how well the approach could work within other frameworks; furthermore, determining the order in which the branches are explored is critical.
16
In airline context, each decision variable (pairing) would only be either zero or one, and hence when branching on the decision variables there is no more than two options only for each decision variable and not multiple options. Also, each tree level would represent a single decision variable; consequently the number of the tree levels would be at most equivalent to the number of the decision variables in the problem. In addition, in this case pairings must be generated before hand as a separate phase before optimization. b) Branch-and-Cut – Branch-and-Price However, the traditional branch-and-bound approach would not be able to find optimal solutions for large crew pairing problem instances, other solution techniques dealing with small subsets of the problem have been developed [2]. Of those techniques, are the branchand-cut and branch-and-price approaches, which are both generalizations of the branch-andbound approach; where in the former, classes of valid inequalities are left out of the LP relaxation, while in the latter, columns are left out, and this is in order to be able to handle the problem efficiently [13]. Branch-and-cut methods are exact algorithms consisting of a combination of a cutting plane method with a branch-and-bound algorithm [2] as, according to Barnhart et al [13], it allows separation and cutting to be applied throughout the branch-and-bound tree. If the LPrelaxation (with fewer inequalities) is solved and found to be infeasible, a sub-problem called separation problem is solved to determine violated inequalities that could be added to the LP to cut off the infeasible solution; the LP is then re-optimized and branching occurs when no more inequalities are available for cutting off. In branch-and-price, the main focus here is on pricing rather than cutting – both are considered as complementary procedures for tightening an LP relaxation. In a similar way, after removing sets of columns the LP is checked for optimality, but by using a pricing problem instead; which is a separation problem for the dual LP and it is solved to try to identify columns to enter the basis. If such columns are found, the LP is re-optimized. Branching occurs when no columns price out to enter the basis and the LP solution does not satisfy the integrality conditions [13]. An example of using the branch-and-cut approach in crew pairing problems is presented in [7] for 68 large real-life set partitioning problems having up to 825 rows and up to 1.05 million variables obtain from different airline companies. The approach uses a branch-and-
17
cut optimizer to solve the problems to optimality while explicitly considering base constraints. This optimizer has four main components, a preprocessor that tightens the userspecified formulation; a heuristic that yields “good” integer-feasible solutions quickly; a cut generation procedure that tightens the LP relaxation, and a branching strategy that selects the “next” branching variable and determines the traversal order of the search-tree. This approach is considered one of the best approaches yielding an exact optimal solution, as problems were solved in “reasonable” time; problems having less than five thousand variables were solved in less than 4 seconds with an average running time of less than one second, and the total time for the largest problem was less than 37 minutes. Whereas in [14], the value of using a branch-and-price approach in a heuristic framework was demonstrated, where dynamic column generation is used together with a customized branch-and-bound procedure to solve the crew pairing problem; in which, column generation was allowed to be executed at each node of the search tree. The presented algorithm starts with solving an LP relaxation of the restricted master problem, and then proceeding with the column generation approach with some modifications. These modifications include creating a number of pairing generation stopping rules and a target value for the LP that will be used with the solution of the shortest path problem to determine whether new columns are to be added to the problem and to eventually obtain an integral solution. The algorithm with two network-based versions was implemented on two test cases, and reported finding good solutions to problem instances with over 2000 flight legs. c) Column Generation As for the column generation approach, it also attempts to handle a smaller problem by dealing with a smaller subset of pairings rather than the significantly large complete set of generated pairings; this involves partial generation of pairings. As exhaustively described in [15], a restricted master problem is constructed from the original (master) crew optimization problem, by using a specified number of pairings only constituting a feasible solution; this new sub-problem is solved and the resulting dual prices are computed and then according to certain calculations, it is determined whether more columns should be added to obtain an optimum solution of the problem; this process is repeated until no more columns could be added. It should be noted that column generation approach integrates between the pairing generation and crew pairing stages, as it goes back and forth between them to obtain optimum set of pairings.
18
According to Flórez et al. [16], this common column generation method could be referred to as “dynamic column generation”; however, if the restricted master problem is an LPrelaxation of the master problem, integer solutions are not guaranteed at the end. In contrast, an approach as branch-and-price performs column generation at every node of the branchand-bound tree; as a result no such issue could result. It is also possible to use a heuristic version of branch-and-price with less computational requirements on the expense of optimality. 2.4.2 Network-Based Models The crew pairing problems could also be formulated as network flows. There are usually two types in literature, trip-as-node and trip-as-arc networks, where the term trip usually stands for flight leg; flight duty or pairing [5]. With such a network representation, generation of legal pairings is done simply by generating paths that start and end at crew base passing through subsequent flight legs [2]. Furthermore, the column generation approach is usually used together with network-based models solution techniques to solve the crew pairing problem; where the generated subproblems are often constrained shortest path problems, with the legal pairing corresponding to the shortest path is the pairing (or column) being considered for addition. An approach using a trip-as-node network based model representation could be found in [17]. This paper uses a network with nodes representing origins and destinations of different flights – source and sink nodes, and a set of connecting arcs representing possible duties connections, while considering only 1-flight duties. The first step in their proposed algorithm is to use a heuristic to generate enough initial columns (pairings). The heuristic starts by selecting a duty arc within the network and then solving two shortest path problems, one is from the source node to the tail node of the duty arc and the other is from the head node of the duty arc to the sink node; these two paths along with the selected duty arc, form a feasible pairing, this arc should then be deleted and the process is to be repeated until no more pairings could be generated.
Then, the algorithm proceeds using a column generation
approach along with the Simplex method for solving the restricted master problem followed by solving the shortest path problem for the different sub-problems (those are the subproblems formed sequentially as part of the column generation solution technique to identify which new column to be added to the restricted master problem). Finally, it applies the
19
branch-and-bound technique coupled with the column generation approach to find the optimal integer solution in case the obtained optimal solution was non-integer. 2.4.3 Meta-Heuristics These types of algorithms are characterized by being mimicking naturally occurring processes. For instance, Genetic Algorithms and Ant Colony Optimization have been successfully applied to solve the crew pairing problem. a) Genetic Algorithms Genetic Algorithm (GA) was first introduced by Holland and is based on Darwin’s theory of survival of the fittest. They are based on the principles of natural genetics and natural selection. The basic elements of natural genetics – reproduction, crossover, and mutation – are used in the genetic search procedure [18]. The algorithm starts by creating a population of chromosomes (individuals) where each one of them represents a solution to the problem. Then, using a certain fitness evaluation function, the current population (some of it or all of it), is replaced by reproduced offspring from the fittest chromosomes (parents) in the population along with a crossover operator. The mutation operator is usually applied randomly for certain chromosomes. Generation of new populations is repeated until the optimum solution is reached [5]; usually with such a solution technique, it is less likely to get trapped at a local optimum [18]. A GA-based heuristic for the Set Partitioning Problem (SPP) was reported as early as 1995 in Chu and Beasley [19]. In their report, some GA basic components were modified, such as using two measures of fitness instead of using a single fitness function with a penalty term, using two kinds of mutation operators; namely a static one and a dynamic one, using a heuristic feasibility operator to make solutions less infeasible, and using a new parent selection method as well as a new population replacement scheme. This heuristic was able to solve 55 real life problems from the ones used in [7] to optimality or near optimality, however it was not computationally competitive with exact solution techniques, except in perhaps problems when the gap between the LP relaxation value and the optimal integer value is large. The same authors developed a similar GA-based heuristic in [20], but this time it was for the Set Covering Problem (SCP); where they modified the crossover and mutation operators, and also added a heuristic feasibility operator. Reported results are optimal for small-sized
20
problems and of high quality for larger problems. It is also noteworthy to mention that they had also made slight enhancements to their previous work for the SPP in [21], but not with much effect on the results, however they grouped test problems from a number of sources (as [7] and [22]) and made them available to researchers online Another similar approach could be found in [22] which uses GA along with a local search heuristic that helps in finding feasible, or near-feasible solutions. The hybrid algorithm uses a linear penalty term with the evaluation function, common GA operators, examines different population replacement schemes, and a modified initialization process. The hybrid algorithm was tested on 40 real-world problems (also taken from set found in [7]) and results were not all optimal as those obtained by the original branch-and-cut approach; and when running time is relatively compared, the branch-and-cut algorithm was significantly faster. Furthermore, the proposed approach was outperformed by branch-and-bound as well, but not as significantly. Hence, several areas of improvement were reported. The work of Ozdemir and Mohan [23] combines a trip-as-node network representation approach with GA. The authors claimed to have a GA algorithm different than those of [19], [20], and [22]; whose goal was to produce solutions that respect constraints, minimize number of crews, maximize crew time utilization, and balance workloads. The algorithm main characteristics include using a certain procedure for initial population generation, using mutation operators similar to well-known cross-over operators (such as one-point and twopoint crossover operators), experimenting different recombination operators, and utilizing a restoration algorithm when the solution does not cover all flights. This algorithm was compared with a number of other approaches (including the GA approach in [20]) and the authors found it to be better than the other approaches in many aspects. The solution proposed by Kornilakis & Stamatopoulos [24] was a two-phase procedure; for the first phase - the pairing generation phase, a depth first search approach was employed, while the second phase dealt with the selection of a subset of the generated pairings with a near optimal cost using GA. The first phase was itself divided into two sequential steps, one for the generation of valid duties and the other combines those valid duties in such a way to yield legal pairings. For the first step, it starts by systematically forming feasible duties using a function that checks the validity of a duty and checks whether more duties could be added to it or not. Then, for duties that could be extended, another function checks all possible flight legs that could be added to it to form new valid duties; this process was repeated until all
21
possible duties were generated. Finally, to reduce the number of duties that will be used in the pairing generation step, an algorithm was applied to select duties that will be most useful in the optimization stage. The second step, generation of pairings from valid duties proceeds in a similar manner. As for the optimization phase, the proposed method by Kornilakis & Stamatopoulos [24] was based on [20], where a modified genetic algorithm was used. This algorithm dealt with the problem as SCP and the modifications were made to make it better fit to its specific characteristics. It also used a slightly different objective function containing a deadheading penalty and avoided having infeasible solutions in the population after mutation by applying a correction algorithm on the new chromosome. GA approach suggested by Zeren & Özkol [25] was an extension of the work in [24] and [20], where the problem was addressed as two phases with the pairing optimization phase handled as a SCP. Pairings were generated in the first phase with the exact depth-first search algorithm presented by [24], with the only difference was having to repeat the approach for mutli-crew bases. As for the optimization phase, this paper proposes a GA with a perturbation operator to be applied after the feasibility operator to enhance the efficiency of the current solution. The results of their proposed approach when applied to a case-study were compared with those obtained by the GA of [20], and were also compared to the exact solution for the same case-study in order to evaluate their solution quality. In general, the proposed GA approach could converge faster and needs less computational time. It should be noted that in the present study the pairing generation phase will be modification to the algorithm by Kornilakis & Stamatopoulos [24]. In addition, the GA approach in [25] will be considered as the backbone of the proposed GA for the pairing optimization phase. b) Ant Colony Optimization Ant Colony Optimization (ACO) is based on the cooperative behavior of real ant colonies, which are able to find the shortest path from their nest to a food source. The ACO process could be explained by representing the optimization problem as a multilayered graph, where the number of layers is equal to the number of design variables and the number of nodes in a particular layer is equal to the number of discrete values permitted for the corresponding design variable [18]. The ants start at the home node, travel through all of the available layers to reach the destination node in each cycle (iteration). Each ant could select only one node in
22
each layer in accordance with a certain state transition rule. For a completed path, the ant deposits some pheromone on it and when all ants complete their paths, the globally best path is updated. The values of the design variables denoted by the nodes on the path with largest amount of pheromone are considered as the components of the optimum solution, this is the path which all ants converge to eventually; this approach is usually used for minimization problems. An approach using ACO could be found in [26], where the problem was solved using hybridizations of ACO with constraint programming. The paper started by trying direct implementation of the basic ACO framework alone, but it was incapable of obtaining feasible solutions for many SPP instances. Then, the paper explored the addition of a look-ahead mechanism in the construction phase of ACO thus generating only feasible solutions, where the ACO used constraint programming in the variable selection (when adding columns). The approach was implemented on data sets provided by [21], and was able to solve most of them optimally. Another ACO-based approach was presented in [27], it used a trip-as-node network representation, along with ACO to solve the crew scheduling problem. In the proposed ACObased algorithm, ants start with an empty permutation and then iteratively choose a flight (node) by using a certain state transition rule to complete the path from the graph, and seek the path with minimum cost. The use of the network representation ensured the fulfillment of all constraints. Two computational experiments were presented, one is to determine the best combination of the ACO-related parameters, and the other compares the resulting solutions with those of the GA approach in [23]. Twenty-eight test problems from [23] were chosen and the paper presented three basic criteria for performance evaluation, which are accuracy, robustness, and efficiency. These were measured in terms of average cost error, its standard deviation, and the CPU calculation time and the number of iterations required for convergence of each method respectively. Results, in general, show that the proposed ACObased algorithm provided better values of those measures. 2.4.4 Other Solution Approaches A different formulation of the crew pairing problem could be found in [6], which presented a duty-period-based formulation that divides the problem into two stages. The first built duties while the next built the pairings, and suggests a decomposition approach for solving the model that incorporates column generation. For some real examples the new formulation
23
provided optimal integer solution for the LP relaxation when the traditional fails to do so. However, with this new formulation, the LP relaxation of the problem is difficult to solve. The approach in [28] is a hybrid one that uses a combination of other methods, which aimed to obtain better solutions than the solution obtained by each method separately and to try to avoid their disadvantages. This algorithm starts with a “SPRINT method” to solve the LP problem, and then uses a “Carmen algorithm” or a “branch on follow-ons” method to find the integer solution. The main approach for the “SPRINT” method is finding the optimal solution of a large scale LP by solving a small number of subset LPs iteratively. Not only does the “SPRINT” method solve the problem, but it also generates pairings as well. The “Carmen algorithm” seeks an integer solution to the problem not by using the solution of the LP problem as an intermediate step; instead it finds the integer solution in a more direct way; as main idea behind this algorithm is that it uses dual values and reduced cost to find integer solutions. Whereas the “branch on follow-ons” method seeks an integer solution in a fashion similar to normal branching, but it adds a certain rule to forcing two flights to appear consecutively in a pairing to speed-up convergence. Experiments show that when using the “Carmen algorithm” the results are not satisfactory, unlike when using the “branch on followons” method- which is though slower, but provides better results. A new integer programming framework, based mainly on the concept of subsequence generation which limits the number of subsequences (consecutive flights) in the problem and dynamically adds attractive ones as needed. To obtain an integer solution, a follow-on branching strategy was used [29]. Table 2.1 shows a summary of the reviewed direct application papers representing direct solution approaches to the crew pairing problem with its two stages. Only important characteristics are shown in the table. It is now apparent that the pairing generation phase is not usually discussed extensively in related literature, as it typically depends on simple enumeration techniques such as a depthfirst-search approach and most researchers assume that all pairings are available before hand; whereas several different solution approaches were proposed for the pairing optimization in literature, such as mathematical programming and meta-heuristic approaches among others, with GA-based approaches being very common.
24
Table 2.1: Summary of Reviewed Papers
ACO
√
Beasley and Chu, 1996 [20]
√
Lavine, 1996 [22]
√ √ √
Vance et al., 1997 [14]
√
Ozdemir and Mohan, 2001 [23]
√
Yan and Chang, 2002 [17]
√ √
Kornilakis and Stamatopoulos, 2002 [24] Crawford et al., 2006 [26]
√
Özdemir, 2009 [28]
√ √
Technique and/or Remarks
Dealt with the general problem, not necessarily in √ airline context. Proposed formulation.
√
new
√ √ √
Used heuristics for initial pairing generation.
√ √
√ √
Deng and Lin, 2011 [27]
√
Proposed a hybrid approach.
√ √
√
√ Proposed a new different approach
Rasmussen et al., 2011 [29] Zeren and Özkol , 2012 [25]
Other Solution
√
Chu and Beasley, 1995 [19]
Vance et al., 1997 [6]
Allow Deadheading
Metaheuristics
GA
Hoffman and Padberg, 1993 [7]
Branch-and-Price
Branch-and-Cut Branch-and-Bound
Column Generation
Network-based Model Pairing Generation
Authors and Date
Mathematical Programming
√
√
√
2.5 ADOPTED SOLUTION APPROACHES The present study includes a modified enumeration method for the pairing generation phase, and a proposed GA, for the optimization phase. 2.5.1 Depth-first approach for the Pairing Generation Phase Kornilakis & Stamatopoulos [24] stated that the number of pairing to be checked for validity is a function of the number of flight legs in a given timetable as shown in Equation (2-8).
25
Number of pairings to be checked for validity = 2Number of flight legs
(2-8)
The main principle is to deal with this phase as two sequential steps. During the first step, a depth-first search is used, which systematically forms possible duties (sets of flight legs), checks if they satisfy the constraints and stores them if they do. The best of the generated duties are kept and provided as input to the second step, where a similar process is used to initially generate a large number of legal pairings and afterwards keep the best of them. Since both steps are quite identical, the explanation of the first step only will be given, that is the duty generation step. This step consists mainly of two functions, namely, the “validDuty (currentDuty)” and “searchForDuties” functions. The algorithm starts by generating duties using the “validDuty (currentDuty)” function, which seeks not only to find feasible duties (the “Keep” binary parameter) but also states whether each duty could have additional legs or not (the “Continue” binary parameter). The flowchart for this function is shown in Figure 2.5, where L stands for the set of all flight legs that appear in the timetable.
Start Generate a subset from L and name currentDuty Calculate “Keep” & “Continue” Values Yes
Keep = 1?
No
More subsets from L could be generatted?
Yes
No
END and Go to searchForDuties function
Insert currentDuty to “duties” array
Figure 2.5: The Flowchart of the “validDuty (currentDuty)” Function Then, using the “search For Duties” function, additional legs are added to the duties which had already been identified in the previous function. This function consists mainly of two 26
loops, one to guarantee that for each duty all possible legs are considered, while the other guarantees that all valid duties are considered for elongation, as shown in the following flowchart from [24].
Start Select a Duty in “duties” array & name currentDuty
Continue = 1?
Yes
No
More duties are available?
Yes
End
Select a Flight leg from L Yes
Chosen Leg subsequent to last leg in currentduty?
No
More legs from L could be chosen?
Yes Same airport as last leg in currentduty?
No
No
No
Yes
Add leg to currentDuty Apply the validDuty(currrentDuty) Function Apply the searchForDuties (currentDuty, duties) Function Remove leg from currentDuty Figure 2.6: The “searchForDuties” Function [24]
27
Using so many duties as input to the next phase of the pairing generation and the optimization will cause serious performance problems. Therefore, a subset containing the duties of the highest quality possible is chosen and kept. To this end, an algorithm that performs the selection of the best duties has been implemented in [24]. The criterion for keeping or not a duty is related to how useful this duty will be in the search for an optimal solution to the crew pairing problem. This is decided by a heuristic function, which returns the ratio of the flying time of the duty over the total duration of the duty. 2.5.2 GA for the Pairing Optimization Phase GAs basic idea is to generate an initial population of chromosomes representing candidate solutions of the problem and then reproducing a number of generations by applying a group of different genetic operators (such as parent selection, crossover, and mutation) in order to improve the current population and make it come closer to the optimum solution; i.e. converge to it. a) Variables Representation (Chromosome Encoding) There are only two methods for variables representation used. They are either column-based or row-based representations. Any chromosome is composed of a number of genes and the difference between these two types is what those genes represent. In column-representation, genes represent available crew pairings with a binary value indicating its inclusion in the solution; where a gene value of one would mean that the corresponding pairing is included in the solution. The number of genes in this representation is equivalent to the total number of pairings (P) in the problem as shown in Figure 2.7. The advantage of this representation is the use of binary values that fits the nature of the SPP (or SCP) variables; however, it has the disadvantage of allowing infeasible solutions to be formed along the course of the GA [20] [25]. The column-based representation has been used in most of previous work having GA as their solution methodology; and also in the present study. column (gene) bit string
1 1
2 0
3 1
4 1
… …
P 0
Figure 2.7: Column-based Chromosome Representation On the other hand, in row-based column representation, chromosomes have genes equivalent to the number of flights present (F), where each gene value represents the crew pairing which 28
covers the corresponding flight as shown in Figure 2.8. However, with this representation, it is possible to represent the same solution in different forms because the same crew pairing would be represented by more than one gene; this would cause difficulties in calculating the fitness function [20] [25]. Furthermore according to Zeren & Özkol [25], this representation could not provide satisfactory results when genetic operators are applied. row (gene) String
1 10
2 7
3 32
4 143
… …
F 55
Figure 2.8: Row-based Chromosome Representation b) Initial Population Generation The initial population represents the original pool of chromosomes on which genetic operators are performed to enhance the solution, it is very important to create an initial population that is as diverse as possible for the GA to explore the solution space, and then allowing it to determine the most promising ones. An initial population could be composed of a number of chromosomes equivalent to the number of pairings, each containing just a single pairing that has not been chosen before to cover all the available flights; another one could just be creating a population as random as possible. In fact, most of the different suggested ways of initial population generation in related literature depend on some sort of randomization in their generation. In [19], a completely random population is generated, while in [25] a random population is generated such that each flight is covered by only one pairing in a flight-based approach. This flight-based approach is the initial population generation method used in the present study. This is due to the fact that this approach would be better than any other random approach, as it attempts to generate initial chromosomes that are either feasible or almost feasible. c) Fitness Function Evaluation The fitness of all the chromosomes in the population represents “how well” a chromosome is with regard to solving a problem; this is done using a suitable fitness function. There are a lot of suggestions for dealing with the fitness function, in [20] it was considered just to be the problem objective function, in [19] and [21] a “fitness-unfitness” function was proposed in order to have two measures of evaluation instead of the just one, adding penalties to the
29
objective function for violated constraints as in [22], adding penalties for deadheaded flights as in [24], or using a fitness function which does not only take the total flight duration cost (duty and rest) into account, but also a couple of other terms such as a penalty factor for the deadhead flights, and a term is for the crew distribution cost that should provide regular work balance between crew bases as described in [25]. The present study uses the original minimization objective function as in Equation (2-1), without adding anything to it, since deadheading would not be allowed, and no penalties would be used. d) Parent Selection Operator Usually two chromosomes are chosen according to a certain criterion (such as their fitness) to be the parent chromosomes, which will then have genetic operators applied to in order to produce new chromosome offspring. A simple way of doing that is by just ranking the chromosomes in the current population according to their fitness and choosing the two most fit chromosomes as the parents; this method was applied in [24]. Another method that is common most of the related literature is the use of a binary tournament for parent selection. In this method, two chromosomes are chosen randomly, and the one having better fitness would be the first parent; this process is repeated for the second one. The binary tournament method is the one that will be used in the present study because, according to [25], it does not require much calculations and runs fast. e) Crossover Operator After the parents have been selected, the crossover operator is implemented. Its objective is to create a new offspring by exchanging the information among chromosomes in the current population; this is usually done by exchanging some portions of the parent chromosomes. The resulting offspring will have characteristics from both parents and if the parents are of high fitness themselves, then the offspring could have the same or even better fitness values; the offspring could actually have worse fitness value as well, however this would not much affect the solution as according to the principle of survival of the fittest that GAs are based on, this offspring with poor fitness value would probably not be selected in the next generation. A common crossover type operator, in the field of pairing optimization, is the single-point operator; where a crossover site is selected along the chromosomes length (usually 30
randomly), and genes to the right of this site are swapped between the two parent chromosomes creating two new offspring chromosomes. The crossover may not necessarily be just a single point, in fact, a couple of the approaches in related literature such as [22] and [23], used one-point and two-point crossover operators. Another commonly used operator type is the uniform crossover operator, in which each gene of the offspring is either the same as the gene of the first parent or that of the second parent with equal probabilities. This type produces only one offspring chromosome and has been used in solutions of [19], [21], and [24]; however, in this type the choice of which parent the offspring resembles more in properties is made randomly without depending on the actual fitness of those parents. To avoid this shortcoming and to make offspring chromosomes more affected by parents with higher fitness, a fitness-based crossover operator was suggested in [20] (and later used in [25]); which uses fitness values of parent chromosomes in a probabilistic way to select genes during crossover operation. This operator which has been known as the fusion crossover operator, also produces one offspring chromosome and it ensures that it will be more likely similar to the parent with higher fitness. According to [20], the underlying principle behind this operator is that the choice of which of the two parent chromosome genes are passed to the offspring chromosome should be made based on their relative fitness values; as it is assumed that the inheritance of a particular gene from a more fit parent is likely to contribute more to the offspring’s overall fitness than that from a less fit parent. Such choices need to be made only for those genes with different values in both parents. The one-point and the fusion crossover operators are selected to be implemented in this study the present study due to the latter’s capability of generating new chromosomes when the parent chromosomes have a similar structure [20], and to increase the population diversity. f) Mutation Operator The crossover operator is mainly responsible for creating a new offspring with better fitness values for each generation. Then, the mutation operator is usually applied for those new offspring with a specific probability; it flips the value of the binary digit from 1 to 0 or vice versa. The main reason for applying this operator is to avoid getting stuck in a local optimum solution without ever reaching the global optimum. It also helps to maintain the diversity of the solution, and to obtain chromosomes that could not be created otherwise.
31
A range of mutation operators were suggested for implementation in related literature, including a static mutation operator suggested in [22] that mutates each gene in one of the parent chromosomes with a probability equal to the reciprocal of the number of pairings, a dynamic mutation operator used in [20] and then [25] that first determines the number of genes to be mutated through and the mutation rate through certain equation, and a static mutation operator that depends on percentage of genes containing 1s in the fittest chromosomes as in [24]. The two static mutation operators are the ones implemented in the present study; because the latter is based on the fittest chromosomes and will most likely be able to produce a more fit offspring, while the former is chosen to further increase the population diversity. g) Population Replacement Scheme The final step in each iteration is to determine how the offspring chromosome will fit into the original population, i.e. how will they be incorporated within the population itself. There are usually two methods used in the present field of research of doing that, the first which is called the “Generational” method replaces the whole population with the offspring chromosomes; but in this way the best chromosome(s) may not survive in the new generation, and the new generation may not necessarily be as fit as the previous one. The other method replaces the less fit chromosomes with the new offspring chromosomes, allowing the fittest chromosomes to be present in the new generation; this method is called the “Steady-State” method and is more common in related literature, where it has been applied in [20], [22], [24] and [25]. In the present study, the “Steady-State” method is preferred over the “Generational” one; mainly for two reasons, firstly, fit chromosomes will not be replaced by other chromosomes that may not be as fit, and secondly because the generated offspring may not be equivalent in sum to the population size and hence will not be able to replace the whole population. More specifically, the elitist strategy suggested in [25] is the one used in the present study, because not only does it keep fit parents and offspring chromosomes in the same population but ranks the chromosomes in the generation as well, which makes determining the optimum solution easier.
32
2.6 CLOSING REMARKS Crew scheduling is composed of two sequential problems, namely, the crew pairing and crew rostering problems; in addition to that, these problems differ according to the crew type. Furthermore, the crew pairing problem is itself further decomposed into two consecutive phases, the pairing generation and the pairing optimization phases; the latter is usually handled as a SPP which is considered quite a difficult problem to solve. The main problem with either phase is the large number of feasible pairings to be dealt with, making the scheduling problem more difficult. The present study addresses both phases of the airline cockpit crew scheduling problem with its main objective is to develop methodologies which could successfully turn scheduled flights within a certain time horizon into valid pairings and then selects the set of pairings having least possible cost while covering all available flights. For the first phase, that is the pairing generation phase, the developed methodology is a modified enumeration approach incorporating a breadth-first enumeration algorithm, which is a modification of the depth-first approach presented in [24]. As for the optimization phase, the developed approach in the present study is using a proposed GA that attempts to combine the strength points of the different GA-based approaches in related literature with mainly the GA approach in [25] as its backbone. However, before moving on to the next chapter, it is important to point out that although there exists an exact method (by Hoffman and Padberg [7] ) that is capable of solving the optimization phase to optimality in reasonable time despite the nature of the problem itself, attempting to solve this problem using GA is preferred for a number of reasons. Firstly, using GA for this type of problems has certain advantages over exact methods such as not having to solve the LP relaxation of the problem making them much easier to implement without resorting to any optimization package, flexibility in handling problem variation, and being able to provide a population of possible solutions at any iteration which is as important as (or perhaps even more important than) an isolated optimum solution. Secondly, all the GA approaches proposed (such as [25]) in spite of being not necessarily computationally competitive with exact methods are quite promising, and most showed possibilities of being competitive if enhanced.
33
Finally, the nature of the problem itself may not always allow finding the optimum solution in a reasonable amount of time for large problem sizes using exact methods; this would surely be problematic for airlines companies having large flight sets. The main issue when dealing with large size problems with exact methods is that they could require highly complex and time consuming calculations, unlike GAs which search a much larger search space in less time.
34
CHAPTER 3 METHODOLOGY
CHAPTER 3 METHODOLOGY 3.1 INTRODUCTION This chapter describes the solution approach for the crew pairing problem with its two phases, which has been developed in the present study. The developed solution approaches incorporates a modified enumeration method for the pairing generation phase, and a proposed GA, for the optimization phase that combines a number of genetic operator used in different related work. It should be noted that the solution methodology for both phases are implemented in C programming language (APPENDIX A).
3.2 THE PAIRING GENERATION PHASE In this phase the present study will modify the procedure presented by Kornilakis & Stamatopoulos [24]. The modified approach is essentially a breadth-first enumeration algorithm that starts by generating all duties of length one first, and then those of length two and so on; unlike that of [24] that starts with a given flight and generates all possible duties with all different lengths from it, and then goes to another flight and so on. As shown in Figure 3.1, where each step represents a function (subroutine) that has been carried out in the modified approach, the
Start Initialization
algorithm begins by generating all valid singlelegged duties from all available flight legs, and then seeks to find all additional duties that could be generated, and finally using all those duties
Single-Legged Duties Generation Additional Duties Generation Overnight Duties Generation
generates all possible valid crew pairings.
“Connected Duties” Generation
3.2.1 Initialization This is a preliminary procedure that sets up the algorithm to be able to start working, all the necessary data for the algorithm to start is defined here. This procedure performs the following sequence of steps:
36
Pairing Generation End Figure 3.1: Overview of Modified Pairing Generation Algorithm
1. Defining all necessary variables and function prototypes. 2. Equating all elements of arrays that are used for storing duties and pairings to zero. 3. Setting the values of some airline-related parameters which will be used throughout the whole algorithm. These values are usually problem specific, and although there exists typical values from them, they should be determined according to each case. A list of these parameters follows; all of them need values representing duration except for the last one (MaxDuties).
MaxSit and MinSit
Briefing and DeBriefing
MaxElapse
MinRest
MaxFly
OverNightRest (minimum
MaxDuties
permissible overnight rest)
4. Taking the number of flights as a user input. 5. Taking number of crew bases as a user input; as well as the corresponding numeric values that represent their identifiers. 6. Reading available flight legs as input data using a “ReadInput” function, that accepts input as a data file with each row representing the information about a specific flight. For any given flight, this information includes its number, origin airport, destination airport, start time, end time, and starting day, respectively. The function stores these values for each row (flight) into corresponding arrays. 3.2.2 Single-Legged Duties Generation This step forms valid single-legged duties from all flights by selecting all possible 1-element subsets of flight legs. It turns each flight leg into a duty, as long as it forms a feasible duty. This step requires the use of two functions, a “DurationCalculation” function and a “ValidDuty” function. For any given flight, its elapse time is first calculated using the “DurationCalculation” function that requires two inputs, the flight (or duty) starting time (S) and its ending time (E). The function logic is shown in Figure 3.2, and it returns a variable called “Duration” which represents, in this case, the flight elapse time. This flight is then named as “Current Duty” and the “ValidDuty(i)” function is used to determine whether this resulting duty is valid or not, and if it could have additional legs added to it or not by calculating its “Keep” and “Continue” variables respectively in a fashion similar to the one described in [24]. 37
Start Yes
S>E?
No
Duration = (24 - S) + E
Duration = E - S
Return Duration End Figure 3.2: “DurationCalculation” Function This function obviously needs the duty itself to check it, which is denoted by i and is “Current Duty” in this case. As shown in Figure 3.3, for a duty to have a “Keep” value of 1 its elapse time along with its debriefing time must not exceed the maximum allowable elapse time (MaxElpase), and its flying time must not exceed the maximum allowable flying time (MaxFly); whereas it would have a “Continue” value of 1, if after adding the minimum allowable rest time between duties (MinSit) and the de-briefing period to its current duration, there would be still room for another flight before reaching the MaxElapse value. If the “Current Duty” turns out to have a “Keep” value of 1, then all the characteristics such as its start time, end time, etc. of the original flight are transferred to a new duty that is added to a “Duties” array. This transfer is done while taking into consideration the fact that the flight could be overnight which may affect the duty end time and end day, and that the briefing period alters the starting time of each duty. This process is repeated until all available flights have been considered. It should be noted here that, the size of the “Duties” array is ever increasing as long as there are more duties that could be added to it. 3.2.3 Additional Duties Generation The purpose of this step is seeking to add more flight legs to all available duties to form new valid duties, as long as the added flight legs are in the same day of the current duty, this is to prevent connecting any flight leg to a duty that ends after midnight. This step first checks if chosen leg is subsequent to the last leg in “CurrentDuty”, but not starting on a new day. If so, it uses a “SearchForDuties” function that is quite similar to the one described in [24].
38
Start
Yes
Elapse < (MaxElapse – Debriefing) && Fly < MaxFly ?
No
DutyKeep[i] = 0
DutyKeep[i] = 1
MaxElapse - (Elapse + MinSit + DeBriefing) > 0 ?
No
Yes DutyContinue[i] = 0
DutyContinue[i] = 1 End
Figure 3.3: “ValidDuty(i)” Function As shown in Figure 3.4, the function checks if the flight leg day is the same as that for the current duty that it will be added to, if they are in the same airport, that is if the origin of the flight leg is the same as the duty’s destination, and if the allowable rest time between the two of them is neither less than the minimum allowable rest time (MinRest) nor is it larger than the maximum allowable rest time (MaxRest). If all this checks out to be true, then the duty flying and elapse times are both computed and are used to determine the validity of this duty, utilizing the “ValidDuty” function. If the resulting current duty is valid it is added to the “Duties” array in the same manner discussed before. This process is repeated for all available flight legs for a given duty, and for all available duties until no more new duties could be created; again, here the size of the “Duties” array is increasing along the way.
39
Start
Select a suitable Duty in “Duties” array & name “CurrentDuty”
Continue = 1?
Yes
No
More duties are available?
Yes
No End
Select a Flight leg
Leg day is same as duty start day?
No
Yes
Yes
Same airport as last leg in currentduty?
No
More flight legs could still be chosen?
No
Yes Rest duration within allowable limits?
No
Yes Calculate current Fly & Elapse values Apply the validDuty(CurrrentDuty) Function No
Keep = 1?
Remove leg from currentDuty
Yes Add leg to “CurrentDuty”
Insert currentDuty to “Duties” array
Figure 3.4: “SearchForDuties” Function
40
3.2.4 Overnight Duties Generation This step seeks additional duties that could be formed by considering duties that pass midnight. Although these duties are not necessarily valid, as a single duty of those could consequently stretch for more than a day, generation of these duties helps in the pairing generation process. This step is almost the same as the previous one, with the only difference being allowing flight legs to be added to duties that are not on the same day, as long as the difference between them doesn’t exceed 24 hours. The resulting generated duties are also added to the “Duties” array following the duties generated in the previous step. The main reason for not including this step within the previous one is to keep valid duties generated from the previous function easily distinguishable from those duties generated by this function, i.e. to prevent mixing-up both valid and invalid duties together in the same array. Identifying any invalid duty could now be easily made, for example, if the previous function had added thirty duties to the array, then any duty in the array located after the thirtieth element is considered invalid. In this way, the number of valid duties is easily determined and preserved. 3.2.5 “Connected Duties” Generation The next step aim is not to form feasible pairing directly from generated duties, as might have been expected; but is to generate an array of all possible candidate pairings. This array is entitled “ConnectedDuties” array, and its main objective is to contain all possible combinations of duties connected sequentially together, to form candidate pairings. These elements will be later checked to see if they constitute valid pairings. The need for such a “transitional array” is simply because pairings could not have been treated the same way duties have been treated. For instance, a combination of two duties by themselves may not be a valid pairing and should be rejected, however if an additional duty is added to them, they may form a legal pairing; had the pairings been treated as the duties were, the 2-duty combination not would have been taken into further consideration and no valid pairing could have been formed from this combination. Before creating this new array, de-briefing periods must be added to the end of all generated duties first. This new array could now be created such that all its current elements are initialized to zero, and then the whole elements of the generated array “Duties” are duplicated into it. In a similar fashion to the “SearchForDuties” function, all current elements of the 41
“ConnectedDuties” array are checked to add more connected duties to them using the “SearchForConnectedDuties” function; each possible new combination that is added to the array is also further checked as well. This function basically selects a connected duty from its array and checks if another connected duty from the array could be added to it and still constitutes a valid duty. The operation of this function depends mainly on the starting and ending days of both duties that it is attempting to connect. Typically there are three situations, both duties start on the same day with the second one ending on the same or following day, or both start on consecutive days, either each one starting and ending on separate days or the first one being an overnight duty while the second starting the following day. The function “SearchForConnectedDuties” is detailed in Figure 3.5; any “connected duty” is referred to as “C-duty”, and “c” is used for indexing the connected duty to be added to current connected duty, while “C” is the current maximum number of elements in the array; the size of this array as well is always increasing. Regardless of which situation the two selected connected duties fall in, the function essentially checks that they are subsequent, the destination of the first is in the same airport as the origin of the second, there is sufficient amount of rest between them, and their combined flying and elapse times do not exceed permissible limits. This process is repeated for all of the available connected duties until the maximum number of duties combination is reached for all possible connected duties generated, this number should not exceed MaxDuties. Finally any repeated combination of duties in “ConnectedDuties” array is deleted via a “DeleteRepeated” function. 3.2.6 Pairing Generation Finally, it is now turn to determine the valid generated pairings. For all elements of the “ConnectedDuties” array, this step checks which of those could form a valid pairing using a “ValidPairing” function as shown in Figure 3.6. A valid pairing would simply be any connected duty that starts and ends at the same crew base for all available crew bases. Connected duties forming valid pairings are added to the “Pairings” array. Results are printed into an output text file; this output file shows the details of the input flight data used together with the details of the valid generated duties, ConnectedDuties (if required), and the valid generated pairings. In addition to presenting the total number of
42
generated duties and pairings, presented details of each of the generated pairing include start and end times, fly and elapse times, number of duties contained, flights involved, days spent and corresponding cost. It should be noted that the algorithm could easily be modified to include any additional required output data.
Start with c = 0 No
C-duty 2 starts the next day C-duty 1 starts? & (C-duty 2 ends on the same day as C-duty 1 ends or the day after it) ? Yes C-duty 1starts & ends on the same day? & C-duty 2, at least, starts same day as Cduty 1 ends?
No C-duty 2 starts the day after C-duty 1 ends?
Yes C-duty 2 starts from same airport as Cduty 1 ends?
No
Yes
Yes
Calculate current Fly & Elapse values
C-duty 2 is subsequent to C-duty 1?
Yes
Rest > MinRest?
No
C-duty 2 starts the same day C-duty 1 ends?
No
Yes No
Calculate current Fly & Elapse values
No Daily Fly < MaxFly && Elapse < MaxElapse of all duties combined?
Yes
Yes Calculate Duration Daily Fly < MaxFly && Elapse < MaxElapse of all duties combined?
Calculate current Fly & Elapse values No
Fly < MaxFly && Elapse < MaxElapse?
No
Overnight Rest < Duration < a whole day?
Yes
Yes Yes
Add this valid combination to “ConnectedDuties” array as element number C
C-duty: Connected Duty c: Index of connected duty C: Current Maximum of C-duties
C = C +1 c 1? No More flights available to check?
Yes
No
More flights available to check?
Add this pairing to current chromosome
Yes
No
Delete Generated Chromsome
Yes
Repeated Chromosome?
No
Figure 3.8: “FlightBasedInitialization” Function
47
End
There are two other functions embedded in the “FlightBasedInitialization” function, those are the “RepeatedChromosome” function that checks whether the selected chromosome is identical to any already available chromosomes, and the “DeleteChromosome” which deletes a selected chromosome by simply equating all its genes to zero. 3.3.4 Feasibility Operator Implementation With the flight-based method of initial population generation, although all flights are covered by at most one pairing, the generated chromosomes are not guaranteed to be valid; that is, some flights may be under-covered. Hence, an operator was needed that attempts to make all infeasible chromosomes feasible or at least makes them less infeasible; not only will this operator by applied to the newly generated population of chromosomes, but any other chromosome(s) that will be generated by the different genetic operators to be applied and which may result in infeasible chromosomes. Consequently, a “FeasibilityOperator” function has been added to the algorithm; this function incorporates a number of auxiliary functions and procedures; the foremost of those is a “FeasibilityCheck” function that conducts a feasibility check for each chromosome first. The function then counts the number of flights covered by this chromosome, if they turn out to be less than the total number of flights (F), then this chromosome is under-covered; i.e., not all flights in have been covered by pairings in this chromosome. In addition to that, it also checks if any of the covered flights are repeated, in case at least one flight is covered more than once, then this chromosome is over-covered, and in this chromosome certain flights are covered excessively by more than one pairing. After determining the covering status of each chromosome, the next step in the “FeasibilityOperator” function is to determine which procedure will be followed to improve each chromosome’s feasibility. There is a sequence of steps to be applied for each chromosome depending on its status as outlined in Figure 3.9, and it is: 1. If the chromosome is under-covered, an “ADD” procedure is applied were more pairings are added to the chromosome to cover any remaining uncovered flights. This procedure is repeated for the same chromosome until it contains no more uncovered flights. 2. If the chromosome is over-covered, a “DROP” procedure is applied that removes as much redundant pairings as possible to make any given flight covered by the
48
minimum number of pairings possible if not just one, this is carried out without making this chromosome under-covered. 3. If the chromosome is neither under-covered nor over-covered, the feasibility operator function is terminated. It should be noted that a chromosome could, however, be both under- and over-covered at the same time, which means that it will have to go through both the ADD and the DROP procedures respectively.
Start Check
Apply FeasibilityCheck
ADD Procedure
Yes
Chromosome under-covered? No Chromosome over-covered?
Yes
DROP Procedure
No
End Figure 3.9: “FeasibilityOperator” Function Outline The first step in the ADD procedure is applying a “CountFlights” function that not only counts the number of flights in each chromosome, but also determines exactly which flights are under-covered and/or over-covered. Then, it checks which pairing(s) could be added to the solution that covers the under-covered flights without causing over-covering. If no such pairing could be found, the pairing that covers the least number of flights and could be added to the solution to cover uncovered flight(s) is added to the current chromosome. After a suitable pairing have been added, the chromosome is then returned to the “FeasibilityCheck” function found at the beginning of Figure 3.9 (the “Check” node), where its status is reevaluated and it is dispatched to the next appropriate procedure. Details of whole ADD procedure are shown in Figure 3.10.
49
Start CountFlights Select a pairing from set of available pairings
No
This pairing not included in current chromosome & can cover an uncovered flight?
Yes Add this pairing to current chromosome Apply Feasibility Check
Chromosome became overcovered?
No
Yes Remove this pairing from current chromosome
Yes
More pairings available to check? No
From available set of pairing, search for a pairing that is not included in current chromosome & can cover an uncovered flight, while covering the least possible number of flights Add this pairing to current chromosome
Goto “Check” Figure 3.10: The ADD Procedure The DROP procedure, detailed in Figure 3.11, is somewhat similar to the ADD procedure. It starts with the “CountFlights” function to determine which flight is covered by the most
50
number of pairings (maxF), and then it seeks to remove a pairing from the solution that covers this flight. This is done repeatedly as long as the chromosome does not become undercovered along this process.
Start CountFlights
Select a pairing from set of available pairings
No
This pairing is included in current chromosome & covers most over-covered flight?
Yes Remove this pairing from current chromosome Apply Feasibility Check
Chromosome became undercovered?
No
Yes Restore this pairing to current chromosome
Yes
More pairings available to check?
No
Goto “Check”
Figure 3.11: The DROP Procedure 3.3.5 Fitness Function Evaluation This step aims to determine the fitness of each chromosome, this step is not just performed once on the initial population, but it is also repeated for all new offspring chromosome. This is simply done by summing the cost of the pairings included in each chromosome; i.e., calculating the value of Equation (2-1). 51
3.3.6 Genetic Operators All the coming steps of applying different operators will be performed in an iterative manner in a way that the population of chromosomes will be constantly changing in search for the optimum problem solution. As previously mentioned, each new iteration is known as a generation. a) Parent Selection The binary tournament method was applied by first selecting two chromosomes randomly from the current population and comparing their fitness functions, the one with lower fitness function value (since the problem is a minimization problem) will be the first parent. Then the same procedure is repeated to select the second parent. b) Crossover Operator Implementation The first crossover operator to be implemented is the one-point crossover where a random crossover site for the parent chromosome is selected as applied in [23] as shown in Figure 3.12 (where the random site turns out to be the third gene) and genes to the right of this site are swapped between the two parent chromosomes creating two new offspring chromosomes. Parent 1:
0
1
0
1
0
1
1
0
1
1
Parent 2:
1
0
0
0
1
1
1
1
0
0
Offspring 1:
0
1
0
0
1
1
1
1
0
0
Offspring 2:
1
0
0
1
0
1
1
0
1
1
Figure 3.12: Example of Implementation of Single-Point Crossover Operation at the Third Gene [18] The second crossover operator to be applied is the fusion crossover operator, in the following manner. Gene values which are identical in both parent chromosomes are just copied to the offspring chromosomes; otherwise genes are copied from the fittest parent chromosome with the probability (p) in Equation (3-1), and from the less fit parent chromosome with probability (1 – p). p=
Fittness value of less fit parent chromosome Sum of fitness values of both parent chromosomes
52
(3-1)
c) Mutation Operator Implementation The first mutation operator to be implemented (suggested in [22]) simply selects randomly either of the two parent chromosomes to apply mutation on, then for each gene in this selected chromosome, mutation is applied to it with a probability equal to the reciprocal of the total number of genes, to generate the new offspring chromosome. While the second mutation operator to be implemented (suggested in [24]) depends on the density of genes equal to one in the fittest chromosome in the population. Mutation here is applied on one of the child chromosomes in which a number of genes (randomly prespecified) are mutated to 1 with probability equal to the percentages of 1s in the fittest chromosomes, and vice versa. It should be noted that, all the generated offspring chromosomes from all operators are added to the current population causing its size to increase; for example, the two generated offspring chromosomes by the one-point crossover operator will be chromosomes number 21 and 22, and so on. As it will be shown later on, the size of the population will be restored to its original size and extra less fit chromosomes will be trimmed away. 3.3.7 Optimum Solution Determination This step is quite straightforward and its aim is obviously to determine the fittest chromosomes in the current population, and to consequently pinpoint the optimum overall problem solution. The fitness function values for all new offspring are calculated first, and the population of the current chromosomes, including the original ones and the new offspring, is ranked in an ascending order according to their fitness function values with the chromosome having least fitness function value in the first position. Then, starting with the fittest chromosome and moving in sequence, a feasibility check (using the previously described “FeasibilityCheck” function) is made for each chromosome. The first chromosome to be feasible would be the best solution for the SPP found in this iteration, i.e. optimum SPP solution of this iteration; whereas the first over-covered chromosome (no under-covered chromosomes exist in any population) would be the best solution for the SCP found in this iteration. The minimum value of the optimum SPP solutions from all iterations would be the global optimum SPP solution, in other words, the solution of the optimization phase of the crew pairing problem.
53
3.3.8 Population Replacement This step is to include the newly generated chromosomes to the population in each iteration; so far the offspring chromosome had been put at the end of the population, but they need to be incorporated with the population itself. As suggested in [25], the “Elitist” strategy ranks the chromosomes in an ascending order according to their fitness values such that the fittest chromosome is first, and then only keeps the first 20 chromosomes for the next generation. In this way, the new offspring generated by the different operators (previously chromosomes with indices exceeding 20) could then fit within the new generation according to their fitness values, and chromosomes with the lowest fitness values would be removed. 3.3.9 Remarks on the Proposed GA a) Feasible Chromosomes
Since having as much feasible chromosomes as possible in a given generation is always desired, wherever the “FeasibilityOperator” function is applied, it is followed by another brief procedure that checks whether the resulted chromosome is feasible or not. If it is indeed infeasible the chromosome is deleted and the step preceding the “Feasibility” operator is repeated for this chromosome. For instance, if a chromosome just generated in the initial population is infeasible, then another chromosome is generated to replace it.
The feasibility operator is applied to all newly generated chromosomes to check their feasibility status and make them less infeasible if needed. If the result is still an infeasible chromosome, then the chromosome is returned to this operator in an attempt to replace this infeasible chromosome with a feasible one; however, this procedure is only repeated for a limited number of times to prevent the algorithm from being stuck in it.
b) Repeated Chromosomes
After the feasibility operator has been applied to an initially generated chromosome, a check is conducted to delete any chromosome resembling any other one already in the population,
with
the
previously
described
“RepeatedChromosome”
and
“DeleteChromosome” functions. In case of a repeated chromosome is found and deleted, it is replaced by a newly generated one.
54
Any newly generated offspring chromosome is checked to determine if is resembles any other chromosome already present in the population using the previously described “RepeatedChromosome” function.
If a repeated chromosome is found after applying any of the two crossover operators, then both chromosomes are deleted using the “DeleteChromosome” function and the process of applying a crossover operator is repeated all over again; however, this procedure is made for a limited number of times only to prevent the algorithm from getting stuck in it.
If a repeated chromosome exists after the second mutation operator, the chromosome is deleted and this mutation operator is started all over again,
If a repeated chromosome exists after the first mutation operator, firstly it is further mutated in attempt to be unique, and then if this turns out to be unsuccessful, the other parent chromosome is selected and the mutation operator is applied to it in the same manner. However, this process is repeated only for a limited number of trials (for both parents), to prevent the algorithm from getting stuck in such a loop.
c) General Remarks
If the new generation contains no feasible pairings at all, i.e. no chromosomes representing a solution to the SPP, the global optimum solution so far is enforced to this new generation as the last element in it; this is in attempt to prevent the population from moving away from the optimal SPP solution.
The code used to implement both algorithms presented in this chapter could be found in APPENDIX A: C CODE. The following chapter presents verification that both of the solution methodologies perform as they are supposed to; and more importantly, validates these proposed methodologies. Those methodologies are implemented on a case-study in a local airline company.
55
CHAPTER 4 TESTING AND IMPLEMENTATION OF THE PROPOSED METHODOLOGY
CHAPTER 4 TESTING AND IMPLEMENTATION OF THE PROPOSED METHODOLOGY 4.1 INTRODUCTION This chapter is divided into two main parts. The first part discusses how these methodologies are validated using a number of test problems, those test problems are of already known solutions and the results from the other methodologies are compared to them. The second part is dedicated to the case-study alone, where the case is thoroughly described and the details of implementing both methodologies on it are shown.
4.2 TEST PROBLEMS 4.2.1 The Pairing Generation Phase Test problems for the pairing generation phase are taken from a number of papers in related literature that provided an adequate example for this phase; usually those test problems are small in size. This is something that would not affect testing the solution methodology, due to the fact that this is just an enumeration phase and does not get harder with larger size; it will just take more time to solve, but the logic would be the same. a) Test Problem 1 This test problem is presented in [23], where a set of nine daily operated flight legs are given, along with their corresponding flight numbers, departure airports and times, and arrival airports and times as shown in Table 4.1, with the given times in the crew base local time. Table 4.1: Input Flight Schedule of Test Problem 1 [23] Flight Number Departure Airport Arrival Airport Departure Time Arrival Time A B 8:00 9:00 1 A D 9:30 10:10 2 D B 10:35 11:35 3 B C 9:20 10:20 4 C B 10:40 11:40 5 B A 12:00 13:20 6 A B 13:40 15:00 7
57
Flight Number Departure Airport Arrival Airport Departure Time Arrival Time B A 15:20 15:50 8 B A 15:30 16:30 9 This test problem is fairly simple, for a single crew-base in airport A; pairings are sought such that, only, the minimum rest between consecutive flights is equal to twenty minutes. This simple requirement can easily be included in the pairing generation algorithm by simply setting the MinSit parameter to 0.333 hr. The resulting valid pairings obtained by the modified pairing generation algorithm are shown in Table 4.2, and when compared with the ones presented in the original paper, both are identical. It should be also noted that all the generated pairings are composed of a single duty and those whose durations (MaxElapse) exceed 8 hours (starting from pairing #14) are not preferred, as stated elsewhere in the original paper. Table 4.2: Pairings Resulting from Modified Algorithm for Test Problem 1 Pairing Number
Flights Sequence
Airports Involved
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17
7–8 7–9 2–3–6 1–6 1–4–5–6 2–3–8 2–3–6–7–8 2–3–9 2–3–6–7–9 1–8 1–4 –5–8 1–6–7–8 1–4–5–6–7–8 1–9 1–4–5–9 1–6–7–9 1–4–5–6–7–9
A–B–A A–B–A A–D–B–A A–B–A A–B–C–B–A A–D–B–A A–D–B–A–B–A A–D–B–A A–D–B–A–B–A A–B–A A–B–C–B–A A–B–A–B–A A–B–C–B–A–B–A A–B–A A–B–C–B–A A–B–A–B–A A–B–C–B–A–B–A
Fly Time (hr) 1.83 2.33 3.00 2.33 4.33 2.17 4.83 2.67 5.33 1.50 3.50 4.17 6.17 2.00 4.00 4.67 6.67
Elapse Time (hr) 2.17 2.83 3.83 5.33 5.33 6.33 6.33 7.00 7.00 7.83 7.83 7.83 7.83 8.50 8.50 8.50 8.50
b) Test Problem 2 This test problem is found in [12], where a set of eight daily operated flight legs are given; their corresponding details are shown in Table 4.3 , in the same manner described earlier. 58
Table 4.3: Input Flight Schedule of Test Problem 2 [12] Flight Number Departure Airport Arrival Airport Departure Time Arrival Time A B 9:30 12:00 1 B A 17:00 19:30 2 B C 12:30 13:00 3 C B 15:30 16:00 4 C A 17:00 19:15 5 A C 8:00 10:15 6 B C 12:30 13:00 7 C B 13:30 14:00 8 From this set of fights valid pairings for a single day are formed, including any possible overnight pairings; originating from any of the two crew-bases, airport A or B, such that:
MaxSit = 8 hours and MinSit = 30 minutes;
MaxElapse = 12 hours
MaxFly for a duty = 8 hours;
MaxDuties = 2 duties per pairing.
No briefing or debriefing times specified.
The resulting valid pairings obtained by the modified pairing generation algorithm are shown in Table 4.4; and when compared with the ones presented in the paper, it should be noted that:
The solution in the original paper [12] generated only 3 overnight duties (numbers 13, 14, and 17 in paper), and did not present a full list of available of all overnight duties possible. Hence, in the modified pairing generation algorithm, the generation of overnight duties was suppressed as there is no point in displaying them, since no comparison could be made. However, if the algorithm was to show all possible overnight pairings, not only will those three pairings be generated, but a lot more.
Other than the overnight pairings, all pairings mentioned in the paper had been identically reproduced by the proposed algorithm.
Pairing number 8 in Table 4.4 is actually an extra pairing that is not included in the original paper although valid.
59
Table 4.4: Pairings Resulting from Modified Algorithm for Test Problem 2 Pairing Number
Flights Sequence
Airports Involved
Fly Time (hr)
Elapse Time (hr)
1
1–2
A–B–A
5.00
10.00
2
6–5
A–C–A
4.50
11.25
3
1–3–5
A–B–C–A
5.25
9.75
4
1–7–5
A–B–C–A
5.25
9.75
5
6–4–2
A–C–B–A
5.25
11.50
6
6–8–2
A–C–B–A
5.25
11.50
7
1–3–4–2
A–B–C–B–A
6.00
10.00
8
1–3–8–2
A–B–C–B–A
6.00
10.00
9
1–7–4–2
A–B–C–B–A
6.00
10.00
10
1–7–8–2
A–B–C–B–A
6.00
10.00
11
3–4
B–C–B
1.00
3.50
12
3–8
B–C–B
1.00
1.50
13
7–4
B–C–B
1.00
3.50
14
7–8
B–C–B
1.00
1.50
c) Test Problem 3 This test problem is in [2], where a set of six daily operated flight legs are given; their corresponding details are shown in Table 4.5. All valid two days pairings originating from specified crew-base(s) are sought for this set of flights, such that:
Only one crew-base is available, that is airport A;
MaxFly for a duty = 8 hours;
MaxDuties = 2 duties per pairing.
OverNightRest = 9 hours;
No briefing or debriefing times specified;
MaxSit = 4 hours and MinSit = 45 minutes ;
MaxElapse = 12 hours (although mentioned in the original paper, yet the resulting pairings they presented do not follow this rule, even if the overnight stay is considered as a duty itself);
Overnight stay could last for more than 24 hours.
60
Table 4.5: Input Flight Schedule of Test Problem 3 [2] Flight Number Departure Airport Arrival Airport Departure Time Arrival Time A B 08:00 13:00 1 B A 15:00 20:00 2 A C 07:00 10:00 3 C A 12:00 1500 4 B C 07:00 10:00 5 C B 11:00 14:00 6 All those conditions could easily be incorporated in the modified pairing generation algorithm by just setting their corresponding parameters values. However, the last two conditions would require a couple of adjustments to the proposed algorithm to allow the overnight stay to be considered as a duty, i.e. the total allowed elapse time would be the total of the 3 duties; and to allow flights to be connected together on consecutive days if the difference between them is more than 24 hours. Those few adjustments have been made in the “SearchForConnectedDuties” function shown in Figure 3.5 in the part responsible for connecting duties on subsequent days. The resulting valid pairings obtained by the modified pairing generation algorithm are shown in Table 4.6. When compared with the ones listed in the paper, there are a number of noteworthy points: 1. The first five pairings obtained in both solutions are identical. 2. The original paper [2] presented a sixth pairing covering the flights (3 – Overnight Stay – 6 – 2) that was not included in the modified pairing generation algorithm solution. The reason for this is the fact that this pairing actually has an Elapse Time of 37.00 hours, which is more than the maximum value allowed in the algorithm. Nonetheless, had the MaxElapse value set in the algorithm to a higher value, this pairing - and another combination for it (3 – 6 – Overnight Stay – 2) - would also result. 3. Pairing number three is the only resulting pairing that could exist every day; in the matter of fact, it had appeared twice in the algorithm results, once for each of the two days. 4. The sixth pairing provided by the algorithm although valid might not be of practical use as both pairings 3 and 4 already do the same function.
61
Table 4.6: Pairings Resulting from Modified Algorithm for Test Problem 3 Pairing Number
Flights Sequence
Airports Involved
Fly Time (hr)
Elapse Time (hr)
1
1 – Overnight Stay – 2
A–B–A
10.00
36.00
2
1 – Overnight Stay – 5 – 4
A–B–C–A
11.00
31.00
3
3–4
A–C–A
6.00
8.00
4
3 – Overnight Stay – 4
A–C–A
6.00
32.00
5
3 – 6 – Overnight Stay – 5 – 4
A–C–B–C–A
12.00
32.00
6
3 – 4 – Overnight Stay – 3 – 4
A–C–A
12.00
32.00
4.2.2 The Optimization Phase As for the test problems for the optimization phase, they are actually the bench-mark instances presented in [21] for solving SPPs. The majority of those instances have been solved to optimality in [21], but were originally contributed by the authors of [7] as real-life problems from different airlines. Those instances are available online as text files from [30]; each instance file contains the total number of flights and pairings in the instance, the cost of each pairing, and the number flights that each pairing covers and their order. Those instances vary in size, which suits the nature of this phase and provides a more accurate measure of validation. Due to the randomness present in the proposed GA, the algorithm has been applied for each instance for a number of 5 trials to allow for a different set of random numbers generated in each trial. The details of those trials are shown in Table 4.7, together with the instance size and its optimal solution (as reported in [21] and [22]); the following notations have been also used in the table:
o: indicates that optimal solution has obtained in this trial;
“nw” in instance name: referes to Northwest Airlines, the name of the airline company from which the data is originally taken [7].
Out of the 30 instances used for testing, 25 of them (83.33%) were solved to optimality at least once; the fact that the solution of an instance could be optimal in a trial and not in another is merely due to the difference in the random numbers generated within each trial. Table 4.8 shows how far the obtained solutions are from the optimal values for the various problems not yielding optimal values; it could be noticed that the maximum deviation is usually from 1.88% to 10.29% only.
62
Table 4.7: Results of the proposed GA on the Test Instances. Instance Name nw41 nw32 nw40 nw08 nw15 nw21 nw22 nw12 nw39 nw20 nw23 nw37 nw26 nw10 nw34 nw43 nw42 nw28 nw25 nw38 nw27 nw24 nw35 nw36 nw29 nw30 nw31 nw19 nw33 nw09
Flights Count 17 19 19 24 31 25 23 27 25 22 19 19 23 24 20 18 23 18 20 23 22 19 23 20 18 26 26 40 23 40
Pairings Optimal Count Solution 197 11,307 294 14,877 404 10,809 434 35,894 467 67,743 577 7,408 619 6,984 626 14,118 677 10,080 685 16,812 711 12,534 770 10,068 771 6,796 853 68,271 899 10,488 1,072 8,904 1,079 7,656 1210 8,298 1217 5,960 1220 5,558 1,355 9,933 1,366 6,314 1,709 7,216 1,783 7,314 2,540 4,274 2,653 3,942 2,662 8,038 2,879 10,898 3,068 6,678 3103 67,760
Best GA solution in each of the 5 trials o 15,060 10,848 o o o o 14,184 o 17,058 o o o 68,331 o o 7,684 o o 5,630 o o o o 4,324 4,108 8,046 11,858 o 71,130
o o o o o 7,436 o 14,384 o 16,965 o o o 68,352 o o o o o 5,630 o o o o 4,324 4,292 o 11,752 6,764 73,894
o o o o o o o 14,318 o 17,058 o o o 69,792 o o o o o 5,692 o o o o 4,430 4,108 o 11,434 6,682 72,116
o 14,886 o 36,322 o o o 14,384 o o o o 6,842 68,352 o o o o o 5,592 o o o o 4,324 o o 11,916 7,536 74,732
o o o o o 7,436 o 14,384 o o o o o 68,337 o o 7,666 o o 5,630 o o o o 4,324 4,108 o o 7,516 73,474
Table 4.8: Range of deviation from optimal values for instances not yielding optimal. Instance Name Flights Count Pairings Count Min Deviation Max Deviation nw12 nw10 nw38 nw29
27 24 23 18
626 853 1220 2,540 63
0.47% 0.09% 0.61% 1.17%
1.88% 2.23% 2.41% 3.65%
Instance Name Flights Count Pairings Count Min Deviation Max Deviation nw09
40
3103
4.97%
10.29%
4.3 REAL-LIFE CASE STUDY A local airline company is considered that has been founded in 2006 in Egypt as a subsidiary company from a much larger airline company; this is to act as its domestic and regional arm, by providing passengers with more frequent flights along various routes at much more convenient timings. The company’s main crew base is at Cairo International Airport, and serves a number of different destinations such as Luxor, Sharm El-sheikh, Aswan, and Hurghada among others. Actual flight data are presented in Table 4.9 for the second Saturday in March 2011; where for each flight the departure airports and times, and arrival airports and times are specified, with all the given times in the crew base local time. To determine the optimal crew pairings for the shown flights, the first step would be, as always, to generate the feasible pairings from this set of flights. In order to be able to apply the proposed pairing generation algorithm, the problem specific parameters need to be determined first. For cockpit crew members, according to Egyptian Civil Aviation Regulations (ECAR), Part 121 (Certification and Operations: Air Carries and Air Taxi Operations), detailed in [31], the following must be satisfied for valid pairings generation:
Briefing period = 1.5 hour and debriefing period = 0.5 hour;
MaxElapse = 10 hours;
MinRest = 12 hours;
OverNightRest = 10 hours;
Those are the conditions enforced by the national regulations, there are other conditions that are enforced by the company itself, such as:
Only one crew-base is available, that is Cairo International Airport;
MaxDuties = 2 duties per pairing;
MaxSit = 2.5 hours and MinSit = 30 minutes;
Overnight stay could last for more than 24 hours and usually not more than two days;
MaxFly is not specified, however, assuming it not to be greater than 7.5 hours would be applicable in this case (and would be also within international limits).
64
Table 4.9: Flights Schedule on Saturday # 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37
Departure Airport Cairo Luxor Cairo Luxor Sharm El-sheikh Cairo Luxor Cairo Aswan Cairo Hurghada Cairo Luxor Cairo Luxor Cairo Aswan Cairo Sharm El-sheikh Cairo Sharm El-sheikh Cairo Budapest Cairo Hurghada Cairo Marsa Alam Cairo Aswan Cairo Hurghada Cairo Sharm El-sheikh Cairo Hurghada Cairo Sharm El-sheikh
Arrival Airport Departure Time Arrival Time Luxor 5:15 6:25 Cairo 6:55 8:05 Luxor 5:45 6:55 Sharm El-sheikh 7:25 8:15 Cairo 8:45 9:45 Luxor 7:45 8:55 Cairo 9:25 10:35 Aswan 8:20 9:45 Cairo 10:15 11:40 Hurghada 10:20 11:25 Cairo 11:55 13:00 Luxor 11:30 12:40 Cairo 13:10 14:20 Luxor 15:20 16:30 Cairo 17:00 18:10 Aswan 11:30 12:55 Cairo 13:25 14:50 Sharm El-sheikh 15:35 16:35 Cairo 17:05 18:05 Sharm El-sheikh 11:45 12:45 Cairo 13:15 14:15 Budapest 12:30 15:00 Cairo 15:45 20:00 Hurghada 15:25 16:30 Cairo 17:00 18:05 Marsa Alam 18:35 19:20 Cairo 19:50 20:35 Aswan 17:20 18:45 Cairo 19:15 20:40 Hurghada 17:55 19:00 Cairo 19:30 20:35 Sharm El-sheikh 19:00 20:00 Cairo 20:30 21:30 Hurghada 20:00 21:05 Cairo 21:35 22:40 Sharm El-sheikh 20:15 21:15 Cairo 21:45 22:45
65
Upon application of the pairing generation algorithm, a total of 52 valid pairings are generated for this particular day. The next step before seeking their optimization is to calculate their corresponding costs according to Equations (2-4) and (2-5). The resulting pairings together with their associated calculated costs are shown in Table 4.10. Table 4.10: Generated Pairings for Saturday # 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32
Flights Sequence 1–2 3–7 6–7 8–9 10 – 11 12 – 13 14 – 15 16 – 17 18 – 19 20 – 21 22 – 23 24 – 25 26 – 27 28 – 29 30 – 31 32 – 33 32 – 37 34 – 35 36 – 37 1–4–5 3–4–5 1 – 2 – 10 – 11 6 – 7 – 12 – 13 6 – 7 – 16 – 17 6 – 7 – 20 – 21 10 – 11 – 14 – 15 10 – 11 – 24 – 25 12 – 13 – 14 – 15 12 – 13 – 18 – 19 12 – 13 – 24 – 25 14 – 15 – 32 – 33 14 – 15 – 32 – 37
Fly Time (hrs) 2.33 2.33 2.33 2.84 2.17 2.33 2.34 2.83 2.00 2.00 6.75 2.16 1.50 2.84 2.16 2.00 2.00 2.17 2.00 3.00 3.00 4.50 4.66 5.16 4.33 4.51 4.33 4.67 4.33 4.49 4.34 4.34
66
Elapse Time (hrs) 4.83 6.83 4.83 5.34 4.67 4.83 4.84 5.33 4.50 4.50 9.50 4.66 4.00 5.34 4.66 4.50 5.75 4.67 4.50 6.50 6.00 9.75 8.58 9.08 8.50 9.84 9.75 8.67 8.58 8.58 8.17 9.42
Cost (hrs) 4.75 4.75 4.75 4.75 4.75 4.75 4.75 4.75 4.75 4.75 6.75 4.75 4.75 4.75 4.75 4.75 4.75 4.75 4.75 4.75 4.75 5.57 4.90 5.19 4.86 5.62 5.57 4.95 4.90 4.90 4.75 5.38
# 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52
Flights Sequence 14 – 15 – 34 – 35 14 – 15 – 36 – 37 16 – 17 – 14 – 15 16 – 17 – 18 – 19 16 – 17 – 24 – 25 18 – 19 – 26 – 27 18 – 19 – 32 – 33 18 – 19 – 32 – 37 18 – 19 – 34 – 35 18 – 19 – 36 – 37 20 – 21 – 14 – 15 20 – 21 – 18 – 19 20 – 21 – 24 – 25 24 – 25 – 26 – 27 24 – 25 – 32 – 33 24 – 25 – 32 – 37 24 – 25 – 34 – 35 24 – 25 – 36 – 37 1 – 4 – 5 – 10 – 11 3 – 4 – 5 – 10 – 11
Fly Time (hrs) 4.51 4.34 5.17 4.83 4.99 3.50 4.00 4.00 4.17 4.00 4.34 4.00 4.16 3.66 4.16 4.16 4.33 4.16 5.17 5.17
Elapse Time (hrs) 9.34 9.42 8.67 8.58 8.58 7.00 7.92 9.17 9.09 9.17 8.42 8.33 8.33 7.16 8.08 9.33 9.25 9.33 9.75 9.25
Cost (hrs) 5.34 5.38 5.17 4.90 4.99 4.75 4.75 5.24 5.19 5.24 4.81 4.76 4.76 4.75 4.75 5.33 5.29 5.33 5.57 5.29
Taking those pairings with their associated costs and applying the proposed GA on them yields two optimum solutions as shown in Table 4.11, along with their associated total objective function value of 64.45 hours. Table 4.11: Proposed GA crew pairing solution for Saturday. # 1 2
Pairings Count 13 13
Pairings Involved 1 4 8 11 14 15 18 19 23 31 44 46 52 1 4 8 11 14 15 18 19 23 31 38 45 52
Objective Function Value 64.45 64.45
The actual current pairing strategy employed in the company uses a total of fifthteen pairings with a total cost of 73.60 hours as shown in Table 4.12. Table 4.12: Company’s crew pairing solution for Saturday. # Pairings Count
1
15
Pairings Involved
Objective Function Value
1 21 3 4 5 28 36 10 11 46 14 15 16 18 19
73.60
67
When comparing the company’s crew pairing problem solution with the one produced by the proposed GA as shown in Figure 4.1, the company’s solution was greater than that produced by the proposed GA by 14.20%. Furthermore, the solution provided by the proposed GA exhibited another advantage, which is offering the company an alternative pairing
Objective Function Value
combination with the same cost, which allows the airline company more flexibility.
80 70 60 50 40 30 20 10 0
73.6 64.45
Proposed GA
Company
Figure 4.1: Different Solution Values for Saturday In the same manner just detailed for a single day (Saturday), pairings are generated every day in the second week of March 2011 and compared with the company’s strategy at the time. The set of flights need to be covered in each day of the second week together with the generated pairings are detailed in APPENDIX B CASE-STUDY RELATED DATA; where the optimal pairings are in bold italic. Objective function values for the everyday crew pairing problems obtained by the proposed GA and the company are presented in Figure 4.2, where it is clear that the proposed GA results are better. Table 4.13 displays a summary of the results obtained; the objective function values obtained for all days by both methods, and more importantly, the difference between those results. It is now even more apparent that the proposed GA is superior to the current company strategies, with difference starting from 7.64% on certain days and reaching up to 26.81% in on other days.
68
Proposed GA
Company
100 50 0
Figure 4.2: Comparison of Objective Function Value Obtained by the Proposed GA and Company for Everyday Crew Pairing Problems Table 4.13: Summary of Everyday Pairing Optimization Results Day Saturday Sunday Monday Tuesday Wednesday Thursday Friday
Proposed GA Objective Function Value 64.45 60.26 50.83 55.66 46.18 55.66 46.81
Company Objective Function Value 73.6 69.21 64.11 59.91 54.61 59.91 59.36
Difference 14.20% 14.85% 26.13% 7.64% 18.25% 7.64% 26.81%
Although the company only generates daily pairings, the results just presented could be further improved if the week is considered as whole, especially since the option of overnight stays is allowed in the company. In fact, dealing with the company on weekly basis would be better in the case of this company, as weekdays flight are not actually repeated the next week, i.e. flights on the second Saturday for instance are not identical to those of the first or third Saturdays; this will also allow the company to work on a planning horizon of one week for the crew pairing problem, which would be more appropriate in case of the non-fixed weekly flights and more suitable to the flying personnel themselves, as well. Consequently, both of the proposed methodologies were applied for all of the week flights as a whole and a total of 342 pairings were generated as detailed in APPENDIX B.8, and an objective function value of 381.34 was obtained by the proposed GA after 10 trials. For the 69
sake of comparison, a value representing the company’s solution to the whole week crew pairing problem was needed; this was simply the summation of the values of daily solutions of all days of this week. As illustrated in Figure 4.3, the solution provided by the proposed GA is better than that of the company as the company’s solution is greater than that of the proposed GA by 15.57%.
Objective Function Value
450 400 350
440.7 381.34
300 250 200 150 100 50 0 Proposed GA
Company
Figure 4.3: Different Case-Study Solutions for the Whole Week Pairing Problem.
70
CHAPTER 5 CONCLUSION AND RECOMMENDATIONS
CHAPTER 5 CONCLUSION AND RECOMMENDATION 5.1 CONCLUSIONS In this thesis, a solution methodology for the airline cockpit crew pairing problem has been presented. The main objective of this methodology is to successfully turn scheduled flights within a certain time horizon into valid pairings and then selecting the pairings having least possible cost while covering all available flights. Hence, a two-phase methodology is developed, that first generates valid pairings through a modified breadth-first-search pairing generation algorithm, and then the second phase seeks to optimize the pairing selection through a proposed GA-based pairing optimization technique. For the first stage, the modified pairing generation algorithm presented accurate results for all cases it is applied to. In particular, when applied on the test problems, all generated pairings are identical to the problem solution; and in a couple of cases, the algorithm is even able to present additional valid solutions. As for the second phase, the results obtained by the proposed GA for the pairing optimization phase are somewhat satisfactory but yet some enhancement is required. The GA is applied on thirty bench-mark instances for five random trials, and the optimal solution was obtained for 83.33% of them at least once, while for those not reaching optimal values, the maximum deviation ranges from 1.88% to 10.29% only as shown in Figure 5.1. 12.00% 10.00% 8.00% 6.00%
Min Deviation
4.00%
Max Deviation
2.00% 0.00% nw12
nw10
nw38
nw29
nw09
Figure 5.1: Range of Deviation from Optimal Values for Instances not Yielding Optimal Results.
72
After the solution methodologies for the two phases of the crew pairing problem are verified to be working as intended and were proven to be capable of providing valid solutions to it, an actual crew pairing problem was solved as a case study in one of Egypt’s local airline companies. Using available flight data from the company, both algorithms are applied to it successfully; when comparing the results obtained by the proposed methodology to the company’s methodology for every single day within a specific week, the proposed methodology was superior. The values obtained by the proposed GA are also confirmed to be optimum as the problems could be solved using the MS Excel Solver Add-in due to their small size; as shown in Figure 5.2, which compares the different solutions values to the optimal problem solution values, the proposed GA always produced an optimal solution, while the company’s solution deviated within 7.64% to 26.81% from the optimal.
150.00% 125.00%
14.20%
14.85%
26.13% 7.64%
100.00%
26.81%
18.25% 7.64%
75.00% 50.00% 25.00% 0.00%
Proposed GA
Company
Figure 5.2: Comparison of the Everyday Crew Pairing Problems Case-Study Results to the Optimal Values Additionally, both methodologies were applied to the whole week as a representative of the planning horizon which is more suitable to the company’s nature and the results in Figure 5.3 were satisfactory and promising. Also due to the problem size, it is solved with an exact method to determine its optimum solution using the Binary Integer Programming Solver available at the Optimization Toolbox in Matlab and the optimal solution is found to be
73
379.80. As shown in Figure 5.3, although the proposed GA solution is not optimum, the difference could be negligible, unlike the solution of the company which deviates 16.03% from the optimum and could not be neglected. 18%
16.03%
16% 14% 12% 10% 8% 6% 4% 2%
0.41%
0% Proposed GA
Company
Figure 5.3: Difference from Optimal Objective Function Value for the Week as a Whole Finally, it could be concluded that the two-phase methodology presented in this study provides satisfactory solutions for the crew pairing problem. In addition, using a GA-based approach for the pairing optimization phase proved to be capable of providing optimal solutions in the majority of cases, although perhaps not as computationally competitive as other methods; furthermore, it has the advantage of giving more than one alternative (if existing) to the optimum solution, which would give airline companies more flexibility in scheduling.
5.2 RECOMMENDATIONS FOR FUTURE WORK There are a number of guidelines for future work: Attempting to reduce the large number of generated pairings produced in the pairing generation phase by perhaps adding a selection algorithm that keeps only pairings that would be more suitable for the optimization step. Reducing the effect of random number generation in the proposed GA, so that the ranges of results produced in each trial are close to one another. Seeking to develop more enhanced GA operators with higher convergence rates to increase the overall speed of the algorithm.
74
Incorporating dynamic scheduling techniques in the proposed GA, as the sudden existence of an additional flight is quite often. Addressing the second stage of the airline crew scheduling, that is the crew rostering problem, as well, as a subsequent step or integrating it with the crew pairing problem.
75
REFERENCES [1] Cynthia Barnhart et al., "Airline Crew Scheduling," in Handbook of Transportation Science, 2nd ed., R. W. Hall, Ed.: Kluwer Academic Publishers, 2003, ch. 14, pp. 517560. [2] Balaji Gopalakrishnan and Ellis L. Johnson, "Airline Crew Scheduling: State-of-theArt," Annals of Operations Research, vol. 140, pp. 305-337, 2005. [3] Air
Transport
Association.
(2009)
Airline
Handbook.
[Online].
http://www.airlines.org/ATAResources/Handbook/Pages/AirlineHandbookChapter4Airl ineEconomics.aspx [4] Massoud Bazargan, "Crew Scheduling," in Airline Operations and Scheduling, 2nd ed.: Ashgate Publishing Limited, 2010, ch. Six, pp. 83-102. [5] Markus P. Theil, "Team-oriented Airline Crew Scheduling and Rostering: Problem Description, Solution Approaches, and Decision Support," Paderborn University, Paderborn, D.Sc. Thesis 2005. [6] Pamela H. Vance, Cynthia Barnhart, Ellis L. Johnson, and George L. Nemhauser, "Airline Crew Scheduling: A New Formulation and Decomposition Algorithm," Operations Research, vol. 45, no. 2, pp. 188-200, Mar. - Apr 1997. [7] Karla L. Hoffman and Manfred Padberg, "Solving Airline Crew Scheduling Problems by Branch-and-Cut," Management Science, vol. 39, no. 6, pp. 657-682, June 1993. [8] Nadia Souai and Jacques Teghem, "Genetic algorithm based approach for the integrated airline crew-pairing and rostering problem," European Journal of Operational Research, vol. 199, no. 3, pp. 674–683, December 2009. [9] R. S. Garfinkel and G. L. Nemhauser, "The Set-Partitioning Problem: Set Covering with Equality Constraints," Operations Research, vol. 17, no. 5, pp. 848-856, Sep. - Oct. 1969. [10] Ralph Borndörfer, "Aspects of Set Packing, Partitioning, and Covering," Berlin University, Beriln, D.Sc. Thesis 1998.
76
[11] Karla L. Hoffman and Manfred Padberg. (2000) "Set Covering, Packing and Partitioning Problems", Encyclopedia of Optimization, [Accessed at 10-7-2011]. [Online]. http://iris.gmu.edu/~khoffman/papers/set_covering.html [12] Douglas Potter, "An Implementation of a Constraint Branching Algorithm for Optimally Solving Airline Crew Pairing Problems," Department of Mathematical Sciences, Chalmers University of Technology and Gothenburg University, Göteborg, Sweden, M.Sc. Thesis 2008. [13] Cynthia Barnhart, Ellis L. Johnson, George L. Nemhauser, Martin W. P. Savelsbergh, and Pamela H. Vance, "Branch-and-Price: Column Generation for Solving Huge Integer Programs," Operations Research, vol. 46, no. 3, pp. 316-329, May - June 1998. [14] Pamela H. Vance et al., "A Heuristic Branch-and-Price Approach for the Airline Crew Pairing Problem," Auburn University, Working Paper 1997. [15] R. G. Shenoi, "Solving the Long Haul Crew Pairing Problem," Department of Civil and Environmental Engineering, Massachusetts Institute of Technology, Massachusetts, M.Sc. Thesis February 1994. [16] Diana C. Flórez, Jose L. Walteros, Miguel A. Vargas, Andrés L. Medaglia, and Nubia Velasco, "A Mathematical Programming Approach to Airline Crew Pairing Optimization," Department of Industrial Engineering, University of Los Andes, Bogotá, Colombia,
Working
Paper
2009.
[Online].
http://www.agifors.org/award/submissions2009/DianaFlorez_paper.pdf [17] Shangyao Yan and Jei-Chi Chang, "Airline Cockpit Crew Scheduling," European Journal of Operational Research, vol. 136, no. 3, pp. 501-511, Feburary 2002. [18] Singiresu S. Rao, "Modern Methods of Optimization," in Engineering Optimization, Theory and Practice, 4th ed.: John Wiley & Sons, Inc., 2009, ch. 13, pp. 693 - 736. [19] P. C. Chu and J. E. Beasley, "A Genetic Algorithm for the Set Partitioning Problem," The Management School, Imperial College, London, Technical Report 1995. [20] J. E. Beasley and P. C. Chu, "A Genetic Algorithm for the Set Covering Problem,"
77
European Journal of Operational Research, vol. 94, no. 2, pp. 392-404, October 1996. [21] P. C. Chu and J. E. Beasley, "Constraint Handling in Genetic Algorithms: The Set Partitioning Problem," Journal of Heuristics, vol. 4, no. 4, pp. 323-357, 1998. [22] David Levine, "Application of a Hybrid Genetic Algorithm to Airline Crew Scheduling," Computers & Operations Research, vol. 23, no. 6, pp. 547 - 558, 1996. [23] Chilukuri K. Mohan and H. Timucin Ozdemir, "Flight Graph based Gentic Algorithm for Crew Scheduling in Airlines," Information Sciences, vol. 133, pp. 165 - 173, 2001. [24] Harry Kornilakis and Panagiotis Stamatopoulos, "Crew Pairing Optimization with Genetic Algorithms," in Lecture Notes in Artificial Intelligence (LNAI), I. Vlahavas and C. Spyropoulos, Eds.: Springer-Verlag Berlin, Heidelberg, 2002, vol. 2308, pp. 109 120. [25] Bahadır Zeren and İbrahim Özkol, "An Improved Genetic Algorithm for Crew Pairing Optimization," Journal of Intelligent Learning Systems and Applications, vol. 4, pp. 7080, February 2012. [26] Broderick Crawford, Carlos Castro, and Eric Monfroy, "A Constructive Hybrid Algorithm for Crew Pairing Optimization," in Lecture Notes in Artificial Intelligence (LNAI), J. Euzenat and J. Domingue, Eds.: Springer-Verlag Berlin Heidelberg, 2006, vol. 4183, pp. 45 - 55. [27] Guang-Feng Deng and Woo-Tsong Lin, "Ant Colony Optimization-based Algorithm for Airline Crew Scheduling Problem," Expert Systems with Applications, vol. 38, no. 5, pp. 5787 – 5793, May 2011. [28] Uğur Özdemir, "Methodology for Crew-Pairing Problem in Airline Crew Scheduling," Boğaziçi University, M.Sc. Thesis 2009. [29] Matias Sevel Rasmussen, Richard M. Lusby, David M. Ryan, and Jesper Larsen, "A Subsequence Generation Approach for the Airline Crew Pairing Problem," Working Paper
2011.
http://www.agifors.org/award/submissions2011/MatiasRasmussen.pdf
78
[Online].
[30] J.
E.
Beasley.
OR-Library
-
Set
Partitioning.
[Online].
http://people.brunel.ac.uk/~mastjjb/jeb/orlib/sppinfo.html [31] ECAR121. (2010, July) SUBPART Q: The Avoidance of Excessive Fatigue in Aircrew. [Online].
http://www.civilaviation.gov.eg/HTML/WEB-
ARABIC/LOWS_REGULATIONS/ECAR_JULY,2010/Part121/Part121Q.htm#Part121 Q_470
79
APPENDIX A C CODE A.1 PAIRING GENERATION ALGORITHM CODE /* This algorithm aims to generate all possible pairings from a given set of flights. */ /*to include the input/output header in the program*/ #include
contents
of
the
standard
#include /* to include random number generation function*/ # define MaxDuties 2
/* The following parameters are set to some default values here. But could be changed later or user-defined*/ float float float float float float float
MaxSit = 2.5; MinSit = 0.5; MaxElapse = 10; MaxFly = 7.5; Briefing = 1.5, DeBriefing = 0.5; MinRest = 12; OverNightRest = 10;
int f, F, d, D, c, C, p, P; float Elapse, Fly, Duration = 0 int FlightNumber[10000]; float FlightEndTime[100000], FlightStartTime[100000]; float DutyEndTime[1000000], DutyStartTime[1000000], DutyFly[1000000];
DutyElapse[1000000],
float ConnectedDutiesEndTime[100000], ConnectedDutiesStartTime[100000], ConnectedDutiesElapse[100000], ConnectedDutiesFly[100000]; float PairingEndTime[100000], PairingElapse[100000], PairingFly[100000];
PairingStartTime[100000],
int FlightOrigin[100000], FlightDestination[100000], DutyOrigin[100000], DutyDestination[100000], PairingOrigin[100000], PairingDestination[100000], ConnectedDutiesOrigin[100000], ConnectedDutiesDestination[100000]; int FlightDay[100000], DutyStartDay[100000], DutyEndDay[100000], ConnectedDutiesStartDay[100000], ConnectedDutiesEndDay[100000], PairingStartDay[100000], PairingEndDay[100000]; int CurrentDuty = 0; int Duties[1000000][200]; int DutyKeep[100000], DutyContinue[100000]; int DutyFlightsCount[100000]; int NumberofDuties; int RepeatedCount = 0; float DutyCost[1000000]; int ConnectedDuties[100000][200]; int ConnectedDutiesDuteisCount[100000]; int ConnectedDutiesFlightsCount[100000]; float Day1Fly[100000]; float ConnectedDutiesCost[1000000]; int Pairings[100000][200];
80
int PairingDutiesCount[100000]; int PairingFlightsCount[100000]; float PairingCost[1000000]; int CrewBase[20], CrewBases; void Initialize(); void InitializeConnectedDuties(); void ReadInput(); float DurationCalculation(float S, float E); void ValidDuty(int i); void AddtoDuties(int i, int x); void SearchForDuties(int y); void SearchForOvernightDuties(int y); void ShowDuties(int i); void ShowConnectedDuties(int i); void SearchForConnectedDuties(int y); void AddtoConnectedDuties(int i, int x, int z); void DeleteRepeated(int y); void AddtoPairings(int y, int x); void ShowPairings(int i); void ValidPairing (int i, int x); void PrintOutput(int i, int y, int x, int z); void PrintInput(); int main(void)/*function main begins program execution*/ { d = 0; Initialize(); Start: printf("Please enter number of available flights:\t"), scanf("%d", &F); if (F > 100000){ printf("Sorry! program can't currently work with more than 100000 flights. Please enter another more suitable number.\n"); goto Start; }
/*Specifying crew bases details as input*/ int j = 0; printf("Please enter the total number of crewbases present:\t"), scanf("%d", &CrewBases); printf("Please enter the number of those %d crewbases:\t", CrewBases); for (j = 0; j < CrewBases; j++){ scanf("%d", &CrewBase[j]); } ReadInput();
/*Forming VALID single-legged duties from all flights by selecting all possible 1-element subsets of flight legs*/ for (f = 0; f < F; f++){ CurrentDuty = FlightNumber[f]-1; Fly = DurationCalculation(FlightStartTime[f], FlightEndTime[f]); Elapse = Briefing + Fly; ValidDuty(CurrentDuty); if (DutyKeep[CurrentDuty] == 1){ DutyKeep[d] = 1, DutyContinue[d] = DutyContinue[CurrentDuty]; DutyStartTime[d] = FlightStartTime[f] – Briefing; DutyEndTime[d] = FlightEndTime[f]; DutyOrigin[d] = FlightOrigin[f]; DutyDestination[d] = FlightDestination[f]; DutyElapse[d] = Elapse, DutyFly[d] = Fly; DutyFlightsCount[d] = 1, DutyStartDay[d] = FlightDay[f];
81
if (DutyStartTime[d] < 0){ DutyStartTime[d] = DutyStartTime[d]+ 24; if (DutyStartDay[d] == 1){ DutyStartDay[d] = 7; } else{ DutyStartDay[d] =DutyStartDay[d] - 1; } } if (DutyStartTime[d] > DutyEndTime[d]){ DutyEndDay[d] = DutyStartDay[d]+ 1; } else{ DutyEndDay[d] = DutyStartDay[d]; } AddtoDuties(d, f); d = d + 1, D = d; } }
/*Seeking to add more flight legs to all available duties to form new valid duties (This process is repeated until no more new duties could be created)*/ for (d = 0; d < D; d++){ CurrentDuty = d; if(DutyStartTime[d] < DutyEndTime[d]){ SearchForDuties(CurrentDuty); } } NumberofDuties = D;
/*Seeking non-valid duty that pass mid-night but could however help in pairing generation.*/ for (d = 0; d < NumberofDuties; d++){ CurrentDuty = d; if(DutyStartTime[d] > DutyEndTime[d]){ SearchForOvernightDuties(CurrentDuty); } }
/*Adding De-briefing periods to all generated duties*/ for (d=0 ; d < NumberofDuties; d++){ DutyElapse[d] = DutyElapse[d] + DeBriefing; if ( (24 - DutyEndTime[d]) (DutyElapse[d]*4/7)){ if ( 3 > DutyFly[d]){ DutyCost[d] = 3;
82
} else{ DutyCost[d] = DutyFly[d]; } } else{ if ((DutyElapse[d]*4/7) > DutyFly[d]){ DutyCost[d] = (DutyElapse[d]*4/7); } else { DutyCost[d] = DutyFly[d]; } } }
/*Equating this array with the "duties" array*/ InitializeConnectedDuties(); C = NumberofDuties;
/*Search for duties to connect*/ for (c = 0; c < C; c++){ if (ConnectedDutiesDuteisCount[c] == MaxDuties){ break; } CurrentDuty = c; SearchForConnectedDuties(CurrentDuty); }
/*Delete Repeated Connected Duties*/ for (c = 0; c < C; c++){ CurrentDuty = c; DeleteRepeated(CurrentDuty); }
/*Checks which pairing*/
of
the
connected
duties
could
be
considered
for (j = 0; j < CrewBases; j++){ for (c=0 ; c < C; c++){ ValidPairing(c, CrewBase[j]); } } printf("\n\nValid Pairing are:\n"); for (p=0 ; p < P; p++){ ShowPairings(p); } Results: PrintOutput(d, D, p, P); PrintInput(); getchar(); getchar(); return 0; /* indicate that program ended successfully. */ } /* end function main */ void Initialize(){ int i,j; for (i = 0; i < 100000; i++){ for (j = 0; j < 200; j++){ Duties[i][j] = 0;
83
as
a
Pairings[i][j] = 0; } } } void ReadInput(){ FILE *cfPtr; if (( cfPtr = fopen("Casestudy.txt", "r")) == NULL ){ printf( "File could not be opened\n" ); } else{ printf("#\t O\t D\t Start Time\t End Time\t Day\n"); for (f=0; f < F; f++){ fscanf( cfPtr, "%d%d%d%f%f%d", &FlightNumber[f], &FlightOrigin[f], &FlightDestination[f], &FlightStartTime[f], &FlightEndTime[f], &FlightDay[f]); printf("%d\t %d\t %d\t %f\t %f\t %d\n", FlightNumber[f], FlightOrigin[f], FlightDestination[f], FlightStartTime[f], FlightEndTime[f], FlightDay[f]); } fclose(cfPtr); printf("-----------------------------------------------------------\n"); } } float DurationCalculation(float S, float E){ if(S > E){ Duration =(24-S)+(E-0); } else{ Duration = E - S; } return Duration; } void AddtoDuties(i, x){ if(DutyFlightsCount[i] == 1){ Duties[i][0] = x + 1; } else{ int j; for ( j = 0; j < DutyFlightsCount[i]-1; j++){ Duties[i][j] = Duties[x][j]; } Duties[i][DutyFlightsCount[i]-1] = f + 1; } } void ValidDuty(i){ if (Elapse = MinSit && (FlightStartTime[f] - DutyEndTime[y]) DutyEndTime[D]){ DutyEndDay[D] = DutyStartDay[D]+ 1; } else{ DutyEndDay[D] = DutyStartDay[D]; } DutyFlightsCount[D] = DutyFlightsCount[y] + 1; AddtoDuties(D, y); D = D + 1; } } } } } } } void SearchForOvernightDuties(y){ if (DutyContinue[y] == 1){/*Continue = 1*/ for ( f = 0; f < F; f++){ /*Select a flight*/ if ((FlightDay[f] - DutyStartDay[y]) == 1){ if(DutyDestination[y] == FlightOrigin[f]){ if( (FlightStartTime[f] - DutyEndTime[y]) >= MinSit && (FlightStartTime[f] - DutyEndTime[y]) = MinRest){ Fly = ConnectedDutiesFly[y] + ConnectedDutiesFly[c]; Elapse = ConnectedDutiesElapse[y] + (ConnectedDutiesStartTime[c] ConnectedDutiesEndTime[y]) + ConnectedDutiesElapse[c]; If ( Fly 1){ count = count + 1; Chromosomes[nn][r] = 0; if (count > P){ /*Prevent it from getting stuck in this loop break; } else{ goto RandomizeP; } } } }/*All other genes are already set to zero, so no need to re-set
them*/ else{ goto RandomizeP; }
96
/*The following generated*/
is
to
check
if
there
are
identical
chromosomes
RepeatedChromsome(nn); if (CommonGenes == P){ CommonGenes = 0; DeleteChromosome(nn, p); goto RandomizeF; } EndFLoop: FitnessFunctionEvaluation(n); } } void FitnessFunctionEvaluation(int y){ float z = 0; for(p=0; p < P; p++){ z = z + PairingCost[p]* Chromosomes[y][p]; } FitnessFunction[y] = z, z = 0; } void ShowChromosomes(int y){ printf("\nChromosome (%d) contains the pairings: ", y+1); for ( p = 0; p < P; p++ ){ if (Chromosomes[y][p] == 1){ printf("%d ", p+1); } } printf("\t\twith Fitness Function = %.2f", FitnessFunction[y]); ShowFeasibilityCheckResults(y); } void SortChromosomes(int y, int z){
/*y represents first chromosome, while z represents the second one.*/ int DummyChromosome[P]; float Dummy; if (FitnessFunction[y] > FitnessFunction[z]){
/*Swap Fitness Functions*/ Dummy = FitnessFunction[y]; FitnessFunction[y] = FitnessFunction[z]; FitnessFunction[z] = Dummy;
/*Swap Chromosomes*/ for(p=0; p < P; p++){ DummyChromosome[p] = Chromosomes[y][p]; Chromosomes[y][p] = Chromosomes[z][p]; Chromosomes[z][p] = DummyChromosome[p]; } } } void ParentSelection(){ int t = 0; printf("\n\nSelected Parents are:\n"); for (t = 0; t < 2; t++){ int r1, r2; /*Random Numbers generated representing choromosomes
selected in each tournament*/ r1 = 0 + rand()%(N); r2 = 0 + rand()%(N);
/*Seeing which one has better fitness*/ if (FitnessFunction[r1] ParentFitnessFunction[1]){
/*Swap Fitness Functions*/ Dummy = ParentFitnessFunction[0]; ParentFitnessFunction[0] = ParentFitnessFunction[1]; ParentFitnessFunction[1] = Dummy;
/*Swap Chromosomes*/ for(p=0; p < P; p++){ DummyChromosome[p] = ParentChromosomes[0][p]; ParentChromosomes[0][p] = ParentChromosomes[1][p]; ParentChromosomes[1][p] = DummyChromosome[p]; } } for (t = 0; t < 2; t++){ printf("\nParent Chromosome (%d): ", t+1); for(p=0; p < P; p++){ if (ParentChromosomes[t][p] == 1){ printf("%d ", p+1); } } printf("\t\twith Fitness Function = %.2f", ParentFitnessFunction[t]); } printf("\n"); } void OnePointCrossover(){
/*Randomly selected crossover point*/ int r, t, fcount = 0, RepeatedCount = 0; Crossover:
/*This is to prevent being stuck in the check repeated loop.*/ if( RepeatedCount >= P){ goto EndOnePointCrossover; }
/*Apply Crossover Operator*/ for ( p = 0; p < r; p++){ Chromosomes[N+0][p] = ParentChromosomes[0][p]; Chromosomes[N+1][p] = ParentChromosomes[1][p]; } for ( p = r; p < P; p++){ Chromosomes[N+0][p] = ParentChromosomes[1][p]; Chromosomes[N+1][p] = ParentChromosomes[0][p]; }
/*Apply Feasibility Operator*/ N = N + 2; for(t=0; t < 2; t++){ FeasibilityOperator(N-2+t); }
/*Check if repeated*/ 98
for (t = 0; t < 2; t++){ RepeatedChromsome(N-2+t); if (CommonGenes == P){ CommonGenes = 0; RepeatedCount = RepeatedCount + 1; N = N - 2; goto Crossover; } } EndOnePointCrossover: if( RepeatedCount >= P){ printf("\nNo new chromosomes could have been found CROSSOVER Operator, after applying it %d times.", P); }
by
the
One-Point
void FusionCrossover(){
/*Determining the associated Probabilities*/ double probability; /*1st Checks which parent is more fit*/ probability = ParentFitnessFunction[1]/((float)ParentFitnessFunction[0]+ (float)ParentFitnessFunction[1]); int fcount = 0, RepeatedCount = 0; Crossover:
/*This is to prevent being stuck in the check repeated loop.*/ if(RepeatedCount >= P){ goto EndFusionCrossover; }
/*Checking each gene*/ for (p = 0; p < P; p++){ if( ParentChromosomes[0][p] == ParentChromosomes[1][p]){ Chromosomes[N][p] = ParentChromosomes[0][p]; } else{ int r; r = (0 + rand()%(100)); if ( r* 0.01 = P){ printf("\nNo new chromosomes could have been found CROSSOVER Operator, after applying it %d times.", P) ; } }
by
the
Fusion
void LevineMutation(){ int rpar, r, RepeatedCount, parcount = 0; double probability; rpar = rand()%(2); /*random number generated representing which parent
is chosen*/ probability = 1/(float)P; /*random number generated representing which
parent is chosen*/ int fcount = 0; Mutation: /*This is to prevent being stuck in the check repeated loop*/ if(RepeatedCount >= P){ /*the following allows checking both parents*/ if (parcount == 0){ parcount = 1; if (rpar == 0){ rpar = 1; } else{ rpar = 0; } } } for (p = 0; p < P; p++){ r = (0 + rand()%(100)); if (r* 0.01 = P){ /*prevents getting stuck in this loop*/ goto EndStaticMutation; } int rn = 20 + rand()%(N-20); /*Selects a random offspring on which
mutation will be applied*/ /*Duplicate original chromosome to new offspring.*/ for (p = 0; p < P; p++){ if (Chromosomes[rn][p] == 1){ Chromosomes[N][p] = 1; } else{ Chromosomes[N][p] = 0; } } float probability = Ones/(float)P; /*Determines probability of mutation
to 1*/ int rg = 1 + rand()%(P-1); /*Determines randomly number of genes to be mutated*/ /*Applying Static Mutation Operator*/ int t = 0; /*t is counter*/ for (t = 0; t < rg; t++){ int r = rand()%(P); /*select a random pairing*/ int mr = rand()%100; /*random mutation probability if ( (0.01*mr) = P){ printf("\nNo new chromosomes could have been found by the Static MUTATION Operator, after applying it %d times.", P); } } void FeasibilityCheck(int y){ int ChromosomeFlights[N][20000]; /*Array containing flights covered by
each chromosome (rows)*/ int
ChromosomeFlightsNum[N];
/*Array
containing
covered by each chromosome.*/ int l, i, j = 0; /*counters*/ ChromosomeUnderCovered[y] = 0; ChromosomeOverCovered[y] = 0;
/*Adding pairing flights to chromosome flights.*/ for (l = 0; l < P; l++){ if (Chromosomes[y][l] == 1){ for (i = 0; i < PairingFlightsNum[l]; i++){ ChromosomeFlights[y][j] = Pairingflights[l][i]; j = j + 1; } } } ChromosomeFlightsNum[y] = j, j = 0;
/*Checks if chromosome flights are under-covered*/ int z = 0; j = 1; CheckFlight: if (j > F){ goto EndChecking; } for (i = 0; i < ChromosomeFlightsNum[y]; i++){ if(ChromosomeFlights[y][i] == j){ z = z +1; j = j + 1; goto CheckFlight; } } EndChecking: ChromosomeCoveredFlightCount[y] = z, z = 0; if (ChromosomeCoveredFlightCount[y] != F){ ChromosomeUnderCovered[y] = 1; }
/*Checks if chromosome flights are overcovered*/ ChromsomeRepeatedFlights[y] = 0; for (i = 0; i < ChromosomeFlightsNum[y]; i++){
102
number
of
flights
for (j = 0; j < i; j++){ if (ChromosomeFlights[y][i] == ChromosomeFlights[y][j]){ ChromsomeRepeatedFlights[y] = ChromsomeRepeatedFlights[y] + 1; } } } if (ChromsomeRepeatedFlights[y] > 0){ ChromosomeOverCovered[y] = 1; } } void ShowFeasibilityCheckResults(int z){ FeasibilityCheck(z); printf("\tCovering Status:"); if (ChromosomeUnderCovered[z] == 1){ printf(" [U]"); } else{ printf(" -"); } if (ChromosomeOverCovered[z] == 1){ printf("\t[O]"); } else{ printf("\t -"); } } void CountFlights(int m){ int s; min = F; /*Minimum number of flights covered*/ max = 0; /*Maximum number of flights covered*/ for (f = 0; f < F; f++){ FlightSum[f] = 0; for (s = 0; s < P; s++){ if (Chromosomes[m][s] == 1){ FlightSum[f] = FlightSum[f] + Flights[f][s]; } } if (FlightSum[f] < min){ min = FlightSum[f]; minF = f; } if (FlightSum[f] > max){ max = FlightSum[f]; maxF = f; } } } void FeasibilityOperator(int c){ /*c: stands for (n)*/ int r, PairingFlightCount; Check:/*Deals with each chromosome seperately*/ FeasibilityCheck(c); if (ChromosomeUnderCovered[c] == 1){ goto ADD; } else if (ChromosomeOverCovered[c] == 1){ goto DROP; }
103
else{ goto EndOperator; } ADD:/*Adds pairings
to
chromomsomes
to
make
at
least
all
flights
chromosomes
without
covered*/ PairingFlightCount = F, r = 0; CountFlights(c);
/*First Checks if columns overcovering at all.*/
could
be
added
to
for (p = 0; p < P; p++){ if (Chromosomes[c][p] == 0 && Flights[minF][p] == 1){ Chromosomes[c][p] = 1; FeasibilityCheck(c);
/*The following is to check if no more over-covering occurs*/ if (ChromosomeOverCovered[c] == 1){ Chromosomes[c][p] = 0; } else{ goto Check; } } }
/*Checks if columns could be added with ascending over-covering*/ for (p = 0; p < P; p++){ if (Chromosomes[c][p] == 0 && Flights[minF][p] == 1){ if (PairingFlightsNum[p] < PairingFlightCount){ PairingFlightCount = PairingFlightsNum[p]; r = p; } } } Chromosomes[c][r] = 1; goto Check; DROP: /* Removes additional pairing within chromosomes
that
makes
flights over-covered*/ CountFlights(c); for (p = 0; p < P; p++){ if (Chromosomes[c][p] == 1 && Flights[maxF][p] == 1){ Chromosomes[c][p] = 0; FeasibilityCheck(c);
/*The following is to check that removing pairings doesn't return the problem to be under-covered*/ if (ChromosomeUnderCovered[c] == 1){ Chromosomes[c][p] = 1; } else{ goto Check; } } } EndOperator: FeasibilityCheck(c); FitnessFunctionEvaluation(c); } void DetermineSolution(){ int SPPOptimumChromosome[P], SCPOptimumChromosome[P]; float SPPFitness, SCPFitness; SPP = 0;
/*Determines the current iteration optimal solution*/ 104
/*Checks first for current iteration SPP Optimum*/ for (n = 0; n < N; n++){ if (ChromosomeUnderCovered[n] == 0 && ChromosomeOverCovered[n] == 0){ SPP = 1; printf("\nIteration Optimum Chromsome (SPP) is # %d containing pairings: ", n+1); for ( p = 0; p < P; p++ ){ SPPOptimumChromosome[p] = Chromosomes[n][p]; if (SPPOptimumChromosome[p] == 1){ printf("%d ", p+1); } } printf("\t\twith objective funtion: %.2f", FitnessFunction[n]); SPPFitness = FitnessFunction[n]; ShowFeasibilityCheckResults(n); break; } }
/*Then checks for current iteration SCP Optimum*/ for (n = 0; n < N; n++){ if (ChromosomeUnderCovered[n] == 0 && ChromosomeOverCovered[n] == 1){ printf("\nIteration Optimum Chromsome (SCP) is # %d containing pairings: ", n+1); for ( p = 0; p < P; p++ ){ SCPOptimumChromosome[p] = Chromosomes[n][p]; if (SCPOptimumChromosome[p] == 1){ printf("%d ", p+1); } } printf("\t\twith objective funtion: %.2f", FitnessFunction[n]); ShowFeasibilityCheckResults(n); break; } }
/*Determines the global solution*/ float z = 0; for(p = 0; p < P; p++){ z = z + PairingCost[p]* OptimumChromosome[p]; } OptimumFitnessFunction = z, z = 0; printf("\n\nGlobal solution so far is: "); if (SPP == 1){ if ( SPPFitness < OptimumFitnessFunction || OptimumFitnessFunction == 0){ for ( p = 0; p < P; p++ ){ OptimumChromosome[p] = SPPOptimumChromosome[p]; OptimumFitnessFunction = SPPFitness; } } } else{ printf("!No new SPP solution in current population!"); }
/*Display final results*/ printf("\nIteration Optimum Chromsome (SPP) contains pairings: "); for ( p = 0; p < P; p++ ){ if (OptimumChromosome[p] == 1){ printf("%d ", p+1); } } printf("\t\twith objective funtion: %.2f", OptimumFitnessFunction); }
105
void PrintOutput(){ FILE *cfPtr; if (( cfPtr = fopen("Final Generation - sppnw09.txt", "w")) == NULL ){ printf( "File could not be opened\n" ); } else{ /*Displaying last generation of chromosomes*/ int PairingCount, n = 0; for(n=0; n < 20; n++){ PairingCount = 0; for ( p = 0; p < P; p++ ){ /*first counts number of pairings*/ if (Chromosomes[n][p] == 1){ PairingCount = PairingCount + 1; } } fprintf(cfPtr,"%d %d", n+1, PairingCount); for ( p = 0; p < P; p++ ){ /*second shows them*/ if (Chromosomes[n][p] == 1){ fprintf(cfPtr,"% d", p+1); } } fprintf(cfPtr,"\t%.2f\n", FitnessFunction[n]); } } }
106
APPENDIX B CASE-STUDY RELATED DATA B.1 ALL INPUT FLIGHTS FOR SECOND WEEK IN MARCH 2011 #
Departure Airport
Arrival Airport
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40
Cairo Luxor Cairo Luxor Sharm Elsheikh Cairo Luxor Cairo Aswan Cairo Hurghada Cairo Luxor Cairo Luxor Cairo Aswan Cairo Sharm Elsheikh Cairo Sharm Elsheikh Cairo Budapest Cairo Hurghada Cairo Marsa Alam Cairo Aswan Cairo Hurghada Cairo Sharm Elsheikh Cairo Hurghada Cairo Sharm Elsheikh Cairo Luxor Cairo
Luxor Cairo Luxor Sharm Elsheikh Cairo Luxor Cairo Aswan Cairo Hurghada Cairo Luxor Cairo Luxor Cairo Aswan Cairo Sharm Elsheikh Cairo Sharm Elsheikh Cairo Budapest Cairo Hurghada Cairo Marsa Alam Cairo Aswan Cairo Hurghada Cairo Sharm Elsheikh Cairo Hurghada Cairo Sharm Elsheikh Cairo Luxor Cairo Sharm Elsheikh 107
Departure Time 5:15 6:55 5:45 7:25 8:45 7:45 9:25 8:20 10:15 10:20 11:55 11:30 13:10 15:20 17:00 11:30 13:25 15:35 17:05 11:45 13:15 12:30 15:45 15:25 17:00 18:35 19:50 17:20 19:15 17:55 19:30 19:00 20:30 20:00 21:35 20:15 21:45 7:45 9:25 8:00
Arrival Time 6:25 8:05 6:55 8:15 9:45 8:55 10:35 9:45 11:40 11:25 13:00 12:40 14:20 16:30 18:10 12:55 14:50 16:35 18:05 12:45 14:15 15:00 20:00 16:30 18:05 19:20 20:35 18:45 20:40 19:00 20:35 20:00 21:30 21:05 22:40 21:15 22:45 8:55 10:35 9:00
Departure Day Saturday Saturday Saturday Saturday Saturday Saturday Saturday Saturday Saturday Saturday Saturday Saturday Saturday Saturday Saturday Saturday Saturday Saturday Saturday Saturday Saturday Saturday Saturday Saturday Saturday Saturday Saturday Saturday Saturday Saturday Saturday Saturday Saturday Saturday Saturday Saturday Saturday Sunday Sunday Sunday
#
Departure Airport
Arrival Airport
41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84
Sharm Elsheikh Cairo Sharm Elsheikh Cairo Hurghada Cairo Luxor Cairo Aswan Cairo Sharm Elsheikh Cairo Budapest Cairo Malta Cairo Luxor Cairo Marsa Alam Cairo Hurghada Cairo Aswan Cairo Luxor Cairo Luxor Cairo Hurghada Cairo Sharm Elsheikh Cairo Luxor Cairo Aswan Cairo Hurghada Cairo Luxor Cairo Luxor Cairo Aswan Cairo
Cairo Sharm Elsheikh Cairo Hurghada Cairo Luxor Cairo Aswan Cairo Sharm Elsheikh Cairo Budapest Cairo Malta Cairo Luxor Cairo Marsa Alam Cairo Hurghada Cairo Aswan Cairo Luxor Cairo Luxor Cairo Hurghada Cairo Sharm Elsheikh Cairo Luxor Cairo Aswan Cairo Hurghada Cairo Luxor Cairo Luxor Cairo Aswan Cairo Sharm Elsheikh 108
Departure Time 9:30 11:45 13:15 10:20 11:55 11:30 13:10 11:30 13:25 15:35 17:05 12:30 15:45 13:15 16:00 13:20 15:00 15:25 16:40 17:55 19:30 17:20 19:15 17:35 19:15 20:00 21:40 20:00 21:35 20:15 21:45 7:45 9:25 8:20 10:15 10:20 11:55 11:30 13:10 15:20 17:00 11:30 13:25 15:35
Arrival Time 10:30 12:45 14:15 11:25 13:00 12:40 14:20 12:55 14:50 16:35 18:05 15:00 20:00 15:15 19.30 14:30 16:10 16:10 17:25 19:00 20:35 18:45 20:40 18:45 20:25 21:10 22:50 21:05 22:40 21:15 22:45 8:55 10:35 9:45 11:40 11:25 13:00 12:40 14:20 16:30 18:10 12:55 14:50 16:35
Departure Day Sunday Sunday Sunday Sunday Sunday Sunday Sunday Sunday Sunday Sunday Sunday Sunday Sunday Sunday Sunday Sunday Sunday Sunday Sunday Sunday Sunday Sunday Sunday Sunday Sunday Sunday Sunday Sunday Sunday Sunday Sunday Monday Monday Monday Monday Monday Monday Monday Monday Monday Monday Monday Monday Monday
#
Departure Airport
Arrival Airport
85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128
Sharm Elsheikh Cairo Sharm Elsheikh Cairo Budapest Cairo Luxor Cairo Hurghada Cairo Aswan Cairo Luxor Cairo Hurghada Cairo Sharm Elsheikh Cairo Luxor Cairo Sharm Elsheikh Cairo Sharm Elsheikh Cairo Hurghada Cairo Luxor Cairo Luxor Cairo Aswan Cairo Sharm Elsheikh Cairo Budapest Cairo Malta Cairo Hurghada Cairo Marsa Alam Cairo Aswan Cairo
Cairo Sharm Elsheikh Cairo Budapest Cairo Luxor Cairo Hurghada Cairo Aswan Cairo Luxor Cairo Hurghada Cairo Sharm Elsheikh Cairo Luxor Cairo Sharm Elsheikh Cairo Sharm Elsheikh Cairo Hurghada Cairo Luxor Cairo Luxor Cairo Aswan Cairo Sharm Elsheikh Cairo Budapest Cairo Malta Cairo Hurghada Cairo Marsa Alam Cairo Aswan Cairo Luxor 109
Departure Time 17:05 11:45 13:15 12:30 15:45 13:20 15:00 15:25 17:00 17:20 19:15 17:35 19:15 20:00 21:35 20:15 21:45 7:45 9:25 8:00 9:30 11:45 13:15 10:20 11:55 11:30 13:10 15:20 17:00 11:30 13:25 15:35 17:05 12:30 15:45 13:15 16:00 15:25 17:00 18:35 19:50 17:20 19:15 17:35
Arrival Time 18:05 12:45 14:15 15:00 20:00 14:30 16:10 16:30 18:05 18:45 20:40 18:45 20:25 21:05 22:40 21:15 22:45 8:55 10:35 9:00 10:30 12:45 14:15 11:25 13:00 12:40 14:20 16:30 18:10 12:55 14:50 16:35 18:05 15:00 20:00 15:15 19.30 16:30 18:05 19:20 20:35 18:45 20:40 18:45
Departure Day Monday Monday Monday Monday Monday Monday Monday Monday Monday Monday Monday Monday Monday Monday Monday Monday Monday Tuesday Tuesday Tuesday Tuesday Tuesday Tuesday Tuesday Tuesday Tuesday Tuesday Tuesday Tuesday Tuesday Tuesday Tuesday Tuesday Tuesday Tuesday Tuesday Tuesday Tuesday Tuesday Tuesday Tuesday Tuesday Tuesday Tuesday
#
Departure Airport
Arrival Airport
129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172
Luxor Sharm Elsheikh Cairo Hurghada Cairo Sharm Elsheikh Cairo Luxor Cairo Sharm Elsheikh Cairo Sharm Elsheikh Cairo Hurghada Cairo Luxor Cairo Luxor Cairo Aswan Cairo Sharm Elsheikh Cairo Budapest Cairo Hurghada Cairo Aswan Cairo Luxor Cairo Hurghada Cairo Sharm Elsheikh Cairo Luxor Cairo Sharm Elsheikh Cairo Sharm Elsheikh Cairo Hurghada Cairo Luxor
Sharm Elsheikh Cairo Hurghada Cairo Sharm Elsheikh Cairo Luxor Cairo Sharm Elsheikh Cairo Sharm Elsheikh Cairo Hurghada Cairo Luxor Cairo Luxor Cairo Aswan Cairo Sharm Elsheikh Cairo Budapest Cairo Hurghada Cairo Aswan Cairo Luxor Cairo Hurghada Cairo Sharm Elsheikh Cairo Luxor Cairo Sharm Elsheikh Cairo Sharm Elsheikh Cairo Hurghada Cairo Luxor Cairo 110
Departure Time 19:15 20:35 20:00 21:35 20:15 21:45 7:45 9:25 8:00 9:30 11:45 13:15 10:20 11:55 11:30 13:10 15:20 17:00 11:30 13:25 15:35 17:05 12:30 15:45 15:25 17:00 18:05 20:00 20:00 21:40 20:00 21:35 20:15 21:45 7:45 9:25 8:00 9:30 11:45 13:15 10:20 11:55 11:30 13:10
Arrival Time 20:05 21:35 21:05 22:40 21:15 22:45 8:55 10:35 9:00 10:30 12:45 14:15 11:25 13:00 12:40 14:20 16:30 18:10 12:55 14:50 16:35 18:05 15:00 20:00 16:30 18:05 19:30 21:25 21:10 22:50 21:05 22:40 21:15 22:45 8:55 10:35 9:00 10:30 12:45 14:15 11:25 13:00 12:40 14:20
Departure Day Tuesday Tuesday Tuesday Tuesday Tuesday Tuesday Wednesday Wednesday Wednesday Wednesday Wednesday Wednesday Wednesday Wednesday Wednesday Wednesday Wednesday Wednesday Wednesday Wednesday Wednesday Wednesday Wednesday Wednesday Wednesday Wednesday Wednesday Wednesday Wednesday Wednesday Wednesday Wednesday Wednesday Wednesday Thursday Thursday Thursday Thursday Thursday Thursday Thursday Thursday Thursday Thursday
#
Departure Airport
Arrival Airport
173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216
Cairo Luxor Cairo Aswan Cairo Sharm Elsheikh Cairo Budapest Cairo Malta Cairo Hurghada Cairo Marsa Alam Cairo Aswan Cairo Luxor Cairo Hurghada Cairo Sharm Elsheikh Cairo Sharm Elsheikh Luxor Cairo Luxor Cairo Sharm Elsheikh Cairo Sharm Elsheikh Cairo Hurghada Cairo Luxor Cairo Luxor Cairo Aswan Cairo Sharm Elsheikh Cairo Budapest Cairo
Luxor Cairo Aswan Cairo Sharm Elsheikh Cairo Budapest Cairo Malta Cairo Hurghada Cairo Marsa Alam Cairo Aswan Cairo Luxor Cairo Hurghada Cairo Sharm Elsheikh Cairo Sharm Elsheikh Luxor Cairo Luxor Cairo Sharm Elsheikh Cairo Sharm Elsheikh Cairo Hurghada Cairo Luxor Cairo Luxor Cairo Aswan Cairo Sharm Elsheikh Cairo Budapest Cairo Hurghada 111
Departure Time 15:20 17:00 11:30 13:25 15:35 17:05 12:30 15:45 13:15 16:00 15:25 17:00 18:35 19:50 17:20 19:15 20:00 21:40 20:00 21:35 20:15 21:45 6:15 7:45 9:05 7:45 9:25 8:00 9:30 11:45 13:15 10:20 11:55 11:30 13:10 15:20 17:00 11:30 13:25 15:35 17:05 12:30 15:45 15:25
Arrival Time 16:30 18:10 12:55 14:50 16:35 18:05 15:00 20:00 15:15 19.30 16:30 18:05 19:20 20:35 18:45 20:40 21:10 22:50 21:05 22:40 21:15 22:45 7:15 8:35 10:15 8:55 10:35 9:00 10:30 12:45 14:15 11:25 13:00 12:40 14:20 16:30 18:10 12:55 14:50 16:35 18:05 15:00 20:00 16:30
Departure Day Thursday Thursday Thursday Thursday Thursday Thursday Thursday Thursday Thursday Thursday Thursday Thursday Thursday Thursday Thursday Thursday Thursday Thursday Thursday Thursday Thursday Thursday Friday Friday Friday Friday Friday Friday Friday Friday Friday Friday Friday Friday Friday Friday Friday Friday Friday Friday Friday Friday Friday Friday
#
Departure Airport
Arrival Airport
217 218 219 220 221 222 223 224 225 226
Hurghada Cairo Aswan Cairo Luxor Sharm Elsheikh Cairo Hurghada Cairo Sharm Elsheikh
Cairo Aswan Cairo Luxor Sharm Elsheikh Cairo Hurghada Cairo Sharm Elsheikh Cairo
Departure Time 17:00 15:45 17:40 17:35 19:15 20:35 20:00 21:35 20:15 21:45
Arrival Time 18:05 17:10 19:05 18:45 20:05 21:35 21:05 22:40 21:15 22:45
Departure Day Friday Friday Friday Friday Friday Friday Friday Friday Friday Friday
B.2 GENERATED PAIRINGS FOR SUNDAY # 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30
Flights Sequence 12 34 56 78 9 10 9 20 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 1256 1 2 9 10 1 2 11 12 3456 3 4 9 10 3 4 11 12 5 6 13 14 5 6 21 22 7 8 21 22 9 10 13 14 9 10 21 22 11 12 13 14
Fly Time (hrs) 2.33 2.00 2.00 2.17 2.33 2.34 2.83 2.00 6.75 5.30 2.34 1.50 2.16 2.84 2.34 2.33 2.17 2.00 4.33 4.66 5.16 4.00 4.33 4.83 4.00 3.50 3.67 4.33 3.83 4.83 112
Elapse Time (hrs) 4.83 4.50 4.50 4.67 4.83 6.67 5.33 4.50 9.50 8.05 4.84 4.00 4.66 5.34 4.84 4.83 4.67 4.50 8.50 8.58 9.08 8.25 8.33 8.83 8.33 7.67 9.09 8.58 7.92 8.58
Cost (hrs) 4.75 4.75 4.75 4.75 4.75 4.75 4.75 4.75 6.75 5.30 4.75 4.75 4.75 4.75 4.75 4.75 4.75 4.75 4.86 4.90 5.19 4.75 4.76 5.05 4.76 4.75 5.19 4.90 4.75 4.90
# 31 32 33 34 35 36 37 38
Flights Sequence 11 12 21 22 13 14 29 30 13 14 31 32 13 14 33 34 19 20 23 24 19 20 25 26 19 20 27 28 21 22 23 24
Fly Time (hrs) 4.33 4.33 4.17 4.00 4.50 5.18 4.68 3.66
Elapse Time (hrs) 7.92 9.25 9.09 9.17 9.25 9.34 9.09 7.16
Cost (hrs) 4.75 5.29 5.19 5.24 5.29 5.34 5.19 4.75
B.3 GENERATED PAIRINGS FOR MONDAY # 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34
Flights Sequence 12 34 56 78 7 20 9 10 11 12 13 14 15 16 17 18 19 10 19 20 21 22 23 24 25 26 27 28 29 30 1278 1 2 11 12 1 2 15 16 3 4 19 20 5 6 9 10 5 6 21 22 7 8 9 10 7 8 13 14 7 8 21 22 9 10 27 28 9 10 29 30 11 12 9 10 11 12 13 14 11 12 21 22 13 14 27 28 13 14 29 30 15 16 9 10
Fly Time (hrs) 2.33 2.84 2.17 2.33 2.34 2.34 2.83 2.00 2.00 6.75 2.34 2.34 2.16 2.84 2.34 2.17 2.00 4.66 5.16 4.33 5.18 4.51 4.33 4.67 4.33 4.49 4.51 4.34 5.17 4.83 4.99 4.17 4.00 4.34 113
Elapse Time (hrs) 4.83 5.34 4.67 4.83 6.67 4.84 5.33 4.50 4.50 9.50 6.84 4.84 4.66 5.34 4.84 4.67 4.50 8.58 9.08 8.50 9.84 9.84 9.75 8.67 8.58 8.58 9.34 9.42 8.67 8.58 8.58 9.09 9.17 8.42
Cost (hrs) 4.75 4.75 4.75 4.75 4.75 4.75 4.75 4.75 4.75 6.75 4.75 4.75 4.75 4.75 4.75 4.75 4.75 4.90 5.19 4.86 5.62 5.62 5.57 4.95 4.90 4.90 5.34 5.38 5.17 4.90 4.99 5.19 5.24 4.81
# 35 36 37 38 39 40
Flights Sequence 15 16 13 14 15 16 21 22 19 20 23 24 19 20 25 26 21 22 27 28 21 22 29 30
Fly Time (hrs) 4.00 4.16 5.18 4.68 4.33 4.16
Elapse Time (hrs) 8.33 8.33 9.34 9.09 9.25 9.33
Cost (hrs) 4.76 4.76 5.34 4.75 4.75 4.75
B.4 GENERATED PAIRINGS FOR TUESDAY # 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36
Flights Sequence 12 34 56 78 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 30 31 32 33 27 28 29 27 28 33 1256 1 2 9 10 1 2 13 14 3456 3 4 9 10 3 4 13 14 5 6 11 12 5 6 15 16 5 6 21 22 7 8 11 12 7 8 21 22 9 10 11 12 9 10 15 16 9 10 21 22 11 12 30 31 11 12 32 33 13 14 11 12 13 14 15 16 13 14 21 22
Fly Time (hrs) 2.33 2.00 2.00 2.17 2.33 2.34 2.83 2.00 6.75 5.30 2.16 1.50 2.84 2.17 2.00 3.00 3.00 4.33 4.66 5.16 4.00 4.33 4.83 4.34 4.00 4.16 4.51 4.33 4.67 4.33 4.49 4.51 4.34 5.17 4.83 4.99 114
Elapse Time (hrs) 4.83 4.50 4.50 4.67 4.83 4.84 5.33 4.50 9.50 8.05 4.66 4.00 5.34 4.67 4.50 6.00 7.17 8.50 8.58 9.08 8.25 8.33 8.83 8.42 8.33 8.33 9.84 9.75 8.67 8.58 8.58 9.34 9.42 8.67 8.58 8.58
Cost (hrs) 4.75 4.75 4.75 4.75 4.75 4.75 4.75 4.75 6.75 5.30 4.75 4.75 4.75 4.75 4.75 4.75 4.75 4.86 4.90 5.19 4.75 4.76 5.05 4.81 4.76 4.76 5.62 5.57 4.95 4.90 4.90 5.34 5.38 5.17 4.90 4.99
# 37 38 39 40 41 42
Flights Sequence 15 16 23 24 15 16 30 31 15 16 32 33 21 22 23 24 21 22 30 31 21 22 32 33
Fly Time (hrs) 3.50 4.17 4.00 3.66 4.33 4.16
Elapse Time (hrs) 7.00 9.09 9.17 7.16 9.25 9.33
Cost (hrs) 4.75 5.19 5.24 4.75 5.29 5.33
B.5 GENERATED PAIRINGS FOR WEDNESDAY # 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36
Flights Sequence 12 34 56 78 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 1256 1 2 9 10 1 2 13 14 3456 3 4 9 10 3 4 13 14 5 6 11 12 5 6 15 16 5 6 19 20 7 8 11 12 7 8 19 20 9 10 11 12 9 10 15 16 9 10 19 20 11 12 23 24 11 12 25 26 11 12 27 28 13 14 11 12 13 14 15 16 13 14 19 20 15 16 23 24 15 16 25 26
Fly Time (hrs) 2.33 2.00 2.00 2.17 2.33 2.34 2.83 2.00 6.75 2.16 2.84 2.33 2.17 2.00 4.33 4.66 5.16 4.00 4.33 4.83 4.34 4.00 4.16 4.51 4.33 4.67 4.33 4.49 4.67 4.51 4.34 5.17 4.83 4.99 4.33 4.17 115
Elapse Time (hrs) 4.83 4.50 4.50 4.67 4.83 4.84 5.33 4.50 9.50 4.66 5.34 4.83 4.67 4.50 8.50 8.58 9.08 8.25 8.33 8.83 8.42 8.33 8.33 9.84 9.75 8.67 8.58 8.58 9.50 9.34 9.42 8.67 8.58 8.58 9.25 9.09
Cost (hrs) 4.75 4.75 4.75 4.75 4.75 4.75 4.75 4.75 6.75 4.75 4.75 4.75 4.75 4.75 4.86 4.90 5.19 4.75 4.76 5.05 4.81 4.76 4.76 5.62 5.57 4.95 4.90 4.90 5.43 5.34 5.38 5.17 4.90 4.99 5.29 5.19
# 37 38 39 40
Flights Sequence 15 16 27 28 19 20 23 24 19 20 25 26 19 20 27 28
Fly Time (hrs) 4.00 4.49 4.33 4.16
Elapse Time (hrs) 9.17 9.41 9.25 9.33
Cost (hrs) 5.24 5.38 5.29 5.33
B.6 GENERATED PAIRINGS FOR THURSDAY # 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38
Flights Sequence 12 34 56 78 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 1256 1 2 9 10 1 2 13 14 3456 3 4 9 10 3 4 13 14 5 6 11 12 5 6 15 16 5 6 21 22 7 8 11 12 7 8 21 22 9 10 11 12 9 10 15 16 9 10 21 22 11 12 27 28 11 12 29 30 11 12 31 32 13 14 11 12 13 14 15 16 13 14 21 22 15 16 23 24 15 16 27 28
Fly Time (hrs) 2.33 2.00 2.00 2.17 2.33 2.34 2.83 2.00 6.75 5.30 2.16 1.50 2.84 2.33 2.17 2.00 4.33 4.66 5.16 4.00 4.33 4.83 4.34 4.00 4.16 4.51 4.33 4.67 4.33 4.49 4.67 4.51 4.34 5.17 4.83 4.99 3.50 4.33 116
Elapse Time (hrs) 4.83 4.50 4.50 4.67 4.83 4.84 5.33 4.50 9.50 8.05 4.66 4.00 5.34 4.83 4.67 4.50 8.50 8.58 9.08 8.25 8.33 8.83 8.42 8.33 8.33 9.84 9.75 8.67 8.58 8.58 9.50 9.34 9.42 8.67 8.58 8.58 7.00 9.25
Cost (hrs) 4.75 4.75 4.75 4.75 4.75 4.75 4.75 4.75 6.75 5.30 4.75 4.75 4.75 4.75 4.75 4.75 4.86 4.90 5.19 4.75 4.76 5.05 4.81 4.76 4.76 5.62 5.57 4.95 4.90 4.90 5.43 5.34 5.38 5.17 4.90 4.99 4.75 5.29
# 39 40 41 42 43 44
Flights Sequence 15 16 29 30 15 16 31 32 21 22 23 24 21 22 27 28 21 22 29 30 21 22 31 32
Fly Time (hrs) 4.17 4.00 3.66 4.49 4.33 4.16
Elapse Time (hrs) 9.09 9.17 7.16 9.41 9.25 9.33
Cost (hrs) 5.19 5.24 4.75 5.38 5.29 5.33
Elapse Time (hrs) 6.25 4.83 4.50 4.50 4.67 4.83 4.84 5.33 4.50 9.50 4.66 5.33 4.67 4.50 6.00 6.33 6.00 7.17 10.00 8.50 8.58 9.08 8.25 8.33 8.83 8.42 8.33 8.33 9.33 9.84 9.75 8.67 8.58 8.58 9.58 9.34
Cost (hrs) 4.75 4.75 4.75 4.75 4.75 4.75 4.75 4.75 4.75 6.75 4.75 4.75 4.75 4.75 4.75 4.75 4.75 4.75 5.71 4.86 4.90 5.19 4.75 4.76 5.05 4.81 4.76 4.76 5.33 5.62 5.57 4.95 4.90 4.90 5.47 5.34
B.7 GENERATED PAIRINGS FOR FRIDAY # 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36
Flights Sequence 17 45 67 89 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 29 30 31 32 123 125 26 27 28 26 27 32 1789 4589 4 5 12 13 4 5 16 17 6789 6 7 12 13 6 7 16 17 8 9 14 15 8 9 18 19 8 9 22 23 8 9 24 25 10 11 14 15 10 11 22 23 12 13 14 15 12 13 18 19 12 13 22 23 12 13 24 25 14 15 29 30
Fly Time (hrs) 2.00 2.33 2.00 2.00 2.17 2.33 2.34 2.83 2.00 6.75 2.16 2.83 2.17 2.00 3.00 2.99 3.00 3.00 4.00 4.33 4.66 5.16 4.00 4.33 4.83 4.34 4.00 4.16 4.83 4.51 4.33 4.67 4.33 4.49 5.16 4.51 117
# 37 38 39 40 41 42 43 44 45 46 47 48 49
Flights Sequence 14 15 31 32 16 17 14 15 16 17 18 19 16 17 22 23 16 17 24 25 18 19 29 30 18 19 31 32 22 23 29 30 22 23 31 32 24 25 29 30 24 25 31 32 12389 12589
Fly Time (hrs) 4.34 5.17 4.83 4.99 5.66 4.17 4.00 4.33 4.16 5.00 4.83 5.00 4.99
Elapse Time (hrs) 9.42 8.67 8.58 8.58 9.58 9.09 9.17 9.25 9.33 8.92 9.00 10.00 10.00
Cost (hrs) 5.38 5.17 4.90 4.99 5.66 5.19 5.24 5.29 5.33 5.10 5.14 5.71 5.71
B.8 GENERATED PAIRINGS FOR THE WEEK AS A WHOLE #
Flights Sequence
Duties
Fly Time (hrs)
Elapse Time (hrs)
Days
Cost (hrs)
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27
1-2 3-7 6-7 8-9 10 - 11 12 - 13 14 - 15 16 - 17 18 - 19 20 - 21 22 - 23 24 - 25 26 - 27 28 - 29 30 - 31 32 - 33 32 - 37 34 - 35 36 - 37 38 - 39 40 - 41 42 - 43 44 - 45 46 - 47 46 - 57 48 - 49 50 - 51
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
2.33 2.33 2.33 2.84 2.17 2.33 2.34 2.83 2.00 2.00 6.75 2.16 1.50 2.84 2.16 2.00 2.00 2.17 2.00 2.33 2.00 2.00 2.17 2.33 2.34 2.83 2.00
4.83 6.83 4.83 5.34 4.67 4.83 4.84 5.33 4.50 4.50 9.50 4.66 4.00 5.34 4.66 4.50 5.75 4.67 4.50 4.83 4.50 4.50 4.67 4.83 6.67 5.33 4.50
1-1 1-1 1-1 1-1 1-1 1-1 1-1 1-1 1-1 1-1 1-1 1-1 1-1 1-1 1-1 1-1 1-1 1-1 1-1 2-2 2-2 2-2 2-2 2-2 2-2 2-2 2-2
4.75 4.75 4.75 4.75 4.75 4.75 4.75 4.75 4.75 4.75 6.75 4.75 4.75 4.75 4.75 4.75 4.75 4.75 4.75 4.75 4.75 4.75 4.75 4.75 4.75 4.75 4.75
118
#
Flights Sequence
Duties
Fly Time (hrs)
Elapse Time (hrs)
Days
Cost (hrs)
28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71
52 - 53 54 - 55 56 - 57 58 - 59 60 - 61 62 - 63 64 - 65 66 - 67 68 - 69 70 - 71 72 - 73 74 - 75 76 - 77 78 - 79 78 - 91 80 - 81 82 - 83 84 - 85 86 - 87 88 - 89 90 - 81 90 - 91 92 - 93 94 - 95 96 - 97 98 - 99 100 - 101 102 - 103 104 - 105 106 - 107 108 - 109 110 - 111 112 - 113 114 - 115 116 - 117 118 - 119 120 - 121 122 - 123 124 - 125 126 - 127 131 - 132 133 - 134 135 - 136 137 - 138
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
6.75 5.30 2.34 1.50 2.16 2.84 2.34 2.33 2.17 2.00 2.33 2.84 2.17 2.33 2.34 2.34 2.83 2.00 2.00 6.75 2.34 2.34 2.16 2.84 2.34 2.17 2.00 2.33 2.00 2.00 2.17 2.33 2.34 2.83 2.00 6.75 5.30 2.16 1.50 2.84 2.17 2.00 2.33 2.00
9.50 8.05 4.84 4.00 4.66 5.34 4.84 4.83 4.67 4.50 4.83 5.34 4.67 4.83 6.67 4.84 5.33 4.50 4.50 9.50 6.84 4.84 4.66 5.34 4.84 4.67 4.50 4.83 4.50 4.50 4.67 4.83 4.84 5.33 4.50 9.50 8.05 4.66 4.00 5.34 4.67 4.50 4.83 4.50
2-2 2-2 2-2 2-2 2-2 2-2 2-2 2-2 2-2 2-2 3-3 3-3 3-3 3-3 3-3 3-3 3-3 3-3 3-3 3-3 3-3 3-3 3-3 3-3 3-3 3-3 3-3 4-4 4-4 4-4 4-4 4-4 4-4 4-4 4-4 4-4 4-4 4-4 4-4 4-4 4-4 4-4 5-5 5-5
6.75 5.30 4.75 4.75 4.75 4.75 4.75 4.75 4.75 4.75 4.75 4.75 4.75 4.75 4.75 4.75 4.75 4.75 4.75 6.75 4.75 4.75 4.75 4.75 4.75 4.75 4.75 4.75 4.75 4.75 4.75 4.75 4.75 4.75 4.75 6.75 5.30 4.75 4.75 4.75 4.75 4.75 4.75 4.75
119
#
Flights Sequence
Duties
Fly Time (hrs)
Elapse Time (hrs)
Days
Cost (hrs)
72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115
139 - 140 141 - 142 143 - 144 145 - 146 147 - 148 149 - 150 151 - 152 153 - 154 155 - 156 157 - 158 159 - 160 161 - 162 163 - 164 165 - 166 167 - 168 169 - 170 171 - 172 173 - 174 175 - 176 177 - 178 179 - 180 181 - 182 183 - 184 185 - 186 187 - 188 189 - 190 191 - 192 193 - 194 195 - 201 198 - 199 200 - 201 202 - 203 204 - 205 206 - 207 208 - 209 210 - 211 212 - 213 214 - 215 216 - 217 218 - 219 223 - 224 225 - 226 1/4/2005 3/4/2005
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
2.00 2.17 2.33 2.34 2.83 2.00 6.75 2.16 2.84 2.33 2.17 2.00 2.33 2.00 2.00 2.17 2.33 2.34 2.83 2.00 6.75 5.30 2.16 1.50 2.84 2.33 2.17 2.00 2.00 2.33 2.00 2.00 2.17 2.33 2.34 2.83 2.00 6.75 2.16 2.83 2.17 2.00 3.00 3.00
4.50 4.67 4.83 4.84 5.33 4.50 9.50 4.66 5.34 4.83 4.67 4.50 4.83 4.50 4.50 4.67 4.83 4.84 5.33 4.50 9.50 8.05 4.66 4.00 5.34 4.83 4.67 4.50 6.25 4.83 4.50 4.50 4.67 4.83 4.84 5.33 4.50 9.50 4.66 5.33 4.67 4.50 6.50 6.00
5-5 5-5 5-5 5-5 5-5 5-5 5-5 5-5 5-5 5-5 5-5 5-5 6-6 6-6 6-6 6-6 6-6 6-6 6-6 6-6 6-6 6-6 6-6 6-6 6-6 6-6 6-6 6-6 7-7 7-7 7-7 7-7 7-7 7-7 7-7 7-7 7-7 7-7 7-7 7-7 7-7 7-7 1-1 1-1
4.75 4.75 4.75 4.75 4.75 4.75 6.75 4.75 4.75 4.75 4.75 4.75 4.75 4.75 4.75 4.75 4.75 4.75 4.75 4.75 6.75 5.30 4.75 4.75 4.75 4.75 4.75 4.75 4.75 4.75 4.75 4.75 4.75 4.75 4.75 4.75 4.75 6.75 4.75 4.75 4.75 4.75 4.75 4.75
120
#
Flights Sequence
Duties
Fly Time (hrs)
Elapse Time (hrs)
Days
Cost (hrs)
116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159
128 - 129 - 130 128 - 129 - 134 195 - 196 - 197 195 - 196 - 199 220 - 221 - 222 220 - 221 - 226 1 - 2 - 10 - 11 6 - 7 - 12 - 13 6 - 7 - 16 - 17 6 - 7 - 20 - 21 10 - 11 - 14 - 15 10 - 11 - 24 - 25 12 - 13 - 14 - 15 12 - 13 - 18 - 19 12 - 13 - 24 - 25 14 - 15 - 32 - 33 14 - 15 - 32 - 37 14 - 15 - 34 - 35 14 - 15 - 36 - 37 16 - 17 - 14 - 15 16 - 17 - 18 - 19 16 - 17 - 24 - 25 18 - 19 - 26 - 27 18 - 19 - 32 - 33 18 - 19 - 32 - 37 18 - 19 - 34 - 35 18 - 19 - 36 - 37 20 - 21 - 14 - 15 20 - 21 - 18 - 19 20 - 21 - 24 - 25 24 - 25 - 26 - 27 24 - 25 - 32 - 33 24 - 25 - 32 - 37 24 - 25 - 34 - 35 24 - 25 - 36 - 37 38 - 39 - 42 - 43 38 - 39 - 46 - 47 38 - 39 - 48 - 49 40 - 41 - 42 - 43 40 - 41 - 46 - 47 40 - 41 - 48 - 49 42 - 43 - 50 - 51 42 - 43 - 58 - 59 44 - 45 - 58 - 59
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
3.00 3.00 3.00 2.99 3.00 3.00 4.50 4.66 5.16 4.33 4.51 4.33 4.67 4.33 4.49 4.34 4.34 4.51 4.34 5.17 4.83 4.99 3.50 4.00 4.00 4.17 4.00 4.34 4.00 4.16 3.66 4.16 4.16 4.33 4.16 4.33 4.66 5.16 4.00 4.33 4.83 4.00 3.50 3.67
6.00 7.17 6.00 6.33 6.00 7.17 9.75 8.58 9.08 8.50 9.84 9.75 8.67 8.58 8.58 8.17 9.42 9.34 9.42 8.67 8.58 8.58 7.00 7.92 9.17 9.09 9.17 8.42 8.33 8.33 7.16 8.08 9.33 9.25 9.33 8.50 8.58 9.08 8.25 8.33 8.83 8.33 7.67 9.09
4-4 4-4 7-7 7-7 7-7 7-7 1-1 1-1 1-1 1-1 1-1 1-1 1-1 1-1 1-1 1-1 1-1 1-1 1-1 1-1 1-1 1-1 1-1 1-1 1-1 1-1 1-1 1-1 1-1 1-1 1-1 1-1 1-1 1-1 1-1 2-2 2-2 2-2 2-2 2-2 2-2 2-2 2-2 2-2
4.75 4.75 4.75 4.75 4.75 4.75 5.57 4.90 5.19 4.86 5.62 5.57 4.95 4.90 4.90 4.75 5.38 5.34 5.38 5.17 4.90 4.99 4.75 4.75 5.24 5.19 5.24 4.81 4.76 4.76 4.75 4.75 5.33 5.29 5.33 4.86 4.90 5.19 4.75 4.76 5.05 4.76 4.75 5.19
121
#
Flights Sequence
Duties
Fly Time (hrs)
Elapse Time (hrs)
Days
Cost (hrs)
160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203
46 - 47 - 50 - 51 46 - 47 - 58 - 59 48 - 49 - 50 - 51 48 - 49 - 58 - 59 50 - 51 - 66 - 67 50 - 51 - 68 - 69 50 - 51 - 70 - 71 56 - 57 - 60 - 61 56 - 57 - 62 - 63 56 - 57 - 64 - 65 58 - 59 - 60 - 61 72 - 73 - 78 - 79 72 - 73 - 82 - 83 72 - 73 - 86 - 87 74 - 75 - 90 - 91 76 - 77 - 80 - 81 76 - 77 - 92 - 93 78 - 79 - 80 - 81 78 - 79 - 84 - 85 78 - 79 - 92 - 93 80 - 81 - 98 - 99 80 - 81 - 100 - 101 82 - 83 - 80 - 81 82 - 83 - 84 - 85 82 - 83 - 92 - 93 84 - 85 - 98 - 99 84 - 85 - 100 - 101 86 - 87 - 80 - 81 86 - 87 - 84 - 85 86 - 87 - 92 - 93 90 - 91 - 94 - 95 90 - 91 - 96 - 97 92 - 93 - 98 - 99 92 - 93 - 100 - 101 102 - 103 - 106 - 107 102 - 103 - 110 - 111 102 - 103 - 114 - 115 104 - 105 - 106 - 107 104 - 105 - 110 - 111 104 - 105 - 114 - 115 106 - 107 - 112 - 113 106 - 107 - 116 - 117 106 - 107 - 122 - 123 108 - 109 - 112 - 113
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
4.33 3.83 4.83 4.33 4.33 4.17 4.00 4.50 5.18 4.68 3.66 4.66 5.16 4.33 5.18 4.51 4.33 4.67 4.33 4.49 4.51 4.34 5.17 4.83 4.99 4.17 4.00 4.34 4.00 4.16 5.18 4.68 4.33 4.16 4.33 4.66 5.16 4.00 4.33 4.83 4.34 4.00 4.16 4.51
8.58 7.92 8.58 7.92 9.25 9.09 9.17 9.25 9.34 9.09 7.16 8.58 9.08 8.50 9.84 9.84 9.75 8.67 8.58 8.58 9.34 9.42 8.67 8.58 8.58 9.09 9.17 8.42 8.33 8.33 9.34 9.09 9.25 9.33 8.50 8.58 9.08 8.25 8.33 8.83 8.42 8.33 8.33 9.84
2-2 2-2 2-2 2-2 2-2 2-2 2-2 2-2 2-2 2-2 2-2 3-3 3-3 3-3 3-3 3-3 3-3 3-3 3-3 3-3 3-3 3-3 3-3 3-3 3-3 3-3 3-3 3-3 3-3 3-3 3-3 3-3 3-3 3-3 4-4 4-4 4-4 4-4 4-4 4-4 4-4 4-4 4-4 4-4
4.90 4.75 4.90 4.75 5.29 5.19 5.24 5.29 5.34 5.19 4.75 4.90 5.19 4.86 5.62 5.62 5.57 4.95 4.90 4.90 5.34 5.38 5.17 4.90 4.99 5.19 5.24 4.81 4.76 4.76 5.34 5.19 5.29 5.33 4.86 4.90 5.19 4.75 4.76 5.05 4.81 4.76 4.76 5.62
122
#
Flights Sequence
Duties
Fly Time (hrs)
Elapse Time (hrs)
Days
Cost (hrs)
204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247
108 - 109 - 122 - 123 110 - 111 - 112 - 113 110 - 111 - 116 - 117 110 - 111 - 122 - 123 112 - 113 - 131 - 132 112 - 113 - 133 - 134 114 - 115 - 112 - 113 114 - 115 - 116 - 117 114 - 115 - 122 - 123 116 - 117 - 124 - 125 116 - 117 - 131 - 132 116 - 117 - 133 - 134 122 - 123 - 124 - 125 122 - 123 - 131 - 132 122 - 123 - 133 - 134 135 - 136 - 139 - 140 135 - 136 - 143 - 144 135 - 136 - 147 - 148 137 - 138 - 139 - 140 137 - 138 - 143 - 144 137 - 138 - 147 - 148 139 - 140 - 145 - 146 139 - 140 - 149 - 150 139 - 140 - 153 - 154 141 - 142 - 145 - 146 141 - 142 - 153 - 154 143 - 144 - 145 - 146 143 - 144 - 149 - 150 143 - 144 - 153 - 154 145 - 146 - 157 - 158 145 - 146 - 159 - 160 145 - 146 - 161 - 162 147 - 148 - 145 - 146 147 - 148 - 149 - 150 147 - 148 - 153 - 154 149 - 150 - 157 - 158 149 - 150 - 159 - 160 149 - 150 - 161 - 162 153 - 154 - 157 - 158 153 - 154 - 159 - 160 153 - 154 - 161 - 162 163 - 164 - 167 - 168 163 - 164 - 171 - 172 163 - 164 - 175 - 176
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
4.33 4.67 4.33 4.49 4.51 4.34 5.17 4.83 4.99 3.50 4.17 4.00 3.66 4.33 4.16 4.33 4.66 5.16 4.00 4.33 4.83 4.34 4.00 4.16 4.51 4.33 4.67 4.33 4.49 4.67 4.51 4.34 5.17 4.83 4.99 4.33 4.17 4.00 4.49 4.33 4.16 4.33 4.66 5.16
9.75 8.67 8.58 8.58 9.34 9.42 8.67 8.58 8.58 7.00 9.09 9.17 7.16 9.25 9.33 8.50 8.58 9.08 8.25 8.33 8.83 8.42 8.33 8.33 9.84 9.75 8.67 8.58 8.58 9.50 9.34 9.42 8.67 8.58 8.58 9.25 9.09 9.17 9.41 9.25 9.33 8.50 8.58 9.08
4-4 4-4 4-4 4-4 4-4 4-4 4-4 4-4 4-4 4-4 4-4 4-4 4-4 4-4 4-4 5-5 5-5 5-5 5-5 5-5 5-5 5-5 5-5 5-5 5-5 5-5 5-5 5-5 5-5 5-5 5-5 5-5 5-5 5-5 5-5 5-5 5-5 5-5 5-5 5-5 5-5 6-6 6-6 6-6
5.57 4.95 4.90 4.90 5.34 5.38 5.17 4.90 4.99 4.75 5.19 5.24 4.75 5.29 5.33 4.86 4.90 5.19 4.75 4.76 5.05 4.81 4.76 4.76 5.62 5.57 4.95 4.90 4.90 5.43 5.34 5.38 5.17 4.90 4.99 5.29 5.19 5.24 5.38 5.29 5.33 4.86 4.90 5.19
123
#
Flights Sequence
Duties
Fly Time (hrs)
Elapse Time (hrs)
Days
Cost (hrs)
248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291
165 - 166 - 167 - 168 165 - 166 - 171 - 172 165 - 166 - 175 - 176 167 - 168 - 173 - 174 167 - 168 - 177 - 178 167 - 168 - 183 - 184 169 - 170 - 173 - 174 169 - 170 - 183 - 184 171 - 172 - 173 - 174 171 - 172 - 177 - 178 171 - 172 - 183 - 184 173 - 174 - 189 - 190 173 - 174 - 191 - 192 173 - 174 - 193 - 194 175 - 176 - 173 - 174 175 - 176 - 177 - 178 175 - 176 - 183 - 184 177 - 178 - 185 - 186 177 - 178 - 189 - 190 177 - 178 - 191 - 192 177 - 178 - 193 - 194 183 - 184 - 185 - 186 183 - 184 - 189 - 190 183 - 184 - 191 - 192 183 - 184 - 193 - 194 195 - 201 - 202 - 203 198 - 199 - 202 - 203 198 - 199 - 206 - 207 198 - 199 - 210 - 211 200 - 201 - 202 - 203 200 - 201 - 206 - 207 200 - 201 - 210 - 211 202 - 203 - 208 - 209 202 - 203 - 212 - 213 202 - 203 - 216 - 217 202 - 203 - 218 - 219 204 - 205 - 208 - 209 204 - 205 - 216 - 217 206 - 207 - 208 - 209 206 - 207 - 212 - 213 206 - 207 - 216 - 217 206 - 207 - 218 - 219 208 - 209 - 223 - 224 208 - 209 - 225 - 226
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
4.00 4.33 4.83 4.34 4.00 4.16 4.51 4.33 4.67 4.33 4.49 4.67 4.51 4.34 5.17 4.83 4.99 3.50 4.33 4.17 4.00 3.66 4.49 4.33 4.16 4.00 4.33 4.66 5.16 4.00 4.33 4.83 4.34 4.00 4.16 4.83 4.51 4.33 4.67 4.33 4.49 5.16 4.51 4.34
8.25 8.33 8.83 8.42 8.33 8.33 9.84 9.75 8.67 8.58 8.58 9.50 9.34 9.42 8.67 8.58 8.58 7.00 9.25 9.09 9.17 7.16 9.41 9.25 9.33 10.00 8.50 8.58 9.08 8.25 8.33 8.83 8.42 8.33 8.33 9.33 9.84 9.75 8.67 8.58 8.58 9.58 9.34 9.42
6-6 6-6 6-6 6-6 6-6 6-6 6-6 6-6 6-6 6-6 6-6 6-6 6-6 6-6 6-6 6-6 6-6 6-6 6-6 6-6 6-6 6-6 6-6 6-6 6-6 7-7 7-7 7-7 7-7 7-7 7-7 7-7 7-7 7-7 7-7 7-7 7-7 7-7 7-7 7-7 7-7 7-7 7-7 7-7
4.75 4.76 5.05 4.81 4.76 4.76 5.62 5.57 4.95 4.90 4.90 5.43 5.34 5.38 5.17 4.90 4.99 4.75 5.29 5.19 5.24 4.75 5.38 5.29 5.33 5.71 4.86 4.90 5.19 4.75 4.76 5.05 4.81 4.76 4.76 5.33 5.62 5.57 4.95 4.90 4.90 5.47 5.34 5.38
124
#
Flights Sequence
Duties
Fly Time (hrs)
Elapse Time (hrs)
Days
Cost (hrs)
292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335
210 - 211 - 208 - 209 210 - 211 - 212 - 213 210 - 211 - 216 - 217 210 - 211 - 218 - 219 212 - 213 - 223 - 224 212 - 213 - 225 - 226 216 - 217 - 223 - 224 216 - 217 - 225 - 226 218 - 219 - 223 - 224 218 - 219 - 225 - 226 1 - 4 - 5 - 10 - 11 3 - 4 - 5 - 10 - 11 195 - 196 - 197 - 202 - 203 195 - 196 - 199 - 202 - 203 32 - 41 34 - 45 36 - 41 36 - 43 36 - 41 - 42 - 43 64 - 73 66 - 73 68 - 77 70 - 87 96 - 103 98 - 109 100 - 105 100 - 107 100 - 105 - 106 - 107 128 - 136 131 - 142 133 - 138 133 - 140 133 - 138 - 139 - 140 157 - 164 159 - 170 161 - 166 161 - 168 161 - 166 - 167 - 168 189 - 199 191 - 205 193 - 201 193 - 203 193 - 201 - 202 - 203 32 - 33 - 44 - 45
1 1 1 1 1 1 1 1 1 1 1 1 1 1 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2
5.17 4.83 4.99 5.66 4.17 4.00 4.33 4.16 5.00 4.83 5.17 5.17 5.00 4.99 2.00 2.16 2.00 2.00 4.00 2.33 2.33 2.16 2.00 2.33 2.16 2.00 2.00 4.00 2.33 2.16 2.00 2.00 4.00 2.33 2.16 2.00 2.00 4.00 2.33 2.16 2.00 2.00 4.00 4.17
8.67 8.58 8.58 9.58 9.09 9.17 9.25 9.33 8.92 9.00 9.75 9.25 10.00 10.00 17.50 19.00 16.25 20.00 20.00 19.00 16.58 19.00 20.00 19.00 19.00 16.25 20.00 20.00 19.00 19.00 16.25 20.00 20.00 16.58 19.00 16.25 20.00 20.00 16.58 19.00 16.25 20.00 20.00 20.00
7-7 7-7 7-7 7-7 7-7 7-7 7-7 7-7 7-7 7-7 1-1 1-1 7-7 7-7 1-2 1-2 1-2 1-2 1-2 2-3 2-3 2-3 2-3 3-4 3-4 3-4 3-4 3-4 4-5 4-5 4-5 4-5 4-5 5-6 5-6 5-6 5-6 5-6 6-7 6-7 6-7 6-7 6-7 1-2
5.17 4.90 4.99 5.66 5.19 5.24 5.29 5.33 5.10 5.14 5.57 5.29 5.71 5.71 9.50 9.50 9.50 9.50 9.50 9.50 9.50 9.50 9.50 9.50 9.50 9.50 9.50 9.50 9.50 9.50 9.50 9.50 9.50 9.50 9.50 9.50 9.50 9.50 9.50 9.50 9.50 9.50 9.50 9.50
125
#
Flights Sequence
Duties
Fly Time (hrs)
Elapse Time (hrs)
Days
Cost (hrs)
336 337 338 339 340 341 342
36 - 37 - 42 - 43 70 - 71 - 86 - 87 100 - 101 - 106 - 107 128 - 129 - 138 133 - 134 - 139 - 140 161 - 162 - 167 - 168 193 - 194 - 202 - 203
2 2 2 2 2 2 2
4.00 4.00 4.00 3.00 4.00 4.00 4.00
20.00 20.00 20.00 18.92 20.00 20.00 20.00
1-2 2-3 3-4 4-5 4-5 5-6 6-7
9.50 9.50 9.50 9.50 9.50 9.50 9.50
126
ملخص الرسالة المقدمة من أحمد عصام محمد سعيد الحبشى للحصول على درجة ماجستير العلوم فى هندسة اإلنتاج بعنوان
جدولة طاقم الطيران مقدمة و دوافع دراسة مصطلح "جدولة الطاقم" هو مطلح يظهر فى كثير من صناعات النقل و يقصد به عادة تكليف مجموعة من العاملين (الطاقم) بمجموعة مهام محددة .بغض النظر عن وسيلة النقل ،فالعامل المشترك عند القيام بالجدولة هو السعى لتغطية كل المهام االموجودة بأقل تكلفة ممكنة ،آخذ ًا فى االعتبار القيود المختلفة .بالنسبة لشركات الطيران فالمسائل الناتجة عن جدولة الطاقم هى واحدة من مشاكل الجدولة الكثيرة التى تواجهها .حيث تبدأ شركات الطيران أوال ً بوضع جدول لرحالتها ثم تحدد طراز الطائرة المناسب لكل رحلة و بعدها تحدد أي طائرة بعينها ستقوم باستخدامها لكل رحلة وفقا ً العتبارات معينة، أخيرا تقوم الشركة بجدولة الطاقم. و ً الدافع الختيار صناعة الطيران بالتحديد لجدولة الطاقم كان بسبب أن هذه الصناعة تكاد تكون معبرة عن معظم الصناعات المشابهة فى هذا المجال ،و ألنه بطبيعة تلك الصناعة يتم تخصيص وقت و جهد كبيرين لحل تلك المشاكل ،و لوجود مجموعة من القيود التى تجعل تلك المسائل فى تلك الصناعة بالتحديد أصعبهم .باإلضافة إلى ذلك كله ،فطاقم الطيران دون مثيله فى أي صناعة نقل أخرى يحصل على رواتب مرتفعة جدا ً و نظ ًرا ألن تلك الرواتب تأتى فى المرتبة الثانية تقريبًا بعد تكاليف الوقود ،فأى مقدار توفير فى تكلفة تلك الرواتب من شأنه أن يحقق أربا ًحا كثيرة لشركات الطيران.
هدف البحث الهدف الرئيسى من هذا البحث هو تطوير أسلوب حل ممنهج قادر على التعامل بنجاح مع نوعية المسائل التى تنشأ عند جدولة طاقم الطيران كتحويل مجموعة رحالت فى فترة زمنية معينة إلى مجموعات رحالت و إختيار منهم مجموعة تحقق اقل تكلفة ممكنة مع تغطية جميع الرحالت الموجودة؛ و ذلك ال يمكن تحقيقه إال عن طريق:
القيام بدراسة وافية للمسائل المرتبطة بجدولة طاقم الطيران و مكوناتها المختلفة.
تمثيل تلك المسائل رياضيـًا بأنسب طريقة.
مراجعة أساليب الحل الحالية بعناية لتحديد مواطن القوة و نقاط الضعف لك ًل منهم.
الوقوف على أسلوب الحل الذى سيتم تطويره.
مقارنة نتائج استخدام أسلوب الحل المقترح على مجموعة مسائل قياسية و تطبيقه على أرض الواقع.
نظرة عامة على فصول الرسالة الفصل األول :يشمل أهمية موضوع الرسالة والدافع لها كما يقدم أهداف الرسالة وملخصا للفصول األخرى.
الفصل الثاني :يستعرض هذا الفصل األدبيات المختلفة فى هذا المجال .يبدأ الفصل بشرح وجيز لبعض المصطلحات الخاصة بشركات الطيران .يتبعه شرح مفصل للمسائل المرتبطة بجدولة طاقم الطيران بمكوناتها المختلفة ،مصحوبـًا أخيرا ،يعرض أساليب الحل المختلفة التى تم استخدمها للتعامل مع هذه النوعية بالتمثيل الرياضى المناسب لتلك المسائل. ً من المسائل؛ باإلضافة إلى – و بشىء من التفصيل – ما توصل إليه باحثون آخرون فى نفس المجال. الفصل الثالث :و يقدم شرحـًا مفصال ً ألسلوب الحل المقترح فى هذا البحث المكون من مرحلتين .و يحتوى على تفاصيل دقيقة ألسلوب الحل المقترح باإلضافة إلى مجموعة من االفتراضات و التعريفات و المعلومات الضرورية. الفصل الرابع :يتضمن اختبار و تطبيق أسلوب الحل المقترح؛ و يهدُف هذا الفصل إلى التأكد من أن أسلوب الحل المقترح يحقق الغرض المرجو منه و أنه قادر على إيجاد حلول مثلى .و ذلك عن طريق استخدام مجموعة من مسائل اختبار أخيرا يتم تطبيق هذه الدراسة فى (أغلبها مسائل تجريبية) و مقارنة حلول تلك المسائل بالحلول الناتجة من هذه الدراسة .و ً إحدى شركات الطيران المحلية و امكن تحقيق نسب توفير تترواح من %7.64إلى %26.81يوميـًا فى إحد االسابيع ،مع توفير بمقدار %15.57فى االسبوع ككل. الفصل الخامس :يقدم االستنتاجات الرئيسية للدراسة ،و يحدد التوجهات المستقبلية للبحث في هذا المجال.
جدولة طاقم الطيران مقدمة من أحمد عصام محمد سعيد الحبشى للحصول على درجة ماجستير العلوم في هندسة اإلنتاج
لجنة الحكم: أ.د .محمد حمدي علواني أستاذ الهندسة الصناعية – كلية الهندسة – جامعة اإلسكندرية
أ.د .إبراهيم عبد السالم عوض أستاذ هندسة الحاسبات و النظم – كلية الهندسة – جامعة اإلسكندرية
أ.د .عزيز عزت السيد أستاذ الهندسة الصناعية – كلية الهندسة – األكاديمية العربية للعلوم والتكنولوجيا والنقل البحري
أ.د .محمد نشأت فُرس أستاذ الهندسة الصناعية – كلية الهندسة – جامعة اإلسكندرية
أ.د .هبة وائل لهيطة وكيل الكلية للدراسات العليا والبحوث – كلية الهندسة – جامعة اإلسكندرية
موافقون
لجنة إشراف رسالة الماجستير الخاضة بالمهندس /أحمد عصام محمد سعيد الحبشى بعنوان "جدولة طاقم الطيران" أ.د .محمد حمدي علواني أستاذ الهندسة الصناعية المتفرغ بقسم هندسة اإلنتاج كلية الهندسة – جامعة اإلسكندرية
أ.د .محمد نشأت فرس أستاذ الهندسة الصناعية المتفرغ بقسم هندسة اإلنتاج كلية الهندسة – جامعة اإلسكندرية
د .ياسمين أبوالسعود صالح مدرس بقسم الرياضيات والفيزياء الهندسية كلية الهندسة – جامعة اإلسكندرية
جـامـعـة اإلسـكـنـدريـة كـلـيـة الـهـنـدسـة قـسـم هـنـدسـة اإلنـتـاج
جدولة طاقم الطيران رسالة مقدمة إلى قسم هندسة اإلنتاج كلية الهندسة – جامعة اإلسكندرية ضمن متطلبات الحصول على درجة
ماجستير العلوم في هندسة اإلنتاج
مقدمة من
أحمد عصام محمد سعيد الحبشى 2012
