Heuristics for a Two-Stage Assembly-Type Flow Shop with Limited Waiting Time Constraints

Featured Application

Manufacturing. 

Abstract

This study investigates a two-stage assembly-type flow shop with limited waiting time constraints for minimizing the makespan. The first stage consists of m machines fabricating m types of components, whereas the second stage has a single machine to assemble the components into the final product. In the flow shop, the assembly operations in the second stage should start within the limited waiting times after those components complete in the first stage. For this problem, a mixed-integer programming formulation is provided, and this formulation is used to find an optimal solution using a commercial optimization solver CPLEX. As this problem is proved to be NP-hard, various heuristic algorithms (priority rule-based list scheduling, constructive heuristic, and metaheuristic) are proposed to solve a large-scale problem within a short computation time. To evaluate the proposed algorithms, a series of computational experiments, including the calibration of the metaheuristics, were performed on randomly generated problem instances, and the results showed outperformance of the proposed iterated greedy algorithm and simulated annealing algorithm in small- and large-sized problems, respectively.

1. Introduction

Competition in manufacturing industries is intensifying around the world, and these industries are facing changes, such as the diversification of customer requirements, shorter product life cycles, and the transition to a multiproduct small-volume production system. In addition, a new area, such as smart manufacturing, is emerging with the 4th Industrial Revolution. To enhance manufacturing competitiveness and improve productivity, several manufacturers are focusing on reducing the production lead time and minimizing inventory. To achieve these goals, production management and scheduling techniques have emerged as core competencies [1]. Numerous scheduling problems have been studied for various types of products that require assembly operations, considering the production of components and subsequent assembly processes together [2]. For example, Lee et al. [3] introduced a scheduling study of a manufacturing system that produces and assembles the body and vehicle of a fire engine, and Potts et al. [4] dealt with a scheduling problem in make-to-order manufacturing systems, such as PC assembly. In addition, there are scheduling problems with assembly operations arising from various manufacturing systems (refrigerators [5], clothing [6], food [7], and semiconductors [8,9,10,11]).

This study deals with a scheduling problem in a two-stage assembly-type flow shop. The first stage is the component production process in which each component is independently fabricated on a dedicated machine. The components made in the first phase are moved to the second stage and assembled into the final product. The assembly operation in the second stage can start after all necessary components have completed in the first stage. The completion time of each product is defined as the time when the assembly operation completes in the second stage. To enhance the flow shop productivity, this study aims to minimize the makespan, which is equal to the completion time of the last scheduled job.

This study constrains the waiting times between stages 1 and 2. This implies that components completed in the first stage must be entered into the second stage for the assembly operation within the limited waiting times. Therefore, it is necessary to complete the operations of the first stage considering the time when the assembly operation can start in the second stage. Figure 1a,b illustrates example schedules with two jobs in the assembly flow shop with and without limited waiting times, respectively. The starts in the first stage in Figure 1a are delayed observing the limited waiting times w₂₁ and w₂₂, whereas the second job in Figure 1b can start without any delay. In general, waiting times are limited to prevent quality deterioration owing to increased waiting times. There are various cases considering the waiting time constraints in manufacturing industries, such as semiconductors, batteries, food, steelmaking, and biotechnology [12,13,14].

Since Lee et al. [3] introduced a two-stage assembly-type flow shop problem, there have been many studies on the scheduling problems, and two review papers (Komaki et al. [2] and Framinan et al. [15]) were recently published. Many studies have sought to minimize the makespan. The makespan minimization problem was demonstrated to be strongly NP-hard in [3], even though only two machines existed in the first stage. Lee et al. [3] also developed three heuristics based on Johnson’s algorithm [16] and suggested a branch-and-bound (B&B) algorithm. Potts et al. [4] showed that an optimal solution for the problem with more than two machines in the first stage is always in permutation schedules where the sequences on all machines in the flow shop are the same. Additionally, Hariri and Potts [17] and Haouari and Daouas [18] provided B&B algorithms, while Sun et al. [19] proposed heuristic algorithms. On the other hand, Koulamas and Kyparisis [20] considered the extended problem in which there are three stages and they developed heuristic algorithms. Additionally, Sung and Juhn [21] proposed a B&B algorithm for the problem of outsourcing one type of component subject to the job-dependent lead time in the first stage. Wu et al. [22] addressed two scenario-dependent jobs processing times and proposed a B&B algorithm and metaheuristics to minimize the robust makespan, and Wu et al. [23] considered a processing time-based learning effect and proposed a B&B algorithm and several metaheuristics. On the contrary, for other objectives, Lee and Bang [24] proposed a B&B algorithm to minimize total tardiness, whereas Lee [25,26] developed B&B algorithms to minimize total completion times and total weighted tardiness, respectively. Additionally, there have been various studies on the assembly-type flow shop problems [27,28,29,30,31,32].

Although typical assembly-type flow shop scheduling problems have been studied by many researchers, only a few studies have considered waiting time constraints or time lags. According to recent review papers, it is necessary to study scheduling problems with waiting time constraints, but there are only a few studies that considered no-wait constraints. Mozdgir et al. [33] introduced a no-wait two-stage assembly flow shop and proposed three metaheuristic algorithms: a genetic algorithm, differential evolution algorithm, and population-based variable neighborhood algorithm. In addition, Ji et al. [34] provided a hybrid particle swarm optimization algorithm, and Li et al. [35] proposed an iterated local search method. Shao et al. [36] suggested an iterated local search method and a variable neighborhood search. Most of the studies related to the no-wait assembly flow shop considered metaheuristic algorithms [37,38,39,40] as solution methodologies because these problems are NP-hard.

The considered scheduling problem is defined as AF(m,1)|max-wait|C_max in three-field notation suggested by Graham et al. [41]. AF(m,1) represents an assembly-type flow shop where there are m machines to fabricate components in stage 1 and a single assembly machine in stage 2. Max-wait denotes the limited waiting constraints between the two stages. C_max represents the makespan, which is the objective function of the scheduling problem. Assuming that there is only one machine in the first stage, this scheduling problem becomes a two-machine flow shop problem with limited waiting time constraints (F2|max-wait|C_max), which has been proven to be NP-hard in [42]. Therefore, this problem is also NP-hard.

