Abstract
Efficient scheduling for the supporting operations of aircrafts in flight deck is critical to the aircraft carrier, and even several seconds’ improvement may lead to totally converse outcome of a battle. In the paper, we ameliorate the supporting operations of carrier-based aircrafts and investigate three simultaneous operation relationships during the supporting process, including precedence constraints, parallel operations, and sequence flexibility. Furthermore, multifunctional aircrafts have to take off synergistically and participate in a combat cooperatively. However, their takeoff order must be restrictively prioritized during the scheduling period accorded by certain operational regulations. To efficiently prioritize the takeoff order while minimizing the total time budget on the whole takeoff duration, we propose a novel mixed integer liner programming formulation (MILP) for the flight deck scheduling problem. Motivated by the hardness of MILP, we design an improved differential evolution algorithm combined with typical local search strategies to improve computational efficiency. We numerically compare the performance of our algorithm with the classical genetic algorithm and normal differential evolution algorithm and the results show that our algorithm obtains better scheduling schemes that can meet both the operational relations and the takeoff priority requirements.
1. Introduction
When the battle comes, carrier-based aircrafts have to take off wave by wave. The operation of the first wave of aircraft takeoff is usually the most complicated since several types of carrier-based aircrafts have to take off synergistically. Before taking off, each carrier-based aircraft requires certain supporting operations, for instance, inspection, charging, oiling, and weapon mount. Some operations can be performed simultaneously, including oiling and weapon mount. All aircrafts do not need to wait for their order since this class of operations can be processed by some different supporting groups at the same time. Nevertheless, some other operations cannot be processed at the same time. For instance, charging oxygen and oiling cannot be processed simultaneously due to the safety concern and thus aircrafts have to be processed one by one. Therefore, the latter class of supporting operations in turn affects the takeoff priority orders of aircrafts and it is important to schedule the supporting groups efficiently such that all carrier-based aircrafts take off in the minimal time horizon. The scheduling problem is usually called “deck scheduling,” which can be viewed as an extension of the Flexible Job Shop Scheduling Problem (FJSP) by incorporating some practical restrictions.
Job Shop Scheduling Problem (JSP) falls in the classical group of combinatorial optimization problems and is well known to be NP-hard [1]. The Flexible Job Shop Scheduling Problem (FJSP) is an extension of the JSP [2]. However, traditional models of JSP and FJSP do not consider the typical features of the scheduling for the carrier-based aircrafts on the deck, including the following.
First, in most JSP and FJSP models, they usually restrict the precedence of operations in each job but do not consider priorities of jobs, which means any job can be completed earlier than others. However, on the deck of the aircraft carrier, the first wave of carrier-based aircrafts may include helicopter, early warning aircraft, and fighter jets, and there are strictly takeoff orders for different carrier-based aircrafts. According to operational regulations, the helicopter must take off firstly, and then the early warning aircraft, fighter jets, which make it more difficult to schedule the supporting resources.
Second, in most JSP and FJSP models, the precedence among operations of a job is predetermined and cannot be changed. In deck scheduling, some operations of a carrier-based aircraft can be processed before or after other operations, which will increase the scheduling flexibility. For example, on the deck of the aircraft carrier, the carrier-based aircraft needs to be charged oxygen and oiled, and it is permitted to charge oxygen first, then oil, or vice versa. But for safety, the two operations cannot be processed simultaneously.
Third, the operations are processed one by one in most JSP and FJSP, but in the job of supporting carrier-based aircrafts, it will take a long time to charge oil and configure weapon sequentially. In order to save time, the two operations can be processed simultaneously.
To the best of our knowledge, only few researches considered the three typical features above in a single scheduling problem. We address these challenges in terms of the extended FJSP (EFJSP) with priority, parallel operations, and sequence flexibility. Based on FJSP, we propose a novel MILP model for the problem. Nevertheless, when the typical restrictions are incorporated into the model, few existing algorithms in the literatures can solve it efficiently. Motivated by the hardness, we develop an improved differential evolution algorithm combined with typical local search strategies. By using some practical instances flight deck scheduling and random instances, we compare the performance of the proposed algorithm with the general genetic algorithm and differential evolution algorithm. Furthermore, we also analyze the impact of the local search strategies on the performance.
2. Literature Review
FJSP has been widely studied, but most of current literatures study the scheduling problem involving one or two of the above three features, which are priority, parallel operations, and sequence flexibility. Alvarez-Valdes et al. [3] introduced some operations which can be processed simultaneously in the glass production; a heuristic algorithm combining the priority rule with local search is proposed to minimize the optimization criteria, which is based on the earliest completion and delay penalty. Vilcot and Billaut [4] discussed the process characteristics of the printing industry, where each operation has at least one former operation, but only a subsequent operation, in a complete process, and some operations can be carried out at the same time. Özgüven et al. [5] introduced a relatively simple integer programming model, in which a job can choose a feasible routing from some reverse sets. However, once the process of the job is determined, no operations can be processed simultaneously. Birgin et al. [6] proposed a MILP model for an extended version of the FJSP, which allowed the precedence to be given by an arbitrary directed acyclic graph rather than a linear order among operations of a job, and compared with [5], the result showed the accuracy of the model. In the Birgin model [6], Birgin et al. [7] put forward the scheduling list algorithm to solve the problem, further extending to the filtered beam search method. The experiment results show that the efficiency and the effect of these two methods are very good.
For the FJSP, each operation could be processed by some machines at different time. If the job has several kinds of processing routes, selecting one of them is called process planning. At first, the process planning is optimized in the case of sufficient resources, but the reality shows that this cannot fully utilize resources. Thus, Saygin and Kilic [8] established the integrated model combining process design with production scheduling, which included 5 stages: flexible process decomposition, machine tool selection, process optimization, scheduling, and rescheduling. There are some similar models such as two-level model [9], two-stage model [10], flexible process selection model [11], and mixed integer programming model [5]. However, in these studies, once the process route is selected, the order of operations is determined, and there is no essential difference with JSP and FJSP.
There are also some researches on the flight deck scheduling; Ryan et al. [12] designed an interactive local and global decision supporting system named deck operation course of action planner for aircraft carrier deck scheduling. They applied the reverse reinforcement learning method [13] and strategy optimization based on queuing network [14] in aircraft adaptive multistage scheduling problem, and through deck operation simulation, the scheduling performance of the optimization based on integer linear programming model is compared with the traditional expert heuristic rules [15]. According to the difference of carrier-based aircraft support organization of different launch mode carrier-based aircraft needed, Wei et al. [16] introduced two carrier-based aircraft support scheduling models on the basis of reasoned supposition and propriety predigesting: carrier-based aircraft support scheduling model of wavily launching carrier-based aircraft on carrier [17] and rescheduling model of carrier-based aircraft support based on mission [18]. The two models are solved based on the FJSP theory and rescheduling theory, respectively. According to the constraint of supporting process for single-carrier aircraft, a multiobjective integrated supporting scheduling model of multicarrier aircrafts was established by Han et al. [19], in which some operations can be processed simultaneously.
From the above reviews, it can be seen that most researches are concerned about one of the three features, and there are few researches which consider the three features simultaneously. Thus, the scheduling problem generated in the supporting process for carrier-based aircrafts is a new extension of the classical FJSP.
The remainder of this paper is organized as follows. In Section 3, some definitions will be proposed; the new model is formalized. In Section 4, the improved DE algorithms for the extension are illustrated in detail. The computational results and analysis are provided in Section 5. Finally, we conclude the paper in Section 6.
3. The Formulation of the EFJSP Model
The deck scheduling for carrier-based aircrafts is to schedule a number of supporting groups to complete the operations for preparing the aircrafts well and let them take off as soon as possible. There are usually a set of operations to be completed before the carrier-based aircraft can take off, such as inspection, charging, oiling, and weapon mount. Each operation must be conducted by one supporting group selected from a set of candidate ones whose efficiency is different. There are also operational rules which restrict the sequence of taking off for different types of aircrafts; for instance, the helicopter must take off before all the other aircrafts. Further, the sequence of some operations can be exchanged. For example, charging oxygen is allowed to be processed before or after oiling, but not at the same time. The scheduling can be decomposed into two subproblems: the sequencing subproblem which determines a sequence for all operations and the routing subproblem that selects a suitable supporting group for each operation. The objective is to find a scheduling that minimizes the makespan.
We can see that the EFJSP is more complex than the FJSP: First, in the EFJSP, different jobs have different priority, and the final operation of the job with higher priority must be completed earlier than others with lower priority. Second, some operations of a job can be processed simultaneously, such as operations 1 and 2 in Figure 1. Third, some operations of a job can be processed by exchanging their preference order, in Figure 1, where operations 4 and 5 can be swapped.
Some definitions will be proposed based on these features which have been mentioned previously.
Definition 1 (job). All the supporting operations of a carrier-based aircraft are considered as a job.
Definition 2 (priority). When many jobs need to be done, the more important job should be completed earlier. However, for the job with higher priority, it does not mean that each operation has to be finished earlier than others; in order to make good use of the supporting groups, it is only required that the final operation must be finished earlier than others with lower priority.
Definition 3 (parallel operations). There are no precedent relations among some operations in a job, which can be processed simultaneously.
Definition 4 (sequence flexibility). This means that there are two operations in a job; they are neighbors and can change their precedent constraint but cannot be processed simultaneously.
Because the EFJSP is more complex than the FJSP, thus it is also NP-hard. In detail, the following assumptions are made in the paper:(1)All the supporting groups are available at time 0.(2)All the jobs can be processed at time 0.(3)Only one operation can be processed by a supporting group at a time.(4)Each operation must be completed without interruption once it starts.(5)The precedence of some operations for a job is predefined and cannot be changed; some can exchange their preference orders.(6)The setting up time of supporting groups and transferring time of operations are negligible.
The following indices, sets, and parameters are used in the new model: : indices for jobs : indices for operations : indices for supporting groups : number of jobs : number of operations in job : set of supporting groups : operation of job : set of supporting groups on which operation can be processed, : immediate job predecessor of operation : processing time if operation is to be performed by supporting group : a very large positive number
Decision Variables : starting time of operation : completion time of operation : 1 if supporting group is assigned to operation ; 0, otherwise : 1 if operation is scheduled before operation where both operations are processed by supporting group ; 0, otherwise : 1 if operation is processed before operation in job ; 0 if operation is processed before operation in job
The EFJSP is formulated into a MILP. The mathematical model is as follows:If the priority of is higher than , then
The makespan is the objective function of the problem. Constraint (2) makes sure that operation is not interrupted. Constraint (3) guarantees that an operation is processed by one supporting group. Constraint (4) describes the operation precedence constraints. Constraints (5)–(8) ensure that operations cannot be processed by the same supporting group at the same time. Constraint (9) shows jobs with higher priority should be completed earlier than others with lower priority. Constraint (10) allows some operations to exchange precedence order, but the operations will not be processed simultaneously.
Comparing with the FJSP model, the EFJSP model includes more constraints, such as constraint (4), parallel operation; constraint (9), priority; and constraint (10), sequence flexibility.
4. Proposed Improved DE for the EFJSP Model
For the FJSP, when the number of jobs is small, some exact algorithms can be employed to solve it, for example, brand-and-bound [20–23], mathematical programming [24–26], and Lagrangian relaxation [27–30]. But when the number of jobs rises, it is difficult to find an optimal solution in a short time. Many researchers have heuristic methods to solve the FJSP, such as genetic algorithm (GA) [31–34], ant colony algorithm [35], particle swarm optimization [36], tabu search [37], leapfrog algorithm [38], bee colony algorithm [39], differential evolution (DE) algorithm [40–44], and memetic algorithms [45, 46]. Some literatures study the combinations of a variety of algorithms or an algorithm with local search to obtain better performance, such as differential evolution algorithm combining with genetic algorithm [47], particle swarm optimization combining with simulated annealing [48], and tabu search combining with local search [49]. But these algorithms cannot solve the EFJSP model directly, and new improved algorithms should be explored.
DE is an optimization algorithm proposed by Storn and Price [50] for solving Chebyshev polynomials, which encodes the chromosome with floating-point vector in continuous space. DE algorithm is an intelligent optimization method based on population, which searches the entire population space with the help of the disturbance formatting by individual difference, and seeks the optimal solution of the problem through the greedy competition mechanism. The DE algorithm has less controlled parameters and is easy to understand and implement. Due to its high reliability, robustness, and good performance, DE has been widely used in optimization area. There have been some works using DE algorithm to solve FJSP and JSP [40–44], which show the advantages of the DE algorithm compared with other algorithms. The EFJSP problem is an extension of FJSP, and we made some improvement on DE by integrating some local research strategies to solve our problem more efficiently. The basic framework of DE is just as presented in Figure 2.
4.1. Encoding
The EFJSP model can be decomposed into two subproblems: sequencing and routing. Thus, a chromosome contains two parts; more specifically, the first part (part 1) is the sequencing that determines an operation order within a job and an operation sequence of all jobs; the second part (part 2) is the routing that assigns each operation to an appropriate supporting group. Some works [51, 52] have been done in the method of sequencing and routing.
4.1.1. Operation Sequence
The number of all operations is calculated as . Let a number (ranging from 1) denote the ID of each operation, and a smaller value of ID means a higher priority in a job.
An example of EFJSP is shown in Table 1 as an illustration, the precedent constraints of operations in job 1 are shown in Figure 1, and the precedent constraints of operations in job 2 and job 3 are liner. In Table 1, there are 3 supporting groups: , , and . Each entry of the input table denotes the processing time of that operation on the corresponding supporting group. The tag “—” means that a supporting group cannot process the corresponding operation. The ID in Table 2 denotes the instances in Table 1.
Part 1 code can be generated by the IDs listed randomly; the length of part 1 is . Take the instances in Table 1 as an example, and suppose there is a random operation sequence: part 1 = , and () is the immediate precedent operation of (); it is obvious that the sequence breaks the precedent constraint in job 2; as a result, part 1 code should be changed as .
4.1.2. Supporting Group Assignment
Following the operation sequencing, each operation should select a supporting group in its alternative supporting group set. Take the instances in Table 1 as an example, and suppose part 1 is , and number “7” denotes the operation , which can be processed by or ; if the operation is processed by , then the corresponding gene is “2” in part 2. A possible supporting group assignment is shown in Table 3. A chromosome is composed of part 1 and part 2.
4.1.3. The IDs of Job with Higher Priority
In the EFJSP model, some jobs have higher priorities, which must be finished earlier; as a result, the IDs should be assigned to the jobs with higher priority first. Chromosomes which cannot satisfy the rule should be abandoned.
4.2. Decoding
4.2.1. Decoding the Chromosome to an Active Scheduling
Decoding is to convert the chromosome into a feasible solution; there are mainly three decoding methods: active scheduling, semiactive scheduling, and nondelay scheduling. Some works [53, 54] have found that the optimal scheduling to achieve the goal of makespan is an active scheduling; thus, we decode the chromosome to an active scheduling here. The steps are shown as follows.
Step 1. Set up .
Step 2. Take the th gene in part 1 and convert it into the operation ; then select the th gene in part 2 and convert it into supporting group ; the processing time is which operation processed by the supporting group .
Step 3. If the operation is the first one to be processed by the supporting group , ; otherwise we should find all the idle time intervals in the supporting group .
Step 4. If the length of the idle time interval is bigger than according to (16), the operation should be inserted into the interval; otherwise, it should be allocated in the end of the supporting group .
Step 5. Repeat Steps 2 to 4 until all operations of part 1 have been processed.
4.3. Initial Population
Population initialization is crucial since it can affect the speed of the algorithm’s convergence and the quality of the solution. In this part, we present a method to assign each operation to a suitable supporting group. The method focuses on the processing time and workload of supporting groups, namely, the global assignment, which is an improved one of the work [52]; the steps are as follows.
Step 1. Create a new array to record the working time of each supporting group; initial values are set as 0.
Step 2. Follow the order sequentially; take an operation from part 1.
Step 3. Add the processing time of each alternative supporting group to the corresponding location in the array; then the corresponding supporting group with the shortest time will be selected for the operation; if there are several supporting groups with the same minimum time, the one with the least processing time should be selected.
Step 4. The order of the selected supporting group in the alternative supporting group set will be added to the corresponding gene bit of part 2.
Step 5. In the array, modify the total working time of the selected supporting group, and leave the others unchanged.
Step 6. Continue from part 1, and repeat Steps 3 to 6 until all operations are processed.
4.4. Mutation
For the mutation, DE is not suitable for discrete problems; the following two methods are applied: POX (Precedence Operation Crossover, POX) [55] and MPX (Multiple Point Crossover, MPX) [56]. The POX inherits the characteristics of operation sequence from parent chromosomes to child chromosomes; the MPX transits the features of supporting group assignment from parent chromosomes to child chromosomes.
4.4.1. POX
Precedence operation crossover is the process to cross the operation sequence in the parent chromosomes, and the supporting group assignments are reserved to the child chromosomes. The process is as follows.
First, the set of jobs is divided into two random complementary and nonempty sets: , .
Second, all the operations of jobs in set with their assigned supporting groups are copied from “Parent 1” chromosome to “Child 1” chromosome, and all the operations of jobs in set with their assigned supporting groups are copied from “Parent 2” chromosome to “Child 2” chromosome.
Third, all the operations of jobs in set with their assigned supporting groups are copied from “Parent 2” chromosome to “Child 1” chromosome, and all the operations of jobs in set with their assigned supporting groups are copied from “Parent 1” chromosome to “Child 2” chromosome.
Taking Table 1 as an example, the process of POX is shown in Figure 3.
4.4.2. MPX
Multiple point crossover is the process to cross the supporting group assignment in the parent chromosomes, and the operation sequence is reserved to the child chromosomes. The process is as follows.
First, an integer set containing 0 and 1 is randomly generated, the length of which is equal to the half-length of chromosomes.
Second, the operations and their assigned supporting groups whose positions correspond to 0 in set are copied from “Parent 1” chromosome to “Child 1” chromosome.
Third, selecting the operations in “Parent 1” chromosome whose positions correspond to 1 in set , these operations and assigned supporting groups in “Parent 2” chromosome are copied to “Child 1” chromosome.
Similarly, for the “Child 2” chromosome, the operations and their assigned supporting groups whose positions correspond to 0 in set are copied from “Parent 2” chromosome. Then, selecting the operations in “Parent 2” chromosome whose positions correspond to 1 in set , these operations and assigned supporting groups in “Parent 1” chromosome are copied to “Child 2” chromosome. Taking Table 1 as an example, the process of MPX is shown in Figure 4.
The mutation of chromosome is performed by where , is the th chromosome in the th population, is the th chromosome in the th mutated population, is scale factor, and is cross symbol; the calculation of (17) is composed of two parts: (18) and (19).
Equation (18) denotes the difference vector between two parent chromosomes; is a random number between 0 and 1. When sequencing the operations, will be crossed in the POX way. When assigning the supporting groups, will be crossed in the MPX way.
Equation (19) denotes the process that parent chromosomes cross with difference vector. We compute using the way in .
4.5. Crossover
After mutation, the crossover operator is applied to generate the trial vector as follows:where is a crossover parameter to control the diversity of the population, denotes a random number between 0 and 1, and the process of crossover is shown in Figure 5. When we obtain , some work needs to be done for the deduplication and completion of solution. The construction of new chromosomes should guarantee the priority of some certain operations.
4.6. Selection
The selection operator is used to decide whether the trial vector is the member of the population for the next generation, which can be described aswhere is the objective function to be minimized. Therefore, the trial vector will replace the corresponding target vector in the next generation if its objective function value is not greater than that of the target vector; otherwise, the target vector remains in the population.
4.7. Local Search Algorithm
In this part, a local search algorithm based on neighborhood structure is proposed to improve the scheduling. And the neighborhood structure is based on the critical path in the disjunctive graph, which is a kind of representation for the scheduling.
4.7.1. Disjunctive Graph
Disjunctive graph [25] is an important formulation of FJSP, where denotes a set of all the nodes, and each node represents an operation in the EFJSP (including dummy starting and terminating operations); represents the conjunctive arcs connecting two adjacent operations within a job, and the direction represents the processing order between the two connected operations; denotes all disjunctive arcs connecting two adjacent operations which are processed by the same supporting group and their directions display the processing order. The processed time of each operation is generally labeled on the corresponding node and regarded as the node’s weight. In Figure 6, , are processed by the supporting group , and , , , and are executed successively by the supporting group , and , , , and are performed by the supporting group .
A scheduling of the EFJSP is feasible, if there are no cyclic paths in its corresponding disjunctive graph. If a disjunctive graph is acyclic, the longest path between the starting node and the ending node is called a critical path, whose length is defined as the makespan of the scheduling. Operations on the critical path are critical operations. For example, the disjunctive graph illustrated in Figure 6 is a feasible scheduling as it is acyclic, its critical path is , and the makespan is 48. Here, we define as the longest path from node to node .
4.7.2. Neighborhood Structures
Neighborhood structure is key to the local search, which can guide the search of algorithm effectively and avoid the blind search. The neighborhood structure of JSP is designed to make good use of the idle time in supporting groups. For the FJSP, another factor should be considered, which is the assignment of the supporting groups. For the EFJSP, the priority of jobs, parallel operations, and the flexibility of operation order will influence the neighborhood structure. Therefore, a new local search algorithm will be introduced based on the work [57]. Since the critical path defines the makespan of the scheduling, so only the critical operations should be used to search for idle time in the alternative supporting group set and implement the local search.
The following notations are used in the local search algorithm: : critical operation : set of immediate precedent operations of : set of immediate succeeding operations of : the earliest starting time of : the earliest completing time of : the latest starting time of : the latest completing time of
The idle time in the alternative supporting groups of can be divided into two types: (1) the idle time in current supporting group which processed and (2) the idle time in other supporting groups which are in the alternative supporting group set of . Therefore, the move of is also two types: (1) in current supporting group and (2) in other alternative supporting groups. Each type of idle time corresponds to a kind of local search.
The first-level local search is the moving in the current supporting group.
It is known that each operation in must be finished before the starting of , and must be finished before the starting of each operation in . The biggest time interval of the processing is .
Suppose operations and are neighbors, processed by the same supporting group with . The biggest idle time interval between and is ; if the intersection of sets and is not empty, it is possible to decrease makespan by inserting between and . So the condition to move in the current supporting group is (22) [33]:
The second-level local search is the moving to the other alternative supporting group.
Similarly, operations , are neighbors; processed by the supporting group , which does not process . is the processing time if is processed by . If the intersection of sets between and is bigger than , then it is possible to decrease the makespan by inserting between and . Therefore, the condition to move to the other supporting group is [33]The scheduling may not be feasible after moving the critical operations; it is important to find the conditions that can guarantee the feasibility of the scheduling when we are moving the critical operations. The work [58] proposed two rules to make sure the scheduling of FJSP is feasible when moving critical operations; we will improve these rules for the EFJSP model.
4.7.3. Rules for Moving Operation within the Current Supporting Group
Theorem 5. For a feasible scheduling of an EFJSP model, operations , are processed by the same supporting group and is precedent to ; if one of the following conditions is satisfied, then when becomes the immediate succeeding operation of , the scheduling is still feasible: (1) is the final operation of job, and the set is empty; (2) , , and , the set is nonempty; (3) if and are the operations of a job, they can be swapped.
The proof of (1) and (2) can be referred to in [58]. Under condition (3), when operations and are swapped, which do not influence other operations, the job still can be processed, so the scheduling is feasible.
Theorem 6. For a feasible scheduling of an EFJSP model, operations , are processed by the same supporting group and is precedent to ; if one of the following conditions is satisfied, then when becomes the immediate precedent operation of , the scheduling is still feasible: (1) is the first operation of job, and the set is empty; (2) , , and , the set is nonempty; (3) if and are the operations of a job, they can be swapped.
The proof of (1) and (2) can be seen in [58] and the proof of (3) is the same as Theorem 5.
4.7.4. Rules for Moving Operation to the Other Supporting Groups
Theorem 7. For a feasible scheduling of an EFJSP model, operations , are neighbors, processed by the same supporting group, and is the immediate precedent operation of ; the supporting group is the alternative supporting group of , which will be inserted between and ; if the two following conditions are met simultaneously, then the scheduling is still feasible: (1) is the final operation of job, and the set is empty, or , , and , the set is nonempty; (2) is the first operation of job, and the set is empty, or , , and , the set is nonempty.
The proof can be referred to in [58].
4.7.5. Local Search Algorithm
With the three theorems, the scheduling obtained after moving the critical operations is feasible. The detailed procedure to obtain acceptable scheduling from the neighborhood structure is described in Algorithm 1.
| ||||||||||||||||||||||||||||||||
4.8. Improved DE with Local Search
The improved DE with local search is depicted as follows.
Step 1. Set the size of the population , scale factor , crossover probability , and maximum number of generations .
Step 2. Initialize the population, when assigning supporting groups, the number of chromosomes selecting the supporting group is with the method of the global assignment, and the others select their supporting groups randomly.
Step 3. Evaluate each chromosome.
Step 4 (mutation). Generate donor vectors , .
Step 5 (crossover). Generate trial vectors , .
Step 6 (selection). Determine target vectors , , by one-to-one selection operator for the next generation.
Step 7 (local search). Choose the chromosome whose makespan is the biggest one in , , perform the local search to the chromosome, and if a new chromosome is found whose makespan is smaller than that one, then it will be replaced by the new chromosome.
Step 8. If , then repeat Steps to ; otherwise, stop.
5. Experiment Design and Computational Results Analysis
In order to analyze the performance of the improved differential evolution algorithm with local search strategies (IDE&LS) proposed in Section 4, we test the algorithm through some practical instances from flight deck scheduling. All the instances are also solved by the general genetic algorithm (GA), differential evolution (DE) algorithm, and improved differential evolution (IDE) algorithm without local search strategies; their computational results are compared with that of the proposed algorithm. In the encodings of GA and DE, the supporting group is selected randomly, and the chromosome is not decoded to an active scheduling.
5.1. Experiment Design
All the methods are implemented in MATLAB 2013(a) on 2.50 GHz Intel Core i5-3210m CPU, 4 GB of RAM, Windows 7.0. There are five instances based on the flight deck scheduling. In each instance, there are 5 types of carrier-based aircrafts considered, which include a helicopter (number 1), a warning airplane (number 2), an escort fighter (number 3), an antisubmarine aircraft (number 4), and some attack fighters. In different instances, the amounts of attack fighters are different.
Instance 1. There are four attack fighters (numbers 5–8).
Instance 2. There are six attack fighters (numbers 5–10).
Instance 3. There are eight attack fighters (numbers 5–12).
Instance 4. There are ten attack fighters (numbers 5–14).
Instance 5. There are twelve attack fighters (numbers 5–16).
The order of taking off is helicopter, warning airplane, escort fighter, antisubmarine aircraft, and attack fighters. The supporting operations of a carrier-based aircraft are shown in Figure 7; there are 12 operations (A–L, numbers 1–12) to support a carrier-based aircraft, but some carrier-based aircrafts are different; for example, the helicopter and warning airplane are without weapon mount, and the helicopter does not need to catapult.
There are 30 supporting groups; operations that each supporting group can process and processing time (in minutes) are shown in Table 4.
Different population sizes and iterations are tested, and computational results showed that all algorithms converge fast when population size , and iterations . For other parameters of the algorithms, [59] presents some experiential value for the crossover probability, mutation probability, and GGAP for the GA, and [60] suggests the value of scale factor and crossover probability in most cases for the DE. Based on their studies, we conducted some sensitivity analysis on the value of the parameters, which help us find their suitable value in our problem.
Figure 8 presents the computational results for the IDE&LS to solve Instance 3, when the value of scale factor varies from 0.1 to 0.9. The makespan is the average value for results of 100 times’ run of the algorithm. It can be seen that the best solution is obtained when . Figure 9 presents the results when the value of changes from 0.1 to 0.95, and we can see that the best solution is obtained at . Similarly, we estimate the value for other parameters. Thus, for DE, IDE, and IDE&LS, we set , , , and , while for GA, we set , , , , and .
5.2. Experimental Results and Analysis
Each method is run 100 times in each instance; calculating the average results, the experiment results are shown in Table 5, and the “makespan” is the object (in minutes).
Table 5 summaries the average performance of four methods in five experimental instances. The best results are presented in bold. The statistically significant improvements of the best result over competitors are indicated with asterisks (two-sample t-test at the default 0.05 significance level), followed by value in brackets [61]. As we can see from Table 5, IDE&LS always get the lowest average value and statistically better than GA and DE in all settings. Compared with the state-of-the-art IDE, IDE&LS (81.10) still have statistically lower value than IDE (83.40) in the fifth case. These results demonstrate the benefit of the proposed method in this paper.
For Instance 5, one experimental result of each method is selected randomly from 100 and its convergence curve is shown in Figure 10.
From the above computational results, we can see that the IDE&LS can obtain much better solutions than GA, DE, and IDE without local search, and also it converges much faster than other methods in the same number of iterations. That is because in the initializing process of the IDE&LS, we utilized some heuristic strategies to generate better and feasible chromosomes, which increase the search efficiency in the beginning of the algorithm. Further, the local search strategies integrated in the method help to improve the quality of chromosomes of each generation, which increase the search quality.
In the military operation, the scheduling plans of supporting groups for different situations are usually made before the beginning of the battle, and the commanders concern more on the optimality of the plan. Thus, in the above analysis, we compared the average makespan of the algorithms while ignoring the computing time. Our computational experiments show that, even for the largest scale instance, the computing time of IDE&LS is not over 11 minutes, which is reasonable and can satisfy the requirement of military operation.
5.3. A Feasible Scheduling Scheme
In order to check the priority, parallel operation, and sequence flexibility, a scheduling Gantt chart of Instance 5 is generated by IDE&LS; as shown in Figure 11, the vertical axis represents the number of the supporting group, the horizontal axis represents the processing time, the first or first two digits of the digital representation are the number of carrier-based aircraft, and the latter two represent the number of operation: for example, “507” indicates operation 7 (operation G) of the carrier-based aircraft 5 and “1203” indicates operation 3 (operation C) of the carrier-based aircraft 12.
The results in Figure 11 show the following:(1)There are some vertical lines, which mean the carrier-based aircrafts have no operations: for example, “112” indicates that number 1 carrier-based aircraft has no operation 12 (operation G), which is in line with the reality: the helicopter does not need catapult to take off.(2)Departure time (operation G) is sorted according to helicopter (number 1), warning airplane (number 2), escort fighter (number 3), antisubmarine aircraft (number 4), and fighters (numbers 5–12), because fighters have same priorities, so anyone of which is allowed to take off firstly.(3)In the maintenance of each carrier-based aircraft, there are some operations being processed simultaneously.(4)For carrier-based aircrafts with higher priorities, not all the operations of them must be finished earlier than those with lower priorities, as long as the last operation can be completed earlier. For example, the helicopter (number 1) should take off first, then warning airplane (number 2), but in Figure 11, operation A of warning airplane is processed earlier than helicopter.(5)Operation 4 (operation D) is processed before operation 5 (operation E) for some carrier-based aircrafts, such as numbers 2, 6, 8, 12, 13, and 14; the others are opposite. In conclusion, the scheduling is feasible.
6. Conclusions
In this paper, we investigated a complex scheduling problem drawn from the deck scheduling of supporting operations for carrier-based aircrafts, where precedence constraints, parallel operations, and sequence flexibility should be considered. Such scheduling problem also commonly appears in production and maintenance of huge items, like aircraft, ship, and its engine. An EFJSP model is established to formulate the scheduling problem, and an improved differential evolution algorithm was proposed to solve the problem. Firstly, the codes were initialized with the shortest time and load balancing strategy, in which the random generation and the priority strategies are also integrated. Secondly, the decoding was done in the way of activity scheduling, reflecting the parallel, flexible features of the operations, and the combination of POX cross and MOX cross was used to make chromosomes mutation. Instances based on practical deck scheduling are utilized to test the proposed model and algorithm. Computational results show that our solution approach can present better solutions in reasonable computational time.
Besides the typical flight deck scheduling problem, the approach developed in this paper can also be extended to other classes of huge item production and maintenance scheduling problems, such as aircraft, ship, and its engine.
The problem studied in the paper is a new one, and we solve it by improving the differential evolution algorithm. However, many other algorithms may be improved and used to solve the deck scheduling problem, such as ant colony algorithm, particle swarm optimization, leapfrog algorithm, and bee colony algorithm. Thus, it is an important extension to work on the improvement of these algorithms to make them able to solve the proposed deck scheduling problem and compare with the IDE algorithm in this paper, which may help find more efficient algorithms in future.
Competing Interests
The authors declare that they have no competing interests.
Acknowledgments
This research was supported by the National Natural Science Foundation no. 61273322.