A slack optimization unified model of regrouping and sequencing batches for β 1 → β 2 manufacturing system

Abstract

It is challenging to schedule batch processing machine in the semiconductor wafer fabrication system. Based on the rolling horizon scheme, the overall horizon is decomposed into many time windows. One time window corresponds to one sub-problem. Regarding each sub-problem, a multiple-phase scheduling strategy is performed, which consists of three phases: to update parameters, to sequence the regrouping batches, and to dispatch the priority-batch. A unified scheduling model of unifying β₂ batch regrouping and sequencing is focused on in the β₁ → β₂ type. In the model, the objective is a minimum total tardiness for sequencing the regrouping batches. To demonstrate the effectiveness of the developed approach, the experiments are implemented on a virtual semiconductor manufacturing test line. The results show that it can obtain satisfied solution.

Keywords

Scheduling time windows batch processing machine multiple-phase scheduling strategy unified scheduling model

Introduction

According to the processing capacity of machine, batch processing machine (BPM) can process several jobs simultaneously, which is different from discrete processing machine (DPM). The set of processing jobs of BPM is defined as batch. In the modern industries, the BPM type is frequently encountered, such as diffusion and oxidation ovens in the semiconductor wafer fabrication system (SWFS) and heat treatment operation system. The scheduling of BPM is challenging. The processing time of BPM may take many hours, which is much longer than other processes,¹ around 30% of the total work in process (WIP) in a SWFS is staying in diffusion stages.² The BPM of SWFS has many complex characteristics, such as multi-re-entrant processing flow and high uncertainties.³ A good BPM scheduling has far been the primary focus both in academic research and industrial application. Using the notations introduced by Ahmadi et al.,⁴ let δ denote a DPM, β denote a BPM, and let → denote the flow configuration. According to the preceding processor of BPM, there are two kinds of BPM models that are denoted as δ → β and β₁ → β₂. Jia et al.⁵ have discussed the scheduling problem of δ → β type. Additionally, most of the studies assume infinite waiting time on every operation, but there are many industries where the waiting time constraints are considered.⁶ One of the main reasons is that the chemical conditions on the surface of a wafer after the cleaning process are gradually deteriorated or contaminated as time elapses. This article addresses the problem of β₁ → β₂ type with incompatible families in β₁, compatible families in β₂, and waiting time restrictions between β₁ and β₂. The batches that are finished in β₁ need to be grouped into batches again in β₂ (i.e. regrouping batches).

The BPMs scheduling system of problem of β₁ → β₂ type belongs to model-based expert system. In this article, according to the rolling horizon scheme, the large-scale dynamic scheduling problem of the β₁ → β₂ type is divided into a series of small scheduling sub-problems. For the scheduling sub-problem, a three-phase scheduling strategy is performed. In the first phase, the scheduling parameters are updated by the real-time scheduling simulation (ReS²) platform.⁷ In the second phase, a unified scheduling model of unifying β₂ batch regrouping and sequencing is executed. In the last phase, the priority-batch is dispatched to the idle β₂. The priority-batch means that this batch should be dispatched prior to others. The three-phase programming is performed iteratively. To demonstrate the effectiveness of the developed approach, the experiments are implemented on a virtual semiconductor manufacturing test line.

This article consists of six sections. The following section presents a review. Section “Problem definition” discusses the problem definition. Section “Methodology” mainly presents the overall procedure structure of three-phase rolling horizon strategy and slack-based mixed-integer linear programming (MILP) unified model. Section “Experimental investigation” conducts the computational experiment. The perspectives, conclusions, and recommendations for future research are provided in the last section.

Literature review

Many researchers have considered the scheduling problems of BPM. For an overview, the readers are invited to refer to Potts and Kovalyov,⁸ Mathirajan and Sivakumar,⁹ Mönch et al.,¹⁰ Yugma et al.,¹¹ and Sharma and Jain.¹²