To the best of the authors’ knowledge, no assembly flow shop study has considered the limited waiting time constraints that are generalized from no-wait. Thus, as its main contribution, this study is the first attempt to consider the assembly flow shop with limited waiting times to fill part of the existing research gap. Additionally, this paper proposes various solution methodologies, including the mathematical formulation, priority rule-based list scheduling, constructive heuristic, and three metaheuristic algorithms. Furthermore, we suggest a method that converts a sequence obtained by the heuristics into a complete schedule with waiting time constraints.

This study aims to minimize the makespan in a two-stage assembly flow shop with limited waiting time constraints. We provide a mixed-integer programming (MIP) to define the considered problem clearly and use a commercial optimization solver, CPLEX 12.10, to solve the MIP. However, because this problem is NP-hard, there is a limitation in obtaining an optimal solution despite using the solver. Thus, we propose various heuristic algorithms, such as priority rule-based list scheduling, constructive heuristic, and metaheuristic to solve the large-sized problem within a short computation time. To evaluate the proposed algorithms, we performed a series of computational experiments, including the calibration of the metaheuristics, on randomly generated problem instances and reported the results.

The remainder of this paper is organized as follows. Section 2 provides the assumptions made in this study and notation for a clear description and provides a mathematical model, while Section 3 proposes heuristic algorithms. Section 4 reports the computational tests to evaluate the performance of the heuristic algorithms as well as the mathematical model. Finally, Section 5 concludes this study and presents future research.

2. Problem Description

This section describes the scheduling problems considered in more detail with assumptions and mathematically defines the problem through an MIP formulation. In this study, there are n jobs to be scheduled, and it is assumed that information regarding the jobs is provided in advance. The first stage consists of m dedicated machines that fabricate m different components, whereas there is a single assembly machine to assemble the m components into a final product in the second stage. The assembly operations of all jobs must start within limited waiting times given to the jobs after completing the fabrication of their components. The objective function of the scheduling problem is to minimize the makespan, which is equal to the completion time of the last job. The other assumptions made in this study are as follows:

• All jobs can be started at time zero;
• Preemption is not allowed;
• Not all machines can process multiple jobs simultaneously. In other words, machines can process only one job at a time;
• The distances and delivery times between the two stages are ignored.

In this problem, there are (n!)^(m+1) alternative sequences, because n! sequences are possible for each machine. However, there is an optimal solution among n! permutation schedules in which the operating sequences of the jobs are the same on the machines. This can be proven according to the proof by Tozkapan et al. [43] that permutation schedules are dominant for the two-stage assembly flow shop to minimize the total completion time, and this proof is sufficient to show that permutation schedules are also dominant for any regular performance measure, including makespan. Although this study considers the limited waiting time constraints, the left-shift schedules in which some operations begin earlier without delaying any other operations are dominant, because a delayed start increases the waiting time. Furthermore, in practical production lines, permutation schedules are commonly utilized to ensure simplicity of managing work, flexibility of material handling, and constrained buffer space. Therefore, this study only considers permutation schedules; that is, all sequences on the machines in the considered flow shop are the same.

Table 1. Notation for the description of the algorithms proposed in this study.

Symbol	Definition
n	number of jobs
i, j	job indices
m	number of machines in the first stage
k	machine index (k = 1, …, m, m + 1); if k = 1, …, m, it represents the first stage machines, otherwise, the second stage machine
pik	processing time of job i on machine k
wik	waiting time of job i between machine k and machine (k + 1)
r	position index
[r]	index of the job in rth position of a permutation schedule
xir	equals to 1 if job i is scheduled in rth position, 0 otherwise
s[r]k	starting time of the rth job on machine k
c[r]k	completion time of the rth job on machine k

provides the notation for a clear description of the algorithms proposed in this study.

The following is the MIP formulation for the considered scheduling problem.

$$\begin{array}{}\mathrm{(1)}& \mathrm{Minimize}& c_{\left[n\right]\left(m+1\right)}& \mathrm{(2)}& \mathrm{subject}\mathrm{to}& s_{\left[r\right]k}+{{\displaystyle \sum }}_{i=1}^n{p}_{ik}{x}_{ir}\le s_{\left[r+1\right]k}& r\le n-1\mathrm{and}k\le m\mathrm{(3)}& & s_{\left[r\right]k}+{{\displaystyle \sum }}_{i=1}^n{p}_{ik}{x}_{ir}\le s_{\left[r\right]\left(m+1\right)}& \forall r\mathrm{and}k\le m\mathrm{(4)}& & s_{\left[r\right]k}+{{\displaystyle \sum }}_{i=1}^n\left(p_{ik}+w_{ik}\right)x_{ir}\ge s_{\left[r\right]\left(m+1\right)}& \forall r\mathrm{and}k\le m\mathrm{(5)}& & s_{\left[r\right]\left(m+1\right)}+{{\displaystyle \sum }}_{i=1}^n{p}_{i\left(m+1\right)}{x}_{ir}=c_{\left[r\right]\left(m+1\right)}& \forall r\mathrm{(6)}& & {{\displaystyle \sum }}_{r=1}^n{x}_{ir}=1& \forall i\mathrm{(7)}& & {{\displaystyle \sum }}_{i=1}^n{x}_{ir}=1& \forall r\mathrm{(8)}& & s_{\left[r\right]k},c_{\left[r\right]\left(m+1\right)}\ge 0& \forall r,k\mathrm{(9)}& & x_{ir}\in \left\{0,1\right\}& \forall i,r\end{array}$$

The objective Function (1) is the minimization of the makespan, which is equal to c_[n](m+1), the completion time of the last scheduled job [n] in the second-stage machine, that is, machine (m + 1). Constraints (2) and (3) define the starting times on the same machine and between the two stages, respectively. Constraint (4) ensures that jobs must maintain the limited waiting times between both stages. Constraint (5) computes the completion times of the jobs on the machine (m + 1). Constraints (6) and (7) consider only the permutation schedules. That is, each job can only be sequenced once, without being partitioned. Constraints (8) and (9) define the domain of the decision variables.

3. Heuristic Algorithms

The MIP formulation can obtain an optimal solution for the considered problem using a commercial solver. However, because this problem is NP-hard, solvers may require a considerable amount of computational time to achieve an optimal solution for large or practical size problems. Therefore, this study focuses on heuristic algorithms to find a good solution within a short computation time.

This section proposes three types of heuristic algorithms: priority rule-based scheduling methods, a constructive algorithm, and three metaheuristic algorithms. In the heuristic algorithm procedures, we calculate the completion times of jobs using the following equations: the first two Equations (10) and (11) are for the first job (r = 1), whereas Equations (12) and (13) are for the second to the last job (r = 2, …, n).

$$c_{\left[1\right]\left(m+1\right)}=MAX\left(p_{\left[1\right]k}\forall k\le m\right)+p_{\left[1\right]\left(m+1\right)}$$

(10)

$$c_{\left[1\right]k}=MAX\left(p_{\left[1\right]k},c_{\left[1\right]\left(m+1\right)}-w_{\left[1\right]k}\right) \mathrm{for} k=1,\dots ,m$$

(11)

$$c_{\left[r\right]\left(m+1\right)}=MAX\left(MAX\left(c_{\left[r-1\right]k}+p_{\left[r\right]k}\forall k\le m\right),c_{\left[r-1\right]\left(m+1\right)}\right)+p_{\left[r\right]\left(m+1\right)} \mathrm{for} r=2,\dots ,n$$

(12)

$$c_{\left[r\right]k}=MAX\left(c_{\left[r-1\right]k}+p_{\left[r\right]k},c_{\left[r\right]\left(m+1\right)}-p_{\left[r\right]\left(m+1\right)}-w_{\left[r\right]k}\right) \mathrm{for} r=2,\dots ,n$$

(13)

3.1. Priority Rule-Based Scheduling

Priority rule-based list scheduling is a commonly used method in many manufacturing systems because it is intuitive and easy to implement. Such a method sorts jobs according to priority values and then assigns the sorted jobs to the machines when the machines become available. In general, the order of jobs can be generated from a priority rule based on the characteristics of the considered problem. As this study considers only permutation schedules, the priority rule-based scheduling can find feasible schedules by ordering jobs in ascending order of the priority values. The following six priority rules generate six feasible schedules, and the completion times of the jobs in a given schedule are calculated using Equations (10)–(13).

• LS1: $MAX\left(p_{ik}\forall k\le m\right)$;
• LS2: $p_{i\left(m+1\right)}$;
• LS3: $MAX\left(p_{ik}\forall k\right)$;
• LS4: $MAX\left(p_{ik}\forall k\le m\right)+p_{i\left(m+1\right)}$;
• LS5: ${{\displaystyle \sum }}_{k=1}^m{p}_{ik}/m+p_{i\left(m+1\right)}$;
• LS6: $MIN\left(MAX\left(p_{ik}\forall k\le m\right),p_{i\left(m+1\right)}\right)$.

The proposed priority rules are modified from the shortest processing time rule. In the considered flow shop, the start of the second stage operation is affected by the longest processing time of the first stage, not the shortest. This is because the second stage operation can start after all the operations in the first stage complete. Thus, the longest processing times in the first stage are considered. LS1 considers the first stage only, LS2 focuses on the second stage, and LS3–6 consider both. Particularly in LS5, it considers the average processing time, not the longest, for the first stage. LS6 is inspired by Johnson’s rule [16] which provides an optimal solution for a classical two-machine flow shop makespan problem.

3.2. Modified NEH Algorithm (MNEH)

This subsection provides a constructive heuristic algorithm based on the NEH algorithm developed by Nawaz et al. [44]. This NEH algorithm is well known as an effective and efficient heuristic for flow shop scheduling problems, and thus many researchers have used the NEH for various flow shop problems. The original procedure begins with an initial seed sequence obtained by sorting jobs in descending order of total processing times (i.e., longest processing time order), and then it creates a complete schedule in an insertion-based constructive manner. At each iteration, a job in front of the seed sequence is inserted into the best position in the current partial schedule and then it is removed from the seed. These iterations are repeated until obtaining a complete schedule.

In this study, the modified version uses the best priority rule to obtain an initial seed sequence, instead of the longest processing time order. The best rule will be demonstrated in the computational experiments (Section 4). Additionally, after obtaining a partial schedule with the insertion method at each iteration, an interchange method is applied to improve the partial schedule. That is, after job (i) is inserted into the current best position at each iteration, partial schedules obtained by interchanging job i and other jobs are evaluated, and then the minimum makespan schedule is moved to the next iteration. Figure 2 shows the procedure for this algorithm.

3.3. Genetic Algorithm

The genetic algorithm (GA) is an evolutionary population-based optimization algorithm inspired by genetics and Darwin’s theory of evolution, and it is based on the survival of the fittest or natural selection [45]. GA is one of the most popular metaheuristics in the field of optimization. GA involves many operators and parameters, and the performance depends on the procedure design, operators, and parameters. The following subsections describe the design of the proposed GA.

3.3.1. Solution Representation

In the GA, solutions are expressed in a chromosome structure, and the performance of the algorithm depends on the chromosome structure. Because this study considers only permutation schedules, the chromosome of a solution is represented in a permutation.

3.3.2. Initial Population

The GA is a population-based heuristic algorithm. Priority rule-based scheduling and MNEH algorithm are used to generate an initial population. That is, six priority rules generate six solutions, and the MNEH algorithm generates six solutions with each of the six solutions by the rules, i.e., a total of 12 solutions. The remainder of the initial population is randomly generated.

3.3.3. Solution Representation

Fitness represents how good a solution is. As this study has the objective of minimizing the makespan, the fitness of a solution is equal to the makespan obtained by Equations (10)–(13). A lower makespan indicates better fitness.

3.3.4. Selection

The selection chooses parents randomly from the current population to generate offspring. The selection is based on the fitness values of chromosomes to generate offspring that inherit good genes. In other words, good chromosomes with low fitness values are likely to be selected as parents. This study considers two commonly used methods (tournament and roulette) in the literature for selection. In the tournament method, four solutions are selected randomly from the population, and two winner solutions from the semi-finals are selected. That is, a better of the first two solutions and a better of the last two solutions are paired. For the roulette methods, the inverse (f_π) of the objective function value (C_max(π)) for each solution (π) in the population is computed, that is, $f_{\mathsf{\pi }}=1/C_{max}\left(\mathsf{\pi }\right)$ and let $F=\sum f_{\mathsf{\pi }}$. The selection probability of each solution in the population is then obtained by $pro{b}_{\mathsf{\pi }}=f_{\mathsf{\pi }}/F$. Based on these selection probabilities of solutions, two solutions are selected randomly as parents. Note that the proposed GA uses a better one of two methods after computational calibration (in Section 4).

3.3.5. Crossover

The crossover operation aims to generate better offspring by exchanging the information of the selected parents. In this study, six types of crossover operation are considered: one-point order crossover (OX1), two-point order crossover (OX2), similar job crossover (SJX), two-point similar job crossover (SJX2), similar block crossover (SBX), and two-point similar block crossover (SBX2). Like the selection operation, the proposed GA uses the best of these six methods. For a description of these crossovers, let parent₁ and parent₂ be the selected parents to generate offspring.

• Procedure: OX1

  Step 0.

  Let point₁ be a cutoff point randomly selected from parent₁.

  Step 1.

  Give the front part (from the first to point₁) of parent₁ to offspring.

  Step 2.

  Remove the jobs, that are given to offspring in Step 1, from parent₂.

  Step 3.

  Sequence jobs remaining in parent₂ into the unoccupied positions of offspring from left to right in the order that they appear in parent₂.

• Procedure: OX2

  Step 0.

  Let point₁ and point₂ be cutoff points randomly selected from parent₁, respectively.

  Step 1.

  Give the middle part (between point₁ and point₂) of parent₁ to offspring.

  Step 2.

  Remove the jobs, that are given to offspring in Step 1, from parent₂.

  Step 3.

  Sequence jobs remaining in parent₂ into the unoccupied positions of offspring from left to right in the order that they appear in parent₂.

• Procedure: SJX

  Step 0.

  Give the jobs in the same position in both parents to offspring.

  Step 1.

  Let point₁ be a cutoff point randomly selected from parent₁.

  Step 2.

  Give the front part (from the first to point₁) of parent₁ to offspring.

  Step 3.

  Remove the jobs, that are already given to offspring, from parent₂.

  Step 4.

  Sequence jobs remaining in parent₂ into the unoccupied positions of offspring from left to right in the order that they appear in parent₂.

SJX2 modified from SJX selects two cutoff points and gives the middle part between the two points of parent₁ to offspring, as in OX2. Additionally, SBX and SBX2 are very similar to SJX and SJX2, respectively. The only difference is that, in Step 0 of SJX (and SJX2), two adjacent jobs are defined as a block and not an individual job but blocks in the same position in both parents are given to offspring. The detailed procedures of SJX2, SBX, and SBX2 are omitted because the rest of the steps are the same.

3.3.6. Mutation

The mutation operation increases the diversity of chromosomes in the population and helps to escape the local optimum. This operation partially alters a solution to generate new offspring with a new chromosome. In this study, two types of mutation schemes are considered: insertion and interchange. The insertion with probability p_IS inserts a randomly selected job into a randomly selected position, whereas the interchange with probability (1 − p_IS) exchanges the positions of two randomly selected jobs.

3.3.7. Improvement (Local Search)

Usually, Gas and other metaheuristics adopt local search methods to improve solutions. The proposed GA also uses a local search strategy of the insertion and interchange used in the mutation. The local search starts when the current best solution does not improve during a predetermined number of consecutive generations, and insertion with probability p_IS or interchange with probability (1 − p_IS) is applied n times to the current best solution in the population, where n is the number of jobs. If the new solution is better than the current best solution, the new solution replaces the current best solution. To avoid an excessively long computation time, we limit the number of local searches to the current best solution to n times.

3.3.8. Restart

As the procedure of generating the next generation in GA iterates, the population can converge prematurely and get stuck in a local optimum. To avoid premature convergence and enhance the quality of solutions in the population, we use a restart procedure suggested by Ruiz and Maroto [46]. This restart procedure starts when the current best solution does not improve during a predetermined number of consecutive generations. The following is the restart procedure.

• Procedure: Restart

  Step 0.

  The chromosomes in the current population are sorted in ascending order of their fitness values.

  Step 1.

  Keep the top 20% of chromosomes and remove the remaining 80% from the population.

  Step 2.

  20% of the population size are newly generated by randomly selecting from the kept chromosomes and then mutating once based on the insertion.

  Step 3.

  20% of the population size are newly generated by randomly selecting from the kept chromosomes and then mutating once based on the interchange.

  Step 4.

  40% of the population size are generated randomly.

3.3.9. Termination Criterion

The GA procedure is terminated at the maximum computation (CPU). In other words, the GA procedure stops when the maximum CPU time elapses.

3.3.10. Entire Procedure of the Proposed GA

The entire procedure of the proposed GA is in Figure 3, in which POP, P_size, p_c, p_m, and p_IS denote the population, population size, crossover probability, mutation probability, and insertion probability for a mutation operation, respectively. In addition, P_l and P_r denote the parameters that trigger the local search and restart procedures, respectively, whereas g_l and g_r indicate the number of consecutive generations that the current best solution does not improve. Additionally, random() represents a function that generates a random number from a uniform distribution with a range (0, 1).

3.4. Iterated Greedy Algorithm

The iterated greedy (IG) algorithm is a metaheuristic developed by Ruiz and Stutzle [47] for the permutation flow shop problem to minimize the makespan. IG is an extension of the NEH algorithm. The main strategy of IG involves the insertion method of NEH stochastically to find better solutions. Not only NEH but also IG was developed originally and particularly for flow shop scheduling problems, and IG has been verified to work well in many research studies [48,49,50,51]. The advantage of IG is that the procedure is simple, and there are few parameters that require calibration.

IG is composed of four phases: destruction, construction, local search, and acceptance, and these four phases are executed iteratively. IG also starts with an initial seed sequence. In the destruction phase, d jobs randomly selected from the incumbent solution are removed, where d is a control parameter called destruction size. Then, the construction phase generates a new complete solution by inserting the removed jobs in the constructive way of the NEH. After that, a local search is performed to improve the newly generated schedule. Finally, the acceptance phase determines whether to accept the new schedule, as in the uphill movement of a simulated annealing algorithm.

In the IG, an initial (incumbent) solution (π) is obtained from the MNEH (in Section 3.2), and the destruction phase is applied to the incumbent solution. As stated briefly above, in the destruction phase, a given number of d jobs are removed from π, generating two partial schedules. The first one (π_R) consists of the d jobs removed from π. The second one (π_D) contains the (n − d) remaining jobs, i.e., the original one without the removed jobs. Then, in the construction phase, jobs in π_R are inserted into the best position of π_D as in NEH. After the construction phase, a new complete solution (π’) with size n is created. Then, the local search procedure which is introduced in Section 3.3.7 of GA is executed to improve the new solution. For the new solution, the acceptance phase determines whether to replace the current solution with a new one for the next iteration. If C_max(π’) < C_max(π), the transition to π’ is accepted. Otherwise, the transition is accepted with probability

$$ex{p}^{\left(-\Delta /\tau \right)},$$

(14)

where Δ represents the difference between the objective function values of the two solutions and is defined as Δ = C_max(π’) − C_max(π), and τ is an adjustable parameter (called temperature) in the IG. The temperature value is obtained using Equation (15)

$$\tau =\frac{{{\displaystyle \sum }}_{i=1}^n{{\displaystyle \sum }}_{k=1}^{m+1}{p}_{ik}}{10n\left(m+1\right)},$$

(15)

suggested by Osman and Potts [52] for the permutation flow shop scheduling problem. Note that, in IG, the temperature is constant instead of decreasing as in the simulated annealing. The proposed IG repeats the destruction, construction, local search, and acceptance until the maximum computation time elapses. Figure 4 shows the entire IG procedure.

3.5. Simulated Annealing Algorithm

Simulated annealing (SA) mimics the physical annealing process, and it is a metaheuristic optimization algorithm that works dynamically and iteratively to search for a better solution [53]. SA has been commonly used to solve various combinatorial optimization problems including scheduling problems. SA also begins with an initial seed sequence and attempts to generate a better solution by repeating small alterations to the current solution. However, such attempts may lead to being stuck in a local optimum. To escape the local optimum, SA occasionally allows uphill movements that accept worse solutions deteriorating the objective function value (makespan). Uphill movements are allowed with an acceptance probability of Equation (14).

In this study, SA also begins with an initial seed sequence obtained from MNEH and uses the insertion with probability p_IS and interchange with probability (1 − p_IS) to generate a neighborhood solution (π’) of a current solution (π). If C_max(π’) < C_max(π), the transition to π’ is accepted. Otherwise, the transition is accepted with Equation (14), and the initial τ is obtained using Equation (15). SA repeats these generation and transition procedures L times at the current temperature, where L is an epoch length as a parameter. After repeating L times, the temperature decreases gradually by a cooling function as τ←ατ, where 0 < α < 1, and this SA procedure terminates when the maximum CPU time elapses. Figure 5 shows the procedure of the SA.

4. Computational Experiments

This section evaluates the proposed algorithms on randomly generated problem instances. All the algorithms were coded in Java, and the tests were conducted on a personal computer with Intel Core i7-8700 CPU (3.2 GHz) and 16 GB RAM. To generate problem instances, we used the same method in [25]. In the first stage, there are m dedicated machines, and three levels of m were used, that is, m = (2, 5, 10), whereas there is a single machine in the second stage. Thus, there are a total of (m + 1) machines in the tests. The processing times were generated from a uniform distribution.

Table 2. Processing time distribution.

Set	First Stage	Second Stage
A	U(1, 100)	U(1, 100)
B	U(1, 80)	U(20, 100)
C	U(20, 100)	U(1, 80)

shows the discrete uniform distribution U(a, b) with a range between a and b. In Set A, the workloads of the two stages are equal. On the contrary, in Sets B and C, the second and first stages become bottlenecks, respectively. Limited waiting times were also generated from U(1, 100).

The first experiment evaluated the mixed integer programming formulation (MIP) through a commercial optimization solver CPLEX 12.10. In the experiment, we considered five levels of jobs (n = 10, 20, 30, 40, and 50) and generated five instances for each of the (m, n) combinations. In addition, the computation time limit (T_L) for each instance was set to 1800 s to avoid excessive computation times. A summary of the results is presented in

Table 3. Performance of MIP using CPLEX.

m	n	CPUT 1			NI 2
		Set A	Set B	Set C	Set A	Set B	Set C
2	10	0.1 [0, 0.2]	0.1 [0, 0.1]	0 [0, 0]	0	0	0
	20	58.9 [0.1, 172.2]	0.1 [0.1, 0.1]	0.1 [0.1, 0.1]	0	0	0
	30	716.2 [0.3, TL]	0.6 [0.1, 2.2]	0.3 [0.2, 0.4]	1	0	0
	40	754.7 [6.2, TL]	0.4 [0.2, 0.5]	0.4 [0.2, 0.5]	2	0	0
	50	TL	0.8 [0.5, 1.3]	0.7 [0.4, 0.9]	5	0	0
5	10	1.2 [0, 2.7]	0.4 [0, 1.3]	0.1 [0, 0.1]	0	0	0
	20	TL	98.2 [0.2, 489.9]	2.8 [0.1, 12.9]	5	0	0
	30	TL	360.6 [0.4, TL]	1.2 [0.6, 2.5]	5	1	0
	40	TL	15.6 [0.5, 70.9]	177.8 [0.9, 873.8]	5	0	0
	50	TL	344.6 [1.6, 1630.4]	207.8 [2.6, 998.8]	5	0	0
10	10	6.3 [2.5, 13]	0.8 [0.1, 2.3]	1.4 [0.1, 2.4]	0	0	0
	20	1440.7 [3.4, TL]	1075.8 [1.8, TL]	1080.4 [0.6, TL]	4	2	3
	30	TL	1086.3 [5.6, TL]	527.5 [3.3, TL]	5	3	1
	40	TL	1419.2 [54.8, TL]	1455.2 [76, TL]	5	3	4
	50	TL	805.5 [26.2, TL]	1756.3 [1637.6, TL]	5	2	3

¹ Average [min, max] computation time, where T_L = 1800 s. ² Number of instances not terminated within 1800 s.

, including the average computation times and the number of instances not terminated until the time limit T_L. As can be observed from the table, the ACPUT in Set A increased exponentially as (m, n) increased. For m = (5 and 10), CPLEX found an optimal solution only for instances with n = 10 within 1800 s. On the contrary, CPLEX solved instances of Sets B and C relatively faster than those in Set A. One drawback of CPLEX in this test is its wide range of computation times. For (m = 10, n = 20) in all three sets, the minimum CPU time was only a few seconds, whereas the maximum time was 1800 s. If CPLEX shows a significant range of CPU times, the estimates for solving times are inaccurate and even impossible; hence, using CPLEX may be impractical.

Next, we tested the priority rule-based list scheduling methods to determine the best method for offering an initial seed sequence for MNEH. The same instances with n = 10, 20, 30, 40, and 50 were used in these tests. To compare the list scheduling methods, the relative deviation index (RDI) was used as a measure, defined as (obj_# − obj_best)/(obj_worst − obj_best) for each instance where obj_# represents the makespan using priority rule #, and obj_best and obj_worst represent the best and worst, respectively. According to the definition of RDI, the lower the RDI, the better the performance.

A summary of the results is in

Table 4. Comparison of the list scheduling methods (the best values are in bold).

Set	LS1	LS2	LS3	LS4	LS4	LS6
A	0.286 (29) 1	0.886 (0)	0.242 (29)	0.527 (12)	0.466 (11)	0.621 (2)
B	0.165 (42)	0.906 (0)	0.480 (9)	0.459 (11)	0.570 (5)	0.436 (9)
C	0.195 (40)	0.900 (0)	0.488 (7)	0.513 (13)	0.518 (8)	0.456 (13)
Overall	0.215 (111)	0.897 (0)	0.403 (45)	0.500 (36)	0.518 (24)	0.504 (24)

¹ Average RDI, number of instances (out of 75) that the method found the best solutions.

which provides the average RDI and number of instances (out of 75) that LS# found the best solutions. As observed from the table, LS1 outperformed the other rules. This indicates that the first stage on which LS1 focuses is more important than the second stage, probably because the decision on sequencing jobs on the parallel machines in the first stage must consider the limited waiting time constraints. However, in the second stage, there is a single assembly machine, and the sequence is equivalent to the sequence in the first stage because this study considers only permutation schedules. Thus, if a shop manager wants to focus on either stage, the result recommends the first stage. In summary, LS1 showed the best performance among the proposed list scheduling rules, therefore LS1 will offer an initial seed sequence for MNEH in the subsequence experiments.

To check the efficiency of the interchange method in the proposed MNEH, comparison tests were performed on the instances with up to n = 50. In this test, initial seed sequences were obtained using LS1.

Table 5. Improvement by the interchange method in the proposed MNEH algorithm.

m	n	Set A	Set B	Set C
2	10	0.181 1	0.000	0.000
	20	−1.091	0.000	0.048
	30	0.155	0.011	−0.024
	40	−0.720	0.000	0.000
	50	−1.638	0.000	0.000
5	10	−0.935	0.000	0.000
	20	−1.418	0.000	−0.368
	30	0.053	−0.353	−0.178
	40	−0.988	−0.017	−0.369
	50	−0.909	−0.140	0.116
10	10	−1.473	0.076	−0.260
	20	−1.141	−0.779	−0.835
	30	−0.993	−0.204	−0.353
	40	−1.224	−0.451	−0.145
	50	−0.599	−0.050	−0.311
Overall		−0.849	−0.127	−0.179

¹ Percentage change, i.e., 100 × (obj_MNEH − obj_NEH)/obj_NEH.

and Figure 6 show the results that show the effectiveness of the interchange method in MNEH. The table reports the percentage change defined as 100 × (obj_MNEH − obj_NEH)/obj_NEH. Note that the negative percentage change indicates that MNEH found a better solution than NEH. As revealed in the table, MNEH worked better than NEH, which indicates that the simple interchange method can improve the solution quality. In addition, the improvement was more apparent when the problem size increased. The same result was obtained in Set A than in Sets B and C as shown in Figure 6. Thus, it can be concluded that the interchange method used in MNEH worked well. In addition, although the interchange procedure was added, MNEH provided a solution for all instances in less than a second.

To achieve the best performance of the proposed metaheuristic algorithms (GA, IG, and SA), calibration experiments were performed. In general, calibration before using a metaheuristic is essential because the performance depends significantly on the control parameters. In other to calibrate the metaheuristics, we generated three instances for each combination of (m, n), with three levels of machines (m = 2, 5, and 10) and four levels of jobs (n = 50, 100, 300, and 500), on Set A. The algorithms solved each instance independently three times, and the average value resulting from the three runs was used to compute the RDI for comparison. For the termination condition, we set the maximum CPU time defined as t_max = n(m + 1)(tf)/2 ms, where tf denotes the time factor and tf = 60 in this calibration.

The proposed GA has eight operators and parameters which are listed below.

• Selection: two levels (tournament and roulette).
• Crossover: six levels (OX1, OX2, SJX, SJX2, SBX, and SBX2).
• Mutation (p_IS): five levels (0, 0.25, 0.5, 0.75, and 1).
• Population size (P_size): five levels (20, 30, 40, 50, and 60).
• Crossover probability (p_c): five levels (0.0, 0.1, 0.2, 0.3, and 0.4).
• Mutation probability (p_m): five levels (0.6, 0.7, 0.8, 0.9, and 1.0).
• Local search (P_l): five levels (30, 40, 50, 60, and 70).
• Restart (P_r): five levels (50, 60, 70, 80, and 90).

For the operators and parameters, 468,750 combinations were possible. To simplify this calibration, we performed two separate experiments. The first experiment was to select the best combination for selection, crossover, and mutation, and the second experiment was to find the best combination for the other parameters.

For the first experiment, a full factorial design for selection, crossover, and mutation was considered; hence, 60 different algorithms were tested. The remaining parameters were fixed as (P_size, p_c, p_m, P_l, P_r) = (50, 1, 1, ∞, ∞). These values were intended to make the parameters meaningless and to focus on the effects of selection, crossover, and mutation on the solutions. Figure 7 illustrates the main effect plot to determine the best operators with lower RDI values. As shown in the figure, (tournament, OX1 and 0.5) showed better performance. This was likely because many changes by crossover operation did not lead to better sequences in this problem with limited waiting time constraints. For mutation, the use of insertion and interchange with the same probability provided good results. Therefore, tournament, OX1 and p_IS = 0.5 were used in subsequent experiments.

The second experiment examined the remaining parameters (P_size, p_c, p_m, P_l, P_r). The full factorial design of the parameters could make 3125 combinations. However, because testing these combinations requires significant time, we adopted the Taguchi L₂₅ orthogonal array design instead of a full factorial design. The L₂₅ design is provided in

Table 6. Orthogonal array for GA calibration.

Experiment	Psize	pC	pM	Pl	Pr
1	20	0	0.6	50	30
2	20	0.1	0.7	60	40
3	20	0.2	0.8	70	50
4	20	0.3	0.9	80	60
5	20	0.4	1	90	70
6	30	0	0.7	70	60
7	30	0.1	0.8	80	70
8	30	0.2	0.9	90	30
9	30	0.3	1	50	40
10	30	0.4	0.6	60	50
11	40	0	0.8	90	40
12	40	0.1	0.9	50	50
13	40	0.2	1	60	60
14	40	0.3	0.6	70	70
15	40	0.4	0.7	80	30
16	50	0	0.9	60	70
17	50	0.1	1	70	30
18	50	0.2	0.6	80	40
19	50	0.3	0.7	90	50
20	50	0.4	0.8	50	60
21	60	0	1	80	50
22	60	0.1	0.6	90	60
23	60	0.2	0.7	50	70
24	60	0.3	0.8	60	30
25	60	0.4	0.9	70	40

; that is, the 25 combinations provided in the table were tested. Note that the Taguchi design developed by Genichi Taguchi can achieve parametric research and optimization while reducing the number of experiments or numerical tests [54]. Figure 8 shows that the lowest RDIs for the parameters were achieved at (P_size, p_c, p_m, P_l and P_r) = (30, 0.2, 1, 60 and 60). Remarkably, the probabilities of crossover and mutation were opposite. With these probabilities, the GA occasionally executes crossover, but it always performs mutation operations. Considering the calibration results, i.e., OX1 and p_c = 0.2, the mutual interchange between two solutions may not help search for better solutions to this problem. In contrast, the mutation was more useful for improving the solution. The values of P_l and P_r were the same as 60. This indicates that the local search and restart procedures start when the best solution did not improve during 60 generations.

The suggested IG has two parameters: d and p_IS. This calibration considered five levels of each parameter, that is, d = (6, 8, 10, 12, and 14) and p_IS = (0, 0.25, 0.5, 0.75, and 1). Thus, we tested 25 combinations. A summary of the results is presented in Figure 9. As shown in the figure, RDI had the lowest at d = 10 and the difference in RDIs between d values was very clear. This value differed significantly from the original value of 4 which was experimentally found in [47]. It is likely because computing power improved compared to in the past. Note that the destruction size d is determined by considering the trade-off between the solution quality and computation time. That is, a large d can provide good solutions but requires a large amount of computation. Therefore, in a limited CPU time, if the d value is too large, IG may provide a poor solution. The effect of the p_IS was not significant. This may be because IG is based on the insertion mechanism. Consequently, the IG uses d = 10 and p_IS = 0.75.

For calibration of the proposed SA, we considered five levels of each of the three parameters (α, L, and p_IS). In this experiment, the epoch length L was defined as L = n × l, where l is a control parameter. The design of this calibration was also based on the Taguchi L₂₅ orthogonal array (

Table 7. Orthogonal array for SA calibration.

Experiment	α	l	pIS
1	0.9	1	0
2	0.9	15	0.25
3	0.9	30	0.5
4	0.9	45	0.75
5	0.9	60	1
6	0.95	1	0.25
7	0.95	15	0.5
8	0.95	30	0.75
9	0.95	45	1
10	0.95	60	0
11	0.99	1	0.5
12	0.99	15	0.75
13	0.99	30	1
14	0.99	45	0
15	0.99	60	0.25
16	0.995	1	0.75
17	0.995	15	1
18	0.995	30	0
19	0.995	45	0.25
20	0.995	60	0.5
21	0.999	1	1
22	0.999	15	0
23	0.999	30	0.25
24	0.999	45	0.5
25	0.999	60	0.75

). Figure 10 shows the calibration results. Three parameters (α, l, and p_IS) had the lowest RDI values at (0.995, 15, and 0.25), respectively. In contrast to GA and IG, the results showed bath-curves for all the parameters. In other words, both higher and lower values from the best values resulted in worse outcomes. This is probably because SA generates a neighborhood solution using only a local search of insertion and interchange without any other methods. From the value of p_IS = 0.25, the interchange appears to be more effective in SA. Therefore, the SA used α = 0.995, l = 15, and p_IS = 0.25 in subsequence tests.

After calibrating the proposed metaheuristics, we examined the solutions obtained from the heuristics by comparing them with those from CPLEX. Here, we considered four levels of n = 20, 30, 40, and 50 because the destruction size d of IG was determined to be 10 in the calibration. Metaheuristics independently solved each instance five times, and the average values of the five independent results were used. In addition, for the termination condition t_max n(m + 1)(tf)/2 ms, three levels of tf = (30, 60, and 90) were considered, and let A_tf be the algorithm A using tf = (30, 60, and 90).

Table 8. Average percentage gaps of heuristic solutions from a solution using CPLEX.

Heuristic	Set A	Set B	Set C
MNEH	2.110 1	0.408	0.356
GA30	−1.299	−0.032	−0.121
GA60	−1.362	−0.035	−0.128
GA90	−1.393	−0.036	−0.130
IG30	−1.869	−0.073	−0.175
IG60	−1.944	−0.075	−0.178
IG90	−1.976	−0.079	−0.180
SA30	−1.260	−0.065	−0.126
SA60	−1.262	−0.065	−0.126
SA90	−1.262	−0.065	−0.126

¹ Average percentage gap, 100 × (obj_Heuristic − obj_CPLEX)/obj_CPLEX.

summarizes the comparison results, which shows the average percentage gaps of heuristic solutions from a solution using CPLEX, and Figure 11 represents the number of instances for which the heuristic solutions are better than or equal to the CPLEX solutions. The negative percentage gap indicates that the heuristic solutions are better than those of the CPLEX. Overall, the IG algorithm exhibited the best performance. For 179 out of 180 instances, IG found solutions better than or equal to those of CPLEX. Both algorithms were better than CPLEX, and SA outperformed GA. For the three levels of tf, only a few changes were observed in all cases. This indicates that the proposed metaheuristics can find a solution close to an optimal solution within a short computation time for instances of up to n = 50. These experimental results verified the effectiveness and efficiency of the proposed metaheuristics. Meanwhile, MNEH showed percentage gaps of approximately 2% in Set A and less than 1% in Sets B and C. Although MNEH was overwhelmed by the metaheuristics, its performance is acceptable, bearing in mind that MNEH is a constructive heuristic.

We also examined the performance of the heuristics on large instances with n = 100, 200, 300, 400, and 500. A summary of the comparison results is in Figure 12 which shows the RDI values of the heuristic algorithms and Figure 13 which represents the number of instances that the heuristic found the best solution. Overall, SA outperformed the other algorithms, and even SA₃₀ was better than GA₉₀ and IG₉₀. These results were remarkably different from those of the previous test with small instances of up to n = 50. This is probably because of the trade-off relationship between solution quality and computation time. In IG, the greedy reinsertion method checks all possible positions to find the best one, and thus, this mechanism is very effective in small instances. However, this technique becomes computationally burdensome when n increases. In contrast, the SA procedure, which uses only a local search method with insertion and interchange, is relatively simple. That is, SA generates a new solution by slightly changing the current solution, and the time to create a new solution rarely increases even if n increases. Therefore, in terms of the trade-off relation, it can be said that SA is much more effective and efficient. On the contrary, for the instances with m = (2 and 5) of Sets B and C, there was no difference in the performance of all algorithms, including MNEH. However, for instances with m = 10, SA overwhelmed the other algorithms, and IG performed better than GA. A summary of the experimental results thus far reveals that attempts to improve the solution by changing the sequence slightly are desirable in this scheduling problem.

In addition, we performed statistical tests to see statistically significant differences in the performance of the proposed metaheuristics. This test used RDI values obtained from GA₉₀, IG₉₀, and SA₉₀ on large-size instances of n = 100, 200, 300, 400, and 500. Figure 14 shows the 95% confidence interval for the mean RDIs of the algorithms. As shown in Figure 14, SA₉₀ performed significantly better in terms of the mean RDI. We also performed Kruskal–Wallis tests which is a non-parametric method.

Table 9. Pairwise comparisons from Kruskal–Wallis tests.

Set	Sample 1 -Sample 2	Test Statistic	Std. Error	Std. Test Statistic	Sig.	Adj. Sig. 1
A	SA90-IG90	53.800	10.398	5.174	0.000	0.000
	SA90-GA90	103.840	10.398	9.987	0.000	0.000
	IG90-GA90	50.040	10.398	4.813	0.000	0.000
B	SA90-IG90	13.480	6.937	1.943	0.052	0.156
	SA90-GA90	35.480	6.937	5.114	0.000	0.000
	IG90-GA90	22.000	6.937	3.171	0.002	0.005
C	SA90-IG90	13.987	6.937	2.016	0.044	0.131
	SA90-GA90	34.853	6.937	5.024	0.000	0.000
	IG90-GA90	20.867	6.937	3.008	0.003	0.008

¹ Significance values adjusted by the Bonferroni correction for multiple tests.

shows the results of pairwise comparisons from the tests. For the tests in Set A, SA₉₀ significantly outperformed GA₉₀ and IG₉₀. However, there is no significant difference between SA and IG in Sets B and C. This is likely because the RDIs for m = 2 and 5 were zero.

The last analysis shows the effect of the waiting time constraints on solutions. For this analysis, we generated 10 instances of (m, n) = (5, 300) in Set A. The waiting times were generated randomly with a range of [1, 100], and these values were treated by multiplying the ratios (0.5, 1.0, 1.5, 2.0, 2.5, and 3.0). We analyzed the results obtained by solving each instance independently five times using SA₉₀ which showed the best performance. As shown in Figure 15, the makespan decreased as the waiting time ratio increased. This is because tight limited waiting times caused delayed starts; hence, the makespan increased accordingly. The decline of the makespan slowed when the ratio exceeded 2. That is, if the limited waiting times are twice the processing times, the effect of the waiting time limit on the solution is reduced. These results suggest the need for manufacturing technologies and systems that can achieve product quality while setting enough limited waiting times. It may also provide a guideline for considering the trade-off between production efficiency and product quality. Meanwhile, the range of the objective values increased as the ratio increased. This may be due to the loose waiting time limits that increased the time range in which jobs could start. In other words, tight waiting time limits reduced the solution space for start times in a problem.

5. Discussion and Conclusions

This study investigated a scheduling problem in a two-stage assembly-type flow shop with limited waiting time constraints to minimize the makespan. For this problem, a mixed-integer programming formulation was provided to mathematically describe and find an optimal solution using CPLEX. If the limited waiting times are treated as zero time, we can also use the MIP for solving a no-wait constrained problem. This problem is NP-hard, which requires an excessive computational time to solve the problem optimally. Therefore, this study focused on heuristic algorithms to quickly find good solutions. Various heuristic algorithms were provided, including priority rule-based list scheduling methods, a modified NEH algorithm, a genetic algorithm, an iterated greedy algorithm, and a simulated annealing algorithm. In addition, this study suggested equations to calculate the completion times of jobs in a given sequence. Computational experiments demonstrated that IG and SA in small- and large-sized problems, respectively, were effective and efficient within a short computation time.

This study had some limitations. First, this study considered only two stages and a single machine in the second stage. Next, the suggested problem assumed that all jobs are ready to process at time zero and considered the given and fixed information of jobs. In addition, because finding exact solutions for large problems requires a significant computation time or may be impossible, the solutions obtained by the heuristics were examined by comparing them with each other. These limitations necessitate further studies.

Future studies may need to consider more general models, such as multiple stages and machines in each stage. In addition, it may be necessary to consider a problem in which jobs arrive at the first stage dynamically or a problem with stochastic processing times. Furthermore, the multi-objective of the throughput of the system and the due date-based measure may also be considered in future studies. Additionally, one may develop an exact algorithm or effective lower bounds to evaluate the solutions obtained by the heuristic algorithms. Finally, optimal solution properties may be necessary to reduce the solution space to be explored.