The scheduling methodology of BPM in SWFS consists of mathematical programming method, simulation method, and heuristic method. Mixed-integer programming (MIP) model,¹³ improved MILP,¹⁴ integer programming formulation,¹⁵ and branch and bound algorithm¹⁶ are mathematical programming methods. Simulation methods are found in Scholl and Domaschke¹⁷ and Klemmt et al.¹⁸ The heuristic algorithms consist of pure heuristic approaches and meta-heuristic approaches. For the BPMs scheduling, Balasubramanian et al.¹⁹ proposed genetic algorithm. Kumar Manjeshwar et al.²⁰ and Damodaran and Vélez-Gallego²¹ used simulated annealing. Almeder and Mönch²² developed an ant colony optimization and a variable neighborhood search approach. Chiang et al.²³ proposed a new genome encoding scheme in memetic algorithm. Kim et al.²⁴ developed three heuristic algorithms using a basic idea of the list scheduling algorithms. Yugma et al.²⁵ proposed a disjunctive graph method. Mansoer and Koo²⁶ presented a dynamic batching heuristic for controlling BPM in semiconductor manufacturing. However, above methods mostly investigate the scheduling problem of δ → β type in SWFS. As reviewed above, almost no previous research considers the BPM scheduling problem of β₁ → β₂ type.

The rolling horizon scheme has received considerable attention in the literature over the last years. Sahin et al.²⁷ reviewed the rolling horizon scheme. Adams et al.²⁸ develop a successful shifting bottleneck approach, which is repeated to schedule all machines. Jiang and Wang²⁹ proposed a rolling horizon algorithm for an aircraft-engine assembly workshop problem. In order to partition a sequence of aircraft into chunks and solve the aircraft sequencing problem individually, Furini et al.³⁰ presented a rolling horizon approach for each of these chunks. In order to obtain better performance than standard dispatching rules in reasonable CPU times in SWFS, a rolling horizon heuristic is proposed by Sourirajan and Uzsoy.³¹ They decompose the shop into smaller sub-problems. In order to obtain clear improvement in large instance, Guo et al.³² proposed the rolling horizon ant colony optimization method. The results show that they can obtain clear efficiency improvement on large problem. Jung et al.² proposed an advanced rolling horizon scheduling approach to solve an MILP model for BPM scheduling problem. This article presents rolling horizon scheme to consider the scheduling problem of β₁ → β₂ type with waiting time restrictions in SWFS.

Problem definition

The problem definition of β₁ → β₂ manufacturing system is formulated. When one β₂ is idle, one priority-batch is loaded to it. The scheduling problem is how to obtain the new regrouping priority-batch and load it to the idle β₂. The processing flow of problem definition is shown in Figure 1.

Figure 1.

The processing flow of the β₁→β₂ type manufacturing system.

The jobs have the processing flow: In → β₁ → Buffer 1 → δ → … → Buffer 2 → β₁ → Buffer 3 → β₂ → Out. β₁ is a re-entrant machine. Buffers 1, 2, and 3 are the buffers of δ, β₁, and β₂, respectively. Dots of “…” represent apostrophe ellipsis. → denotes the flow configuration. The jobs of Buffer 2 are named as re-entrant jobs. Some assumptions and detailed descriptions are defined as follows:

When one batch has been processed on a processor, the whole batch is completely processed.

It assumes that, at any time, jobs of each batch must be processed by at most one machine.

The values of parameters P, S, and q are known and fixed. P is the processing time of β₂. S is the processing capacity of β₂. q is the waiting time restriction between β₁ and β₂.

In β₁, incompatible job families are assumed. It means that only the jobs with the same family can be grouped batches. The same family has the same recipe. Jobs with the same recipe are viewed as a family. As shown in Figure 1, the number of families to be scheduled of the Buffer 1 is I (i.e. F = I × L = I × 1 = I), but the number of families to be scheduled of the Buffer 2 is 2I (i.e. F = I × L = I × 2 = 2I). L is the re-entrant number of jobs to be processed in β₁, l = 1, 2, …, L. It assumes that all the jobs have the same L. I is the number of products to be scheduled, i = 1, 2, …, I. F is the number of families to be scheduled in β₁, f = 1, 2, …, F. There exists F = I × L.

It assumes that the processing capacity of β₂ is not less than that of β₁, that is, S ≥ s_j. In β₂, compatible job families are assumed. It means that any batches that come from β₁ can be regrouped new batches, but all those batches are unsplit. In other words, the same batch cannot belong to the different regrouping batches. When the processing capacity of β₂ is less than that of β₁, the batches of β₁ need to be unsplit, which does not belong to regrouping batches. J is the number of different batches that came from β₁ in Buffer 3, j = 1, 2, …, J. s_j is the size of the jth new batch in Buffer 3, j = 1, 2, …, J.

There is waiting time restriction between β₁ and β₂.

Methodology

In this section, the overall algorithm structure of three-phase strategy is begun first. Then, the slack-based MILP scheduling model of regrouping and sequencing batches is analyzed. All these are discussed below.

Overall structure of three-phase scheduling strategy

The key theory of three-phase strategy is the rolling horizon scheme. There are many nodes in the overall horizon axis. Each node corresponds to a triggered event of rolling horizon scheme. The triggered event is that one β₂ is idle. The time window between the two adjacent nodes includes one sub-problem. The scheduling problem of β₁ → β₂ type is split into many sub-problems. As for each sub-problem, three-phase scheduling strategy is performed: to update scheduling parameters, to regroup and sequence batches, and to load the priority-batch. The first and third phases are executed by the ReS² platform, which has been researched by Liu et al.⁷ This article focuses on the second phase. A slack-based MILP model is illustrated in the next sub-section. The overall procedure structure of three-phase scheduling strategy is implemented as follows. The overall flowchart is shown in Figure 2:

Step 1. Initialize a time window. The first phase is executed.

Step 2. Update the WIP information of Buffer 3 and the processing status of β₂.

Step 3. When one β₂ is idle, a triggered event is generated.

Step 4. A priority-batch needs to be obtained.

Step 5. WIP of Buffer 3 is regrouped batches.

Step 6. While N > 1, to set up a database that is the information of the total number (N); then, to run the second phase scheduling strategy; lastly, to generate a sequencing array of the total number (N).

Step 7. While N = 1, the regrouping batch is the priority-batch for the idle β₂.

Step 8. While N = 0, that is the WIP is empty, the idle β₂ lies in a status of waiting until there exists N = 1. The regrouping batch is the priority-batch for the idle β₂.

Step 9. Run the third phase scheduling strategy: to dispatch the priority-batch to the idle β₂; then, to remove the dispatched priority-batch from Buffer 3.

Step 10. Check the stopping criterion.

Figure 2.

The overall flowchart of three-phase scheduling strategy.

The stopping criterion is controlled by either scheduling jobs or scheduling horizon. This procedure is implemented on the ReS² platform, which connects ILOG CPLEX. For all parameters, some are known in advance, such as the parameters of I and L. The others are unknown. For example, the values of PR_j, N, q, s_j, r_j, d_j, ZS_j, DS_j, and P_k,j are obtained by the ReS² platform in the first phase, and the values of dr_n, Cr_n, PRr_n, and T_n are obtained by ILOG CPLEX in the second phase. PR_j is the total pure remaining processing time of the jth batch after β₁, j = 1, 2, …, J. r_j is the arriving time of the jth batch in Buffer 3, j = 1, 2, …, J. d_j is the due date time of the jth batch, j = 1, 2, …, J. ZS_j is the total number of processing steps of the jth batch, j = 1, 2, …, J. DS_j is the number of processing step of the jth batch in β₂, j = 1, 2, …, J. P_k,j is the processing time of the kth processing step of the jth batch, k = 1, 2, …, ZS_j and j = 1, 2, …, J. dr_n is the due date time of the nth regrouping batch, n = 1, 2, …, N. Cr_n is the completion time of the nth regrouping batch, n = 1, 2, …, N. PRr_n is the total pure remaining processing time of the nth regrouping batch after β₂, n = 1, 2, …, N. T_n is the tardiness of the nth regrouping batch, n = 1, 2, …, N. Note that PR_j and PRr_n represent the total sum of remaining processing time of the jth batch and the nth regrouping batch, respectively.

Slack-based MILP model

If the completion time of a regrouping batch (i.e. Cr_n) is greater than its due date time (i.e. dr_n), then the regrouping batch is said to be tardy. Its tardiness is measured by Cr_n − dr_n. Else, the regrouping batch is not tardy. The objective is to minimize the total tardiness over all regrouping batches. Whenever one idle β₂ is requested to decide a regrouping batch to be processed in it, a priority-batch needs to be offered. The MIP model of β₁ → β₂ type manufacturing system is conventionally formulated as follows. There are two key decision variables for MIP model. One is a binary variable, which is denoted by x_j,n. For instance, if x_j,n = 1, then it indicates the jth batch in Buffer 3 is allocated to the nth regrouping batch; otherwise, x_j,n = 0. The other is sequence position index, which is denoted by one-dimensional (1D) array a(n), n = 1, 2, …, N. For instance, if a(n) = 1, then it is the priority-batch. In order to distinguish BPM from DPM in the remaining processing machines of β₂, an adjustment coefficient is imposed. The adjustment coefficient is denoted by μ_k. For instance, when the remaining processing machine of the kth processing step is DPM, we let μ_k = s_j. When the remaining processing machine of the kth processing step is BPM, and its processing capacity is B_k, we let μ_k = s_j/B_k. B_k is the processing capacity of machine of the kth processing step, k = 1, 2, …, ZS_j. t is the current time of simulation clock.

Minimize

\sum_{n = 1}^{N} max [(C r_{n} - d r_{n}), 0]

(1)

Subject to

C r_{n} = t + a (n) \times P + PR r_{n} \forall n \in {1, 2, \dots, N}

(2)

a (n) \in {1, 2, \dots, N} \forall n \in {1, 2, \dots, N}

(3)

If n \neq u, then a (n) \neq a (u) \forall n and u \in {1, 2, \dots, N}

(4)

\sum_{n = 1}^{N} x_{j, n} = 1, \forall j \in {1, 2, \dots, J}

(5)

\sum_{j = 1}^{J} x_{j, n} \times s_{j} = S \forall n \in {1, 2, \dots, N}

(6)

R P_{j} = μ_{k} \times \sum_{k = D S_{j} + 1}^{Z S_{j}} P_{k, j} \forall j \in {1, 2, \dots, J}

(7)

PR r_{n} = max_{1 \leq j \leq J} (x_{j, n} \times P R_{j}) \forall n \in {1, 2, \dots, N}

(8)

d r_{n} = min_{1 \leq j \leq J} (x_{j, n} \times d_{j}) \forall n \in {1, 2, \dots, N}

(9)

\begin{matrix} t - r_{j} + x_{j, n} \times a (n) \times P \leq q; \forall n \in {1, 2, \dots, N}, \\ \forall j \in {1, 2, \dots, J} \end{matrix}

(10)

The constraint (1) is the objective function that minimizes total tardiness in a time window. The completion time of the nth regrouping batch is computed by the constraint (2). Both constraints (3) and (4) ensure that one β₂ processes only one operation at a time. That is, the constraint (3) ensures that each regrouping batch has a given position, and the constraint (4) ensures that each given position has one and only one regrouping batch that is assigned. The constraint (5) ensures that any batches of β₂ are allocated to different regrouping batches. In other words, all batches are unsplit. The constraint (6) ensures that the total size of the nth regrouping batch is equal to the processing capacity of β₂. Both constraints (7) and (8) are used to compute the total pure remaining processing time of the nth regrouping batch after β₂ in SWFS. The constraint (7) is used to compute PR_j and PRr_n. The constraint (9) is used to compute dr_n. The waiting time restrictions are ensured by the constraint (10). Since a(n) and x_j,n are decision variables, the above model is nonlinear. In order to run this problem by ILOG CPLEX, it needs to be linearized.

In order to modify the constraints (10), the Big M method is imposed (i.e. M is an extremely large positive integer). The waiting time constraint between β₁ and β₂ is modified as follows

\begin{matrix} t - r_{j} + a (n) \times P - M \times (1 - x_{j, n}) \leq q; \\ \forall n \in {1, 2, \dots, N}; \forall j \in {1, 2, \dots, J} \end{matrix}

(11)

The constraints (1)–(9) and (11) build a new MILP model, which is called slack-based MILP unified model. It can be run by ILOG CPLEX.

Experimental investigation

In order to evaluate the above three-phase scheduling strategy, this section addresses a computational experiment. As shown in Figure 3, the architectural view of implementation is described. The implementation consists of four main components, that is, three phases and graphical user interface. The first and third phases are dependent on the ReS² platform, which are addressed in section “Overall structure of three-phase scheduling strategy.” The second phase has two main modules. One is a slack-based MILP generator (i.e. Visual Basic.NET procedure developed by ourselves) and the other is a slack-based MILP solver (i.e. ILOG CPLEX). All input data and the results are stored in their database. The three-phase scheduling strategy is repeated until all required scheduling iterations are completed. Whenever the real-time release and dispatch is requested to decide to process on a new scheduling, it retrieves the scheduling data from its database.

Figure 3.

The architectural view of implementation.

A virtual semiconductor manufacturing test line is modeled. As shown in Figure 4(a), there are eight different machine areas, which are denoted by PAN, AAN, SAN, ASI, MRH, DIK, GON, and LPC, respectively. The processing flow of the jobs is In → (1) → (2) → (3) → (4) → (5) → (6) → (7) → (8) → (9) → (10) → (11) → (12) → Out. As shown in Figure 4(b), there are 12 different processing steps, which are defined as PAN, AAN¹, SAN¹, ASI, MRH, SAN², DIK¹, AAN², SAN³, GON, DIK², and LPC, respectively. The superscript number of these equipment areas represents re-entrant number. For example, AAN¹ and AAN² mean that jobs are processed in artificial neural network (ANN) for the first and second time, respectively. To compare the processing flow of the β₁ → β₂ type manufacturing system (see Figure 1) with the virtual semiconductor manufacturing test line (Figure 4(b)), β₁ corresponds to DIK¹ and DIK² and β₂ corresponds to LPC. There is waiting time restriction between DIK² and LPC.

Figure 4.

The over flow of virtual semiconductor manufacturing test line

Table 1 shows the values of some parameters of the virtual semiconductor manufacturing test line, such as the processing time (minute) and the processing capacity (wafer). The processing time of DIK² is variable, which is relative to different product types. In the experiment, four product types are processed simultaneously (I = 4). The processing times in DIK² are 180, 263, 410, and 300, respectively. Let’s use ZS_j = 12. Since the last processing step is LPC, PR_j = 0 and DS_j = 12 are set. Let the processing capacity of LPC be 12 jobs (i.e. S = 12). For all products, let’s use q = 11,360.

Table 1.

The values of some parameters in the virtual semiconductor manufacturing test line.

Equipment area	PAN	AAN		SAN			ASI	MRH	GON	DIK		LPC
Equipment area	PAN	AAN¹	AAN²	SAN¹	SAN²	SAN³	ASI	MRH	GON	DIK¹	DIK²	LPC
Processing time	45	50	40	45	36	45	7	20	36	360	Variable	918
Processing capacity	1	1		1			1	1	1	8		8

When one LPC is idle (i.e. a trigger event), one sub-problem needs to be resolved. It is defined as Case 1. Table 2 shows the values of some parameters that are obtained by the ReS² platform in the first phase of three-phase scheduling strategy.

Table 2.

The values of some parameters in the first phase of three-phase scheduling strategy.

Parameter	j = 1	j = 2	j = 3	j = 4	j = 5	j = 6	j = 7	j = 8
s_j	3	4	5	6	6	7	8	9
r_j	100	150	200	300	180	263	410	300
d_j	3621	3621	3627	3627	3636	3636	3245	3245

In the second phase of three-phase scheduling strategy, the slack-based MILP model offers the results of the two decision variables and the value of objective function. Table 3 shows the values of binary variable (i.e. x_j,n). From the results given in Table 3, the first regrouping batch consists of the first and eighth batches, the second one consists of the second and seventh batches, and so on. The 1D array of a(n) is that (a(1), a(2), a(3), a(4) = (4, 3, 2, 1). It shows that the priority-batch is the fourth regrouping batch (i.e. a(4) = 1), which consists of the third and sixth batches. The value of objective function is 53 (i.e. $min (\sum_{n = 1}^{4} max [(C r_{n} - d r_{n}), 0]) = 53$ ).

Table 3.

The values of binary variables (x_j,n).

x_j,n	j = 1	j = 2	j = 3	j = 4	j = 5	j = 6	j = 7	j = 8
n = 1	1	0	0	0	0	0	0	1
n = 2	0	1	0	0	0	0	1	0
n = 3	0	0	0	1	1	0	0	0
n = 4	0	0	1	0	0	1	0	0

In the third phase of three-phase scheduling strategy, the ReS² platform loads the priority-batch (i.e. the fourth regrouping batch) to the idle LPC. When the iteration is not ended, a new time window restarts.

There is no relative literature to focus on the β₁ → β₂ scheduling with waiting time restrictions in SWFS. To show the effectiveness of the above method, three cases are executed: Case 1, Case 2, and Case 3. The Case 1 is a simple version, the batch quantity is 8 (i.e. J = 8). The batch quantity of Case 2 is twice larger than that of Case 1 (i.e. J = 16). The batch quantity of Case 3 is larger than that of Case 2 by 2 (i.e. J = 18). For instance, when J = 16, the values of some parameters that are obtained by the ReS² platform in the first phase of three-phase scheduling strategy are listed as follows:

s_j = [3, 3, 4, 4, 5, 5, 6, 6, 6, 6, 7, 7, 8, 8, 9, 9]

r_j = [100, 100, 150, 150, 200, 200, 300, 300, 180, 263, 180, 263, 410, 410, 300, 300]

d_j = [3611, 3611, 3611, 3611, 3627, 3627, 3627, 3627, 3636, 3636, 3636, 3636, 3245, 3245, 3245, 3245]

The two different performance measures are used, such as objective optimal value and CPU time.

About Cases 1, 2, and 3, the experimental results of the proposed rolling horizon-based three-phase scheduling strategy are shown in Table 4.

Table 4.

The experimental results of two different performance measures.

Case	J	Objective optimal value	CPU time (s)
Case 1	8	53	0.03
Case 2	16	9890	5.1
Case 3	18	14,568	15.8

From the results given in Table 4, the proposed rolling horizon-based three-phase scheduling strategy performs well. The CPU time of the proposed rolling horizon-based three-phase scheduling strategy is easily influenced by the batch quantity coming from DIK². For instance, when the batch quantity in Case 3 is larger than in Case 2 by 2, the CPU time in Case 3 is about triple larger than in Case 2. Table 4 also shows that the proposed rolling horizon-based three-phase scheduling strategy can provide satisfied solution both quality and CPU time, especially for medium-scale problems.

Conclusion

This article has focused on the β₁ → β₂ scheduling with incompatible families in β₁, compatible families in β₂, and waiting time restrictions between β₁ and β₂ in SWFS. To resolve the problem, a new rolling horizon-based three-phase scheduling strategy is performed. In the second phase, a slack-based MILP model is formulated. The objective is to minimize total tardiness. To demonstrate the effectiveness of the proposed rolling horizon-based three-phase scheduling strategy, a virtual semiconductor manufacturing test line is modeled and set to run. The experiments are implemented on the ReS² platform, which connects to ILOG CPLEX. The results show that the proposed rolling horizon-based three-phase scheduling strategy makes trade-offs between solution quality and computation time, especially for medium-scale scheduling problem of the β₁ → β₂ type. This approach can be extended to other scheduling problems of β₁ → β₂ type in fabrication operations that involve waiting time restrictions. The slack-based technique MILP model and experiments should be further improved. In order to make conclusions sound and well-justified, further simulations are performed to compare the proposed method with different other approaches.

Footnotes

Declaration of conflicting interests

The author(s) declared no potential conflicts of interest with respect to the research, authorship, and/or publication of this article.

Funding

The author(s) disclosed receipt of the following financial support for the research, authorship, and/or publication of this article: This work was supported by the University Provincial Natural Science Foundation of Anhui Province (KJ2016A057 and TSKJ2014B14) and National Science and Technology Major Special Projects (2011ZX02501-005).

References

Mehta

Uzsoy

Minimizing total tardiness on a batch processing machine with incompatible job families. IIE Trans 1998; 30(2): 165–178.

Jung

Pabst

Ham

et al . An effective problem decomposition method for scheduling of diffusion processes based on mixed integer linear programming. In: ASMC 2013 SEMI advanced semiconductor manufacturing conference, Saratoga Springs, NY, 14–16 May 2013, pp.35–40. New York: IEEE.

Min

Yih

Development of a real-time multi-objective scheduler for a semiconductor fabrication system. Int J Prod Res 2003; 41(10): 2345–2364.

Ahmadi

Dasu

et al . Batching and scheduling jobs on batch and discrete processors. Oper Res 1992; 40(4): 750–763.

Jia

Jiang

Combined scheduling algorithm for re-entrant batch-processing machines in semiconductor wafer manufacturing. Int J Prod Res 2015; 53(6): 1866–1879.

Arima

Kobayashi

Wang

et al . Optimization of re-entrant hybrid flows with multiple queue time constraints in batch processes of semiconductor manufacturing. IEEE T Semiconduct M 2015; 28(4): 528–544.

Liu

Fung

RYK

Jiang

Modelling of semiconductor wafer fabrication systems by extended object-oriented Petri nets. Int J Prod Res 2005; 43(3): 471–495.

Potts

Kovalyov

MY.

Scheduling with batching: a review. Eur J Oper Res 2000; 120(2): 228–249.

Mathirajan

Sivakumar

A literature review, classification and simple meta-analysis on scheduling of batch processors in semiconductor. Int J Adv Manuf Technol 2006; 29(9–10): 990–1001.

10.

Mönch

Fowler

Dauzère-Pérès

et al . A survey of problems, solution techniques, and future challenges in scheduling semiconductor manufacturing operations. J Sched 2011; 14(6): 583–599.

11.

Yugma

Blue

Dauzère-Pérès

et al . Integration of scheduling and advanced process control in semiconductor manufacturing: review and outlook. J Sched 2015; 18(2): 195–205.

12.

Sharma

Jain

A review on job shop scheduling with setup times. Proc IMechE, Part B: J Engineering Manufacture 2016; 230(3): 517–533.

13.

Bixby

Burda

Miller

et al . Short-interval detailed production scheduling in 300mm semiconductor manufacturing using mixed integer and constraint programming. In: The 17th annual SEMI/IEEE ASMC 2006 conference, Boston, MA, 22–24 May 2006, pp.148–154. New York: IEEE.

14.

Liao

LM.

Improved MILP models for two-machine flowshop with batch processing machines. Math Comput Model 2008; 48(7–8): 1254–1264.

15.

Kao

Zhan

Chang

et al . Near optimal furnace tool allocation with batching and waiting time constraints. In: 2011 IEEE conference on automation science and engineering, Trieste, 24–27 August 2011, pp.108–113. New York: IEEE.

16.

Yao

Jiang

A branch and bound algorithm for minimizing total completion time on a single batch machine with incompatible job families and dynamic arrivals. Comput Oper Res 2012; 39(5): 939–951.

17.

Scholl

Domaschke

Implementation of modeling and simulation in semiconductor wafer fabrication with time constraints between wet etch and furnace operations. IEEE T Semiconduct M 2000; 13(3): 273–277.

18.

Klemmt

Horn

Weigert

et al . Simulations-based and solver-based optimization approaches for batch processes in semiconductor manufacturing. In: 2008 winter simulation conference, Miami, FL, 7–10 December 2008, pp.2041–2049. New York: IEEE.

19.

Balasubramanian

Mönch

Fowler

et al . Genetic algorithm based scheduling of parallel batch machines with incompatible job families to minimize total weighted tardiness. Int J Prod Res 2004; 42(8): 1621–1638.

20.

Kumar Manjeshwar

Damodaran

Srihari

. Minimizing makespan in a flow shop with two batch-processing machines using simulated annealing. Robot Cim-Int Manuf 2009; 25(3): 667–679.

21.

Damodaran

Vélez-Gallego

MC.

A simulated annealing algorithm to minimize makespan of parallel batch processing machines with unequal job ready times. Expert Syst Appl 2012; 39(1): 1451–1458.

22.

Almeder

Mönch

Metaheuristics for scheduling jobs with incompatible families on parallel batching machines. J Oper Res Soc 2010; 62(12): 2083–2096.

23.

Chiang

Cheng

LC.

A memetic algorithm for minimizing total weighted tardiness on parallel batch machines with incompatible job families and dynamic job arrival. Comput Oper Res 2010; 37(12): 2257–2269.

24.

Kim

Joo

Choi

SY.

Scheduling wafer lots on diffusion machines in a semiconductor wafer fabrication facility. IEEE T Semiconduct M 2010; 23(2): 246–254.

25.

Yugma

Dauzère-Pérès

Artigues

et al . A batching and scheduling algorithm for the diffusion area in semiconductor manufacturing. Int J Prod Res 2012; 50(8): 2118–2132.

26.

Mansoer

Koo

PH.

A batching strategy for batch processing machine with multiple product types. J Ind Intel Inf 2015; 3(2): 138–142.

27.

Sahin

Narayanan

Robinson

EP.

Rolling horizon planning in supply chains: review, implications and directions for future research. Int J Prod Res 2013; 51(18): 5413–5436.

28.

Adams

Balas

Zawack

The shifting bottleneck procedure for job shop scheduling. Manage Sci 1988; 34(3): 391–401.

29.

Jiang

Wang

HX.

Study on the self-evolution problem of an aircraft-engine assembly workshop with uncertain number of assembly times. Proc IMechE, Part B: J Engineering Manufacture 2015; 229(8): 1418–1428.

30.

Furini

Kidd

Persiani

et al . Improved rolling horizon approaches to the aircraft sequencing problem. J Sched 2015; 18(5): 435–447.

31.

Sourirajan

Uzsoy

Hybrid decomposition heuristics for solving large-scale scheduling problems in semiconductor wafer fabrication. J Sched 2007; 10(1): 41–65.

32.

Guo

Jiang

Zhang

et al . Decomposition-based classified ant colony optimization algorithm for scheduling semiconductor wafer fabrication system. Comput Ind Eng 2012; 62(1): 141–151.