Scheduling Cluster Tools with Multi-Space Process Modules and a Multi-Finger-Arm Robot in Wafer Fabrication Subject to Wafer Residency Time Constraints

Abstract

To increase productivity, more sophisticated cluster tools are developed. To achieve this, one of the ways is to increase the number of spaces in a process module (PM) and the number of fingers on a robot arm as well, leading to a cluster tool with multi-space PMs and a multi-finger-arm robot. This paper discusses the scheduling problem of cluster tools with four-space PMs and a four-finger-arm robot, a typical tool with multi-space PMs and a multi-finger-arm robot adopted in modern fabs. With two arms in such a tool, one is used as a clean one, while the other is used as a dirty one. In this way, wafer quality can be improved. However, scheduling such cluster tools to ensure the residency time constraints is very challenging, and there is no research report on this issue. This article conducts an in-depth analysis of the steady-state scheduling for this type of cluster tools to explore the effect of different scheduling strategies. Based on the properties, four robot task sequences are presented as scheduling strategies. With them, four linear programming models are developed to optimize the cycle time of the system and find feasible schedules. The performance of these strategies is dependent on the activity parameters. Experiments are carried out to test the effect of different parameters on the performance of different strategies. It shows that, given a group of parameters, one can apply all the strategies and choose the best result obtained by one of the strategies.

1. Introduction

Cluster tools have been demonstrated to be adaptable, reconfigurable, and efficient for wafer fabrication in semiconductor manufacturing [1,2], resulting in increased productivity [3], reduced cycle time [3,4,5], high space utilization [2,4], and decreased capital costs. As illustrated in Figure 1, cluster tools are generally composed of several process modules (PMs), a wafer-handling robot, and two loadlocks (LLs) for loading and unloading wafer cassettes, usually holding 25 wafers with the same recipe [6,7]. Wafer processing in PMs adopts single-wafer processing technology, such that each PM can process only one wafer at a time. A raw wafer in a cassette is delivered to PMs for processing by the robot in a pre-specified order and finally returned to the cassette after all operations are completed.

To increase the productivity, more sophisticated cluster tools are developed. One of the methods of cluster-tool development is to increase the number of spaces in a PM and the number of fingers on a robot arm to form a cluster tool with multi-space PMs and a multi-finger-arm robot. As shown in Figure 2, the cluster tools discussed in this article are a typical type of cluster tool adopted in modern fabs and are different from the ones with single-space PMs illustrated in Figure 1. The discussed cluster tool shown in Figure 2 consists of several four-space PMs, a dual-arm–dual-finger robot, and several LLs. As shown in Figure 2, in a four-space PM, at a time, two spaces face the door, such that the robot can load wafers into them or unload wafers from them, while the other two spaces are located at the opposite position. The internal chamber can then rotate to exchange the positions taken by the spaces so that the robot can access the other two spaces. In this way, the robot can access all the spaces in the PMs according to a certain order. For the dual-arm–dual-finger robot, each arm has two fingers. Although both fingers in an arm can hold a wafer, they cannot work independently. Also, the two arms are structurally tightly coupled so that only one of them can load/unload at a time. Thus, when one of the robot arms performs an unloading or loading task at a PM or an LL, the two fingers on it should enter the PM or LL together to pick up or place two wafers (or one wafer if there is only one wafer in the spaces at the door of the PM or there is only one wafer held by one of the fingers). After the robot loads four wafers into a PM, a rotation operation of the internal chamber of the PM is required before starting the processing so that the two wafers that are loaded into the PM earlier can be unloaded before the other two upon their completion. This first-in-first-out rule minimizes the difference in sojourn time between the wafers loaded earlier and those loaded later. Moreover, there are several LLs (normally four) to make sure that raw wafers can enter the tool for processing in time. Thus, LLs are not the bottleneck such that the throughput of a tool is not determined by them. Also, this implies that once the robot comes to an LL to perform an unloading/loading task, it can do so immediately without waiting.

As the wafer circuit shrinks down to several nanometers, in wafer fabrication, contamination should be avoided by meeting various requirements. One of such requirements is the strict wafer residency time constraints (RTCs) [8,9]. With RTCs, once a wafer is processed in a PM, it should be removed from the PM within a limited time; otherwise, high temperature and chemical gas would contaminate or damage the wafer in it. Another requirement is the right use of fingers for wafer grasping. To realize this requirement, robot fingers are classified into two types: clean and dirty ones. The fingers dedicated to grasping raw wafers (called dirty wafers as well) are called dirty fingers, while fingers employed to grasp processed wafers are called clean fingers. By doing so, cross-contamination can be avoided. In real-life semiconductor fab applications, for cluster tools shown in Figure 2, two fingers on one of the robot arms are used as clean ones, while the other two fingers on the other robot arm are treated as dirty ones. The cluster tools shown in Figure 2 are normally used for chemical vapor deposition processes.

The cluster tool illustrated in Figure 1 is a cluster tool with single-space PM and single-finger-arm robot (S³F–CT), while the cluster tool illustrated in Figure 2 is a cluster tool with four-space PM and four-finger-arm robot (SF³–CT). Previous studies provide the optimal scheduling strategy for S³F–CT. However, existing studies do not deal with the practical situations that a robot arm is constrained to dedicate a part of robot activities to as stated in this paper. To the best of the authors’ knowledge, there is no research report on the scheduling of SF³–CTs, as the existing studies related to cluster tool scheduling mainly focus on S³F–CTs.

Two or more LLs in a cluster tool can ensure that there are enough raw wafers entering the tool for processing, such that the tool can operate under a steady state most of the time. Practically, the wafer-processing time in a PM is quite longer than the robot task time [10,11]. Nevertheless, the robot task time in a cycle might be longer than the wafer completion time at a step. Under a steady state, if the robot task time in a cycle is longer than the wafer completion time at the bottleneck step, the cluster tool is said to be transport-bound. In this situation, the robot is always busy. If the robot task time in a cycle is shorter than the wafer completion time at the bottleneck step, then the cluster tool is said to be process-bound. In this situation, the robot has idle time. For process-bound cluster tools with a single-arm robot, a backward strategy is optimal [11], while for process-bound cluster tools with a dual-arm robot, a swap strategy is efficient [12]. Significant advancements have been made in the area of modeling, performance assessment, control, and scheduling of cluster tools under the steady state [7,13,14,15,16,17,18]. However, RTCs are not considered in those studies.

With RTCs, Kim et al. [19], Lee and Park [20], and Rostami et al. [8] propose several methods to find an optimal and feasible cyclic schedule for cluster tools with a dual-arm robot. Furthermore, Wu et al. [6,21] conduct studies on scheduling cluster tools equipped with a single-arm robot/dual-arm robot from a perspective of control theory so as to obtain an optimal and feasible schedule efficiently. Lim et al. [22] introduce a novel category of robot task sequences that are more effective in meeting RTCs for situations with unbalanced processing parameters among steps. Ko et al. [23] propose an approach for cluster tools with a dual-arm robot handling multiple wafer types, aiming to satisfy RTCs and achieve the minimum cycle time by identifying an optimal release sequence for different wafer types. For cluster tools with processing-time variation and RTCs, Lim et al. [24] suggest a flexible strategy to improve the schedule robustness. For the scheduling problem of multi-cluster tools with RTCs, Zhu et al. [25] find a feasible steady-state schedule in dealing with two wafer types concurrently. For re-entrant processes with RTCs, efforts have also been made in the modeling, control, and scheduling of cluster tools with single-arm and dual-arm robots [26,27]. Meanwhile, the studies in [28,29] examine how activity time variation affects the wafer delay in PMs for cluster tools with single-arm and dual-arm robots. Yu et al. [30,31,32] suggest partially loading wafers in parallel PMs to improve the productivity of cluster tools. However, they do not consider multi-space PMs, nor address the issue of cross-contamination between dirty and clean wafers.

For S³F–CTs, only after a wafer enters a PM can the PM start its processing activity, implying that the processing activities follow the robot tasks. As a result, it is important to carefully determine the robot task sequence [6,21]. However, for the tools addressed in this work, except for the processing activities, the internal chambers of PMs should perform rotation operations such that the robot can correctly load wafers into PMs for processing. Notice that if a PM is still performing a rotation operation when the robot arrives at the PM for loading or unloading, the robot has to wait. This implies that rotation operations might delay the robot task time, too. Therefore, for SF³–CTs shown in Figure 2, it is necessary to analyze how the rotation operations in PMs affect the robot task schedule. This makes the obtained results for S³F–CTs in the existing studies not directly applicable to SF³–CTs. Furthermore, RTCs and the requirement for the right use of clean and dirty fingers make the scheduling problem of SF³–CTs much more complicated.

Note that, for the addressed tool, four wafers can be processed concurrently in a PM. However, each time, only two wafers can be loaded/unloaded, resulting in the increase in time delay of these wafers in a PM. Thus, how to reduce such a time delay is an important issue. Up to now, there is no research report on this topic, while practical applications require corresponding techniques to provide solution methods for that, i.e., there is a gap between the existing research achievements and the practical application demand. This motivates us to conduct this study. It should be pointed out that, as discussed above, although there are extensive studies on scheduling cluster tools with RTCs, the time delay caused by loading wafers into a PM more than once time makes the RTCs much more difficult to satisfy. Furthermore, due to the fact that the robot arm is restricted from performing certain tasks, the widely used scheduling strategies are not applicable, since the existing methods assume that there is no restriction on the robot arms. In summary, for the addressed problem, we face new challenges. With the new challenges, this work aims to examine new scheduling strategies and explore the effect of different scheduling strategies on obtaining feasible schedules. To do so, based on the properties of the system, four scheduling strategies are presented, and methods are developed to find feasible and optimal schedules. Then, experiments are conducted to test the performance of the methods on the capability for finding feasible and optimal schedules.

The rest of this article is organized as follows. In the next section, a detailed description of the problem is given. Then, the properties of the system are analyzed in Section 3. In Section 4, linear programs are established to find optimal and feasible schedules based on the presented robot task sequences. In Section 5, comparison experiments are carried out to show the application of the proposed method. Section 6 concludes this work.

2. The Processes and Scheduling Strategies

2.1. The Operation Processes

In semiconductor fabs, wafers are associated with recipes, specifying the wafer flow patterns (WFPs) and processing parameters. WFPs specify the processing routes of wafers. For an SF³–CT, WFP is defined as (m₁, m₂, m₃, …, m_n), with n being the number of process steps required to process wafers and m_i the number of parallel PMs at Step i. LLs are treated as Steps 0 and n+1 for holding raw and completed wafers, respectively. The robot arm with two dirty fingers is denoted by F₁, and we call this arm the dirty arm, while the other robot arm with two clean fingers is represented by F₂, and we call it the clean arm. Two raw wafers are unloaded from an LL by F₁ and delivered to a PM at Step 1 for processing. Once they are processed at Step 1, they are treated as clean wafers. Then, F₂ should deliver them to Steps 2, …, n for processing sequentially. After all operations are completed, they are returned to LL by F₂.

To schedule a cluster tool, determining the robot task sequence is vitally important so as to maximize the tool’s productivity and meet RTCs. The robot tasks include unloading, loading, and moving; U_i and L_i are used to denote the robot tasks of unloading and loading at a PM of Step i, i ∈ N_n = {0, 1, …, n}. Since the time taken for a robot task is quite short in practice, the time taken to perform U_i, i ∈ N_n\{0}, and L_i, i ∈ N_n, is the same and denoted by β. Note that before the robot unloads two clean wafers from an LL, the alignment of the wafers should be carried out first, resulting in the time to perform U₀ being relatively longer. Thus, β₀ is used to denote the time taken for U₀. The moving task from a PM at Step i (or an LL at Step 0) to a PM at Step j (or an LL at Step 0) is denoted by M_i,j, i, j, ∈ N_n, and the time taken for M_i,j is denoted by μ. Note that for M_i,j, i, j, ∈ N_n, if i = j, such a robot-moving task is called a rotation task. Assume that a robot arm is in the front of a PM, if the robot performs a rotation task, then the other robot arm should rotate to the front of the PM after the rotation. Furthermore, a swap operation of the robot includes an unloading task, a rotation task, and a loading task.

At the idle state, all four spaces in a PM are empty. Then, after two wafers are loaded into two of the spaces, the internal chamber of the PM rotates to make the other two empty spaces face the door, such that the robot can load another two wafers into the PM. Similarly, a rotation operation should be performed when the four wafers are processed and should be removed from the PM by the robot consecutively. Symbol υ is used to denote the time taken for a rotation operation of a PM. The wafer-processing time in a PM at Step i is denoted by α_i, i ∈ N_n. Assume that there are four wafers in a PM at Step i. Let W_i,12 and W_i,34 be the four wafers that are to be processed in a PM at Step i concurrently and W_i,12 be the two wafers that are loaded into the PM earlier than W_i,34. Notice that after W_i,12 are loaded into the PM at Step i, the internal chamber rotates such that W_i,34 can be loaded into the PM. Then, with W_i,34 being loaded, the rotation operation should be executed again to move the two spaces holding W_i,12 to the door position such that the PM can start to process wafers. After the processing activity is completed, W_i,12 can be removed from the PM earlier than W_i,34. In this way, one can ensure that the wafers loaded into the PM earlier can be removed from the PM earlier.

Note that, under a steady state, there are four wafers being processed in a PM at Step i. When the robot comes to the PM for unloading W_i,12, the processing activity at the PM may not be completed. Thus, the robot has to wait here for some time, and such a robot-waiting task is denoted by A_i1. After W_i,12 is removed from the PM, the internal chamber should rotate such that the spaces holding W_i,34 rotate to the door position of the PM. Also, when the robot comes to the PM again for unloading W_i,34, the rotation operation of the PM may not be completed. At this time, the robot should wait, and the robot-waiting activity is denoted by A_i2. Furthermore, when the robot loads W_i,12 into a PM at Step i, it implies that the PM is empty. Thus, the robot can load W_i,12 immediately without waiting. After W_i,12 are loaded into the PM, the PM should rotate such that other two empty spaces rotate to the door position of the PM. When the robot comes to the PM again and is ready to load W_i,34 into the PM, the internal chamber of the PM may not complete the rotation operation. This means that the robot should wait at the PM. Such a robot-waiting activity is denoted by A_i3. In addition, the times for A_i1, A_i2, and A_i3 are represented by ω_i1, ω_i2, and ω_i3, respectively.

To meet RTCs, after the wafers are processed in a PM, they should leave the PM within a limited time window. Let δ_i denote such a limited time at Step i, i ∈ N_n\{0}, and d_i denote the wafer delay time of a wafer in a PM at Step i, i.e., the time duration starting from the time point at which the processing activity is completed to the time point at which the robot grasps the wafer for unloading. We use τ_i,12 and τ_i,34 to denote the wafer sojourn time of W_i,12 and W_i,34, respectively. Then, if a schedule for an SF³–CT is feasible, the following constraints should be met:

α_i ≤ τ_i,12 ≤ α_i + δ_i, i ∈ N_n\{0}

(1)

α_i ≤ τ_i,34 ≤ α_i + δ_i, i ∈ N_n\{0}

(2)

2.2. Robot Task Sequences

Assume that there are n (≥2) steps for an SF³–CT. To maximize the productivity of an SF³–CT, under the steady state, each PM should be full of wafers. To maximize the productivity and ensure the feasibility (i.e., meet RTCs) in operating an SF³–CT, it is vital to properly determine a robot task sequence that can be performed periodically. In [11,12], the authors prove that backward and swap are the optimal scheduling strategies for single-arm and dual-arm cluster tools, respectively. With clean and dirty robot fingers, in terms of operation strategies, an SF³–CT is neither a single-arm cluster tool nor a dual-arm cluster tool but a hybrid one that is equivalent to a combination of them; at some steps, swap operations can be applied, while they are not applicable at some other steps. Due to this property, there are two types of operation strategies for an SF³–CT, one is the backward strategy and the other is hybrid strategy, which combines the backward and swap strategies. Next, we present four possible robot task sequences as the operation strategies. Note that the following robot task sequences are presented based on the assumption that the tool operates under a steady state with each PM full of wafers and the clean robot arm F₂ is at a PM of Step n.

The first robot task sequence is a backward strategy, called one-time backward sequence (OBS). For OBS, the clean robot arm F₂ first performs task sequence σ₁ = 〈U_n → M_n,n+1 → L_n+1 → M_n+1,n → U_n → M_n,n+1 → L_n+1 → M_n+1,n−1 → U_n−1 → M_n−1,n → L_n → M_n,n−1 → U_n−1 → M_n−1,n → L_n → M_n,n−2 → … → M_3,1 → U₁ → M_1,2 → L₂ → M_2,1 → U₁ → M_1,2 → L₂〉 to handle clean wafers. Then, the dirty robot arm F₁ performs robot task sequence σ₂ = 〈M_2,0 → U₀ → M_0,1 → L₁ → M_1,0 → U₀ → M_0,1 → L₁ → M_1,n〉 to load raw wafers to the system. Note that, by M_1,n in σ₂, a state is reached such that F₂ is at a PM of Step n. Thus, by sequentially performing σ₁ and σ₂, a production cycle is finished, with four wafers being processed. Notice that, by this strategy, after σ₁ is performed, a PM at Step 1 is emptied.

The second robot task sequence is a hybrid strategy called one-time hybrid task sequence (OHTS). For OHTS, the clean arm F₂ first performs a robot task sequence σ₃ = 〈U_n → M_n,n+1 → L_n+1 → M_n+1,n → U_n → M_n,n+1 → L_n+1 → M_n+1,n−1 → U_n−1 → M_n−1,n → L_n → M_n,n−1 → U_n−1 → M_n−1,n → L_n → M_n,n−2 → … → M_4,2 → U₂ → M_2,3 → L₃ → M_3,2 → U₂ → M_2,3 → L₃〉 to handle clean wafers. Then, arms F₁ and F₂ collaboratively perform robot task sequence σ₄ = 〈M_3,0 → U₀ → M_0,1 → a swap operation at Step 1 → M_1,2 → L₂ → M_2,0 → U₀ → M_0,1 → a swap operation at Step 1 → M_1,2 → L₂ → M_2,n〉 to load raw wafers into the system. Note that, by σ₄, the system reaches a state such that F₂ is at a PM of Step n. Thus, by sequentially performing σ₃ and σ₄, a production cycle is finished with four wafers being processed. Different from OBS, after performing σ₃, a PM at Step 2 is emptied, but no PM at Step 1 is emptied.

The third robot task sequence is also a backward strategy, called two-time backward sequence (TBS). For TBS, F₂ first performs robot task sequence σ₅ = 〈U_n → M_n,n+1 → L_n+1 → M_n+1,n−1 → U_n−1 → M_n−1,n → L_n → M_n,n−2 → … → M_3,1 → U₁ → M_1,2 → L₂〉 to handle clean wafers. Then, σ₆ = 〈M_2,0 → U₀ → M_0,1 → L₁ → M_1,n〉 is performed by F₁ and F₂ together to load raw wafers into the system. After that, σ₅ and σ₆ are sequentially performed again. At this time, each PM in the tool is full of wafers again. Therefore, a production cycle is conducted by performing σ₅ → σ₆ → σ₅ → σ₆, such that each step completes four wafers in such a cycle. By TBS, after performing σ₅ for Steps 1–n, two processed wafers in a PM are moved to the next step for further processing, with two spaces of a PM at Step 1 being emptied.

The last robot task sequence is also a hybrid strategy, called two-time hybrid task sequence (THTS). For THTS, F₂ first performs robot task sequence σ₇ = 〈U_n → M_n,n+1 → L_n+1 → M_n+1,n−1 → U_n−1 → M_n−1,n → L_n → M_n,n−2 → … → M_4,2 → U₂ → M_2,3 → L₃〉 to handle clean wafers. After performing σ₇, σ₈ = 〈M_3,0 → U₀ → M_0,1 → a swap operation at Step 1 → M_1,2 → L₂ → M_2,n〉 is performed by F₁ and F₂ collaboratively to load raw wafers into the system. Then, σ₇ and σ₈ are sequentially performed again. At this time, each PM in the tool is full of wafers again. Therefore, similar to TBS, a production cycle is conducted by sequentially performing σ₇ → σ₈ → σ₇ → σ₈, such that each step completes four wafers in such a cycle. This strategy is similar to TBS; the difference is that, after performing σ₇, no processed wafer at Step 1 is moved to Step 2, and two spaces of a PM at Step 2 are emptied.

With these four robot task sequences, the clean and dirty fingers are correctly used. In σ₁–σ₈, the robot-waiting time is not considered. Although a robot task sequence in each of σ₁–σ₈ is determined, it does not present a schedule since the start and end times of the activities are not given. However, as discussed above, if the robot-waiting time is decided, a schedule is obtained. Thus, to find a feasible and optimal schedule under one of the four robot task sequences, we need to intendedly increase the robot waiting time taken by A_i1. Thus, the key to scheduling an SF³–CT is to determine the robot-waiting time, such that the RTCs are met and the productivity of the system is maximized. The next Section aims to do so.

In this Section, the operational processes of semiconductor fabs using cluster tools are discussed with a focus on wafer flow patterns and the robot task sequence. It describes how dirty and clean wafers are treated separately for a multi-arm and multi-finger robot and how RTC should be met to avoid contamination. It outlines the importance of properly sequencing robot tasks to ensure productivity while maintaining RTCs and provides the foundational details on how wafers are processed in parallel within multi-space process modules.

3. Scheduling Analysis

In this section, we describe the time aspect under OBS, OHTS, TBS, and THTS, respectively. Then, four linear programs are established to find optimal and feasible schedules for an SF³–CT.

3.1. Temporal Properties Under OBS

Let θ_i be the time for processing four wafers at Step i. Under the steady state, to complete four wafers by a PM at Step n, by OBS, with the robot-waiting activities being considered, task sequence σ₉ = 〈U_n → M_n,n+1 → L_n+1 → M_n+1,n → A_n2 → U_n → M_n,n+1 → L_i+1 → M_n+1,n−1 → A_(n−1)1 → U_n−1 → M_n−1,n → L_n → M_n,n−1 → A_(n−1)2 → U_n−1 → M_n−1,i → A_n3 → L_n → the internal chamber of the PM rotates → wafer processing → four wafers stay in the PM after processed (i.e., the delay time)〉 should be performed.

From Figure 3, we can see the task sequence of the robot between PM₁ and PM₂ and between PM₁ and LL as well. In the figure, the red arrows present the wafer movement direction; blue arrows indicate the next step in the process; blank circles represent empty LLs; purple/blue circles represent wafers. In the steps with a yellow circular background, the internal chamber of the PM rotates just before starting to process wafers. Note that different colored wafers are used to clarify the robot task sequence and do not represent different wafers. With m_n parallel PMs serving for Step n, according to σ₉, the time for processing four wafers at the step can be calculated using Equation (3):

θ_n = (α_n + d_n + 8β + 7μ + υ + ω_n2 + ω_n3 + ω_(n−1)1 + ω_(n−1)2)/m_n

(3)

Furthermore, to complete four wafers by a PM of Step i, i ∈ {3, …, n − 1} and n > 2, by OBS, with the robot-waiting activities being considered, task sequence σ₁₀ = 〈U_i → M_i,i+1 → L_i+1 → M_i+1,i → A_i2 → U_i → M_i,i+1 → A_(i+1)3 → L_i+1 → M_i+1,i−1 → A_(i−1)1 → U_i−1 → M_i−1,i → L_i → M_i,i−1 → A_(i−1)2 → U_i−1 → M_i−1,i → A_i3 → L_i → wafer processing → four wafers stay in the PM after processed (i.e., the delay time)〉 should be performed. With m_i parallel PMs serving for Step i, according to σ₁₀, the time for processing four wafers at the step can be calculated using Equation (4):

θ_i = (α_i + d_i + 8β + 7μ + υ + ω_(i+1)3 + ω_i2 + ω_i3 + ω_(i−1)1 + ω_(i−1)2)/m_i, i ∈ {3, …, n − 1} and n > 2

(4)

Similarly, to complete four wafers by a PM of Step 1, by OBS, with the robot-waiting activities being considered, task sequence σ₁₁ = 〈U₁ → M_1,2 → L₂ → M_2,1 → A₁₂ → U₁ → M_1,2 → A₂₃ → L₂ → M_2,0 → U₀ → M_0,1 → L₁ → M_1,0 → U₀ → M_0,1 → A₁₃ → L₁ → the internal chamber of the PM rotates → wafer processing → four wafers stay in the PM after processed (i.e., the delay time)〉 should be performed. With m₁ parallel PMs serving for Step 1, according to σ₁₁, the time for processing four wafers at the step can be calculated with Equation (5):

θ₁ = (α₁ + d₁ + 2β₀ + 6β + 7μ + υ + ω₂₃ + ω₁₂ + ω₁₃)/m₁

(5)

In σ₉, σ₁₀, and σ₁₁, A_i2, i ∈ N_n\{0} is caused by the rotation of the internal chamber of a PM for Step i. Notice that after the robot performs an unloading task at the PM in σ₉, σ₁₀, or σ₁₁ for the first time, the internal chamber of the PM starts to rotate. At the same time, the robot performs task sequence 〈M_i,i+1 → L_i+1 → M_i+1,i〉. Then, A_i2 should be performed, and the time taken for A_i2 is determined by the longest one between the time taken for a rotation operation of the PM and 〈M_i,i+1 → L_i+1 → M_i+1,i〉. Thus, we have the following Equation:

ω_i2 = max(υ − (2μ + β), 0), i ∈ N_n\{0}

(6)

In σ₉, σ₁₀, and σ₁₁, A_i3, i ∈ N_n\N₁ is caused by the rotation of the internal chamber of a PM for Step i as well. Notice that after the robot performs a loading task at Step i in σ₉, σ₁₀, and σ₁₁ for the first time, the internal chamber of the PM starts to rotate. At the same time, the robot performs task sequence 〈M_i,i−1 → A_(i−1)2 → U_i−1 → M_i−1,i〉. Then, A_i3 should be performed, and the time taken for A_i3 is determined by the longest one between the time taken for a rotation operation of a PM for Step i and 〈M_i,i−1 → A_(i−1)2 → U_i−1 → M_i−1,i〉. Thus, we have the following Equation:

ω_i3 = max(υ − (ω_(i−1)2 + 2μ + β), 0), i ∈ N_n\N₁

(7)

Similarly, the time taken for A₁₃ is determined by the longest one between the time taken for a rotation operation of a PM for Step 1 and 〈M_1,0 → U₀ → M_0,1〉, and thus, we have the following Equation:

ω₁₃ = max(υ − (2μ + β₀), 0)

(8)

According to σ₉ and σ₁₀, the time taken for task sequence 〈M_i,i−1 → A_(i−1)2 → U_i−1 → M_i−1,i → A_i3 → L_i → the internal chamber of the PM rotates → wafer processing → four wafers stay in the PM after processed (i.e., the delay time)〉 equals the wafer sojourn time of W_i,12, i ∈ N_n\N₁. Furthermore, the time taken for task sequence 〈the internal chamber of the PM rotates → wafer processing → four wafers stay in the PM after processed (i.e., the delay time) → U_i → M_i,i+1 → L_i+1 → M_i+1,i → A_i2〉 equals the wafer sojourn time of W_i,34, i ∈ N_n\N₁. Then, we have the following Equation:

τ_i,12 = α_i + d_i + υ + 2β + 2μ + ω_(i−1)2 + ω_i3, i ∈ N_n\N₁

(9)

τ_i,34 = α_i + d_i + υ + 2β + 2μ + ω_i2, i ∈ N_n\N₁

(10)

According to σ₁₁, the time taken for task sequence 〈M_1,0 → U₀ → M_0,1 → A₁₃ → L₁ → the internal chamber of the PM rotates → wafer processing → four wafers stay in the PM after processed (i.e., the delay time)〉 equals the wafer sojourn time of W_1,12. Furthermore, the time taken for task sequence 〈the internal chamber of the PM rotates → wafer processing → four wafers stay in the PM after processed (i.e., the delay time) → U₁ → M_1,2 → L₂ → M_2,1 → A₁₂〉 equals the wafer sojourn time of W_1,34. Then, we have the following Equation:

τ_1,12 = α₁ + d₁ + υ + β + β₀ + 2μ + ω₁₃

(11)

τ_1,34 = α₁ + d₁ + υ + 2β + 2μ + ω₁₂

(12)

For OBS, with the robot-waiting activities being considered, σ₁ and σ₂ can be rewritten as 〈U_n → M_n,n+1 → L_n+1 → M_n+1,n → A_n2 → U_n → M_n,n+1 → L_n+1 → M_n+1,n−1 → A_(n−1)1 → U_n−1 → M_n−1,n → L_n → M_n,n−1 → A_(n−1)2 → U_n−1 → M_n−1,n → A_n3 → L_n → M_n,n−2 → … → M_3,1 → A₁₁ → U₁ → M_1,2 → L₂ → M_2,1 → A₁₂ → U₁ → M_1,2 → A₂₃ → L₂〉 and 〈M_2,0 → U₀ → M_0,1 → L₁ → M_1,0 → U₀ → M_0,1 → A₁₃ → L₁ → M_1,n → A_n1〉, respectively. Then, under OBS, the robot cycle time ψ₁ formed by σ₁ and σ₂ together is given as follows:

$${\psi }_1=4(n+1)\mu +2(2n+1)\beta +2{\beta }_0+{\sum }_1^n{\omega }_{i1}+{\sum }_1^n{\omega }_{i2}+{\sum }_1^n{\omega }_{i3}$$

(13)

3.2. Temporal Properties Under OHTS

By OHTS, with the robot-waiting activities being considered, similar to OBS, task sequence σ₉ or σ₁₀ is executed so as to complete four wafers by a PM for Step i, i ∈ N_n\N₂. Thus, with m_i parallel PMs serving for Step i, according to σ₉ and σ₁₀, the time for processing four wafers at Step i, i ∈ N_n\N₂, can be calculated using Equations (3) and (4). We can see the task sequence of the robot among PM₁, PM₂, and LL as presented in Figure 4, where the meaning of colored arrows is same as that in Figure 3. In the steps with a yellow circular background, the internal chamber of the PM rotates just before starting to process wafers.

For Step 2, n > 2, to complete four wafers at a PM, task sequence σ₁₂ = 〈U₂ → M_2,3 → L₃ → M_3,2 → A₂₂ → U₂ → M_2,3 → A₃₃ → L₃ → M_3,0 → U₀ → M_0,1 → A₁₁ → U₁ → the robot rotates → L₁ → M_1,2 → L₂ → M_2,0 → U₀ → M_0,1 → A₁₂ → U₁ → the robot rotates → L₁ → M_1,2 → A₂₃ → L₂ → the internal chamber of the PM rotates → wafer processing → four wafers stay in the PM after processed (i.e., the delay time)〉 should be performed. With m₂ parallel PMs serving for Step 2, according to σ₁₂, the time for processing four wafers at Step 2 can be calculated using Equation (14):

θ₂ = (α₂ + d₂ + 2β₀ + 10β + 11μ + υ + ω₃₃ + ω₂₂ + ω₂₃ + ω₁₁ + ω₁₂)/m₂, n > 2

(14)

For Step 2, n = 2, to complete four wafers at a PM, the robot activity time is equivalent to that of Step 2 with n > 2 in the task sequence. However, the waiting time is not the same due to the absence of Step 3, which is A₃₃. With m₂ parallel PMs serving for Step 2, n = 2, the time for processing four wafers at Step 2 can be calculated using Equation (15).

θ₂ = (α₂ + d₂ + 2β₀ + 10β + 11μ + υ + ω₂₂ + ω₂₃ + ω₁₁ + ω₁₂)/m₂, n = 2

(15)

For Step 1, to complete four wafers by a PM, task sequence σ₁₃ = 〈U₁ → the robot rotates → L₁ → M_1,2 → L₂ → M_2,0 → U₀ → M_0,1 → A₁₂ → U₁ → the robot rotates → L₁ → the internal chamber of the PM rotates → wafer processing → four wafers stay in the PM after processed (i.e., the delay time)〉 should be performed. With m₁ parallel PMs serving for Step 1, according to σ₁₃, the time for processing four wafers at Step 1 can be calculated using Equation (16):

θ₁ = (α₁ + d₁ + β₀ + 5β + 5μ + υ + ω₁₂)/m₁

(16)

The robot-waiting activity A_i2, i ∈ N_n\{0} is caused by the rotation of the internal chamber of a PM for Step i. Similar to OBS, the time taken for A_i2, i ∈ N_n\N₁, is determined by the longest one between the time taken for a rotation operation of the PM and 〈M_i,i+1 → L_i+1 → M_i+1,i〉. Thus, ω_i2, i ∈ N_n\N₁ can be obtained using Equation (6).

Observing σ₁₃, after the robot performs a loading task at Step 1 for the first time so as to complete a robot rotation operation, the internal chamber of the PM starts to rotate. At the same time, the robot performs the task sequence 〈M_1,2 → L₂ → M_2,0 → U₀ → M_0,1〉. Thus, the time taken for A₁₂ is determined by the longest one between the time taken for a rotation operation of the PM and 〈M_1,2 → L₂ → M_2,0 → U₀ → M_0,1〉. Therefore, ω₁₂ can be calculated using Equation (17):

ω₁₂ = max(υ − (β + β₀ + 3μ), 0)

(17)

The robot-waiting activity A_i3, i ∈ N_n\{0} is caused by the rotation of the internal chamber of a PM for Step i as well. Similar to OBS, the time taken for A_i3, i ∈ N_n\N₂ is determined by the longest one between the time taken for a rotation operation of a PM for Step i and 〈M_i,i−1 → A_(i−1)2 → U_i−1 → M_i−1,i〉. Thus, ω_i3, i ∈ N_n\N₂, can be obtained using Equation (7).

Observing σ₁₂, after the robot performs a loading task at Step 2 for the first time, the internal chamber of the PM starts to rotate. At the same time, the robot performs task sequence 〈M_2,0 → U₀ → M_0,1 → A₁₂ → U₁ → the robot rotates → L₁ → M_1,2〉. Thus, the time taken for A₂₃ is determined by the longest one between the time taken for a rotation operation of the PM and 〈M_2,0 → U₀ → M_0,1 → A₁₂ → U₁ → the robot rotates → L₁ → M_1,2〉. Therefore, Equation (18) is given to calculate ω₂₃:

ω₂₃ = max(υ − (2β + β₀ + 4μ + ω₁₂), 0)

(18)

Notice that A₁₃ represents the robot-waiting activity at a PM for Step 1 before the robot loads wafers represented by W_1,34 into the PM. Observing σ₁₃, since the robot performs a swap operation at the PM such that these wafers are loaded into the PM, it implies that A₁₃ is not necessary.

Moreover, similar to OBS, for Step i, i ∈ N_n\N₂, the wafer sojourn time of W_i,12 and W_i,34 can be obtained by (9) and (10), respectively. For Step 2, observing σ₁₂, the time taken for task sequence 〈M_2,0 → U₀ → M_0,1 → A₁₂ → U₁ → the robot rotates → L₁ → M_1,2 → A₂₃ → L₂ → the internal chamber of the PM rotates → wafer processing → four wafers stay in the PM after processed (i.e., the delay time)〉 equals the wafer sojourn time of W_2,12. Also, the time taken for task sequence 〈the internal chamber of the PM rotates → wafer processing → four wafers stay in the PM after processed (i.e., the delay time) → U₂ → M_2,3 → L₃ → M_3,2 → A₂₂〉 equals the wafer sojourn time of W_2,34. Then, Equation (19) is given to obtain τ_2,12, while τ_2,34 can be obtained by (10).

τ_2,12 = α₂ + d₂ + υ + β₀ + 3β + 4μ + ω₁₂ + ω₂₃

(19)

For Step 1, observing σ₁₃, the time taken for task sequence 〈M_1,2 → L₂ → M_2,0 → U₀ → M_0,1 → A₁₂ → U₁ → the robot rotates → L₁ → the internal chamber of the PM rotates → wafer processing → four wafers stay in the PM after processed (i.e., the delay time)〉 equals the wafer sojourn time of W_1,12, and the time taken for task sequence 〈the internal chamber of the PM rotates → wafer processing → four wafers stay in the PM after processed (i.e., the delay time) → U₁ → the robot rotates → L₁ → M_1,2 → L₂ → M_2,0 → U₀ → M_0,1 → A₁₂〉 equals the wafer sojourn time of W_1,34. Therefore, we have the following Equation:

τ_1,12 = τ_1,34 = α₁ + d₁ + υ + 3β + β₀ + 4μ + ω₁₂

(20)

For OHTS, with the robot-waiting activities being considered, σ₃ and σ₄ can be rewritten as 〈U_n → M_n,n+1 → L_n+1 → M_n+1,n → A_n2 → U_n → M_n,n+1 → L_n+1 → M_n+1,n−1 → A_(n−1)1 → U_n−1 → M_n−1,n → L_n → M_n,n−1 → A_(n−1)2 → U_n−1 → M_n−1,n → A_n3 → L_n → M_n,n−2 → … → M_4,2 → A₂₁ → U₂ → M_2,3 → L₃ → M_3,2 → A₂₂ → U₂ → M_2,3 → A₃₃ → L₃〉 and 〈M_3,0 → U₀ → M_0,1 → A₁₁ → performing a swap operation at Step 1 → M_1,2 → L₂ → M_2,0 → U₀ → M_0,1 → A₁₂ → performing a swap operation at Step 1 → M_1,2 → A₂₃ → L₂ → M_2,n〉, respectively. Then, under OHTS, the robot cycle time ψ₂ formed by σ₃ and σ₄ together can be calculated as follows:

$${\psi }_2=4(n+1)\mu +2(2n+1)\beta +2{\beta }_0+{\sum }_1^n{\omega }_{i1}+{\sum }_1^n{\omega }_{i2}+{\sum }_1^n{\omega }_{i3}$$

(21)

3.3. Temporal Properties Under TBS

Under the steady state, to complete four wafers at a PM for Step i, i ∈ N_n\N₁, by TBS, with the robot-waiting activities being considered, task sequence σ₁₄ = 〈U_i → M_i,i+1 → L_i+1 → M_i+1,i−1 → A_(i−1)1 → U_i−1 → M_i−1,i → L_i → M_i,i−2 → … → M_3,1 → A₁₁ → U₁ → M_1,2 → L₂ → M_2,0 → U₀ → M_0,1 → L₁ → M_1,n → A_n2 → U_n → M_n,n+1 → L_n+1 → M_n+1,n−1 → … → M_i+1,i−1 → A_(i−1)2 → U_i−1 → M_i−1,i → L_i → the internal chamber of the PM rotates → wafer processing → four wafers stay in the PM after processed (i.e., the delay time)〉 should be performed. Figure 5 shows the robot task sequence under the TBS strategy with part of the backward process omitted, in the figure the meaning of the colored arrows is same as that in Figure 3. The steps with a yellow circular background similarly indicate the internal chamber rotation of the PM before the processing step. With m_i parallel PMs serving for Step i, according to σ₁₄, the time for processing four wafers can be calculated with Equation (22):

$${\theta }_i=[{\alpha }_i+d_i+(2n+5)\beta +{\beta }_0+(2n+5)\mu +\upsilon +{\sum }_1^{i-1}{\omega }_{i1}+{\sum }_{i-1}^n{\omega }_{i2}]/m_i,i\in {\mathbf{N}}_n/{\mathbf{N}}_1$$

(22)

Similarly, to complete four wafers by a PM for Step 1, by TBS, with the robot-waiting activities being considered, task sequence σ₁₅ = 〈U₁ → M_1,2 → L₂ → M_2,0 → U₀ → M_0,1 → L₁ → M_1,n → A_n2 → U_n → M_n,n+1 → L_n+1 → M_n+1,n−1 → … → M_2,0 → U₀ → M_0,1 → L₁ → the internal chamber of the PM rotates → wafer processing → four wafers stay in the PM after processed (i.e., the delay time)〉 should be performed. With m₁ parallel PMs serving for Step 1, according to σ₁₅, the time for processing four wafers can be calculated using Equation (23):

$${\theta }_1=[{\alpha }_1+d_1+(2n+4)\beta +2{\beta }_0+(2n+5)\mu +\upsilon +{\sum }_1^n{\omega }_{i2}]/m_1$$

(23)

In σ₁₄, A_i2 is also caused by the rotation of the internal chamber of a PM for Step i. After the robot performs a loading task at the PM in σ₁₄ for the first time, the internal chamber of the PM starts to rotate. At the same time, the robot performs task sequence 〈M_i,i−2 → A_(i−2)1 → U_i−2 → M_i−2,i−1 → L_i−1 → M_i−1,i−3 → … → M_2,0 → U₀ → M_0,1 → L₁ → M_1,n → A_n2 → U_n → M_n,n+1 → L_n+1 → M_n+1,n−1 → … → M_i+2,i〉. It follows from this sequence that A₁₂ and A₂₂ are different, implying that A_i2 is dependent on n. Thus, we divide it into two cases: n = 2 and n > 2. If n > 2, A_i2, i ∈ {3, 4, …, n − 1} should be performed. And the time taken for A_i2 is determined by the longest one between the time taken for a rotation operation of the PM and 〈M_i,i−2 → A_(i−2)1 → U_i−2 → M_i−2,i−1 → L_i−1 → M_i−1,i−3 → … → M_2,0 → U₀ → M_0,1 → L₁ → M_1,n → A_n2 → U_n → M_n,n+1 → L_n+1 → M_n+1,n−1 → … → M_i+2,i〉. When i = 2 and n > 2, the time taken for A₂₂ is determined by the longest one between the time taken for a rotation operation of the PM and 〈M_2,0 → U₀ → M_0,1 → L₁ → M_1,n → A_n2 → U_n → M_n,n+1 → L_n+1 → M_n+1,n−1 → … → M_i+2,i → A_i2 → U_i → M_i,i+1 → L_i+1 → M_i+1,i−1 → … → M_5,3 → A₃₂ → U₃ → M_3,4 → L₄ → M_4,2〉. When n = 2, A₂₂ should be performed. And the time taken for A₂₂ is determined by the longest one between the time taken for a rotation operation of the PM and 〈M_2,0 → U₀ → M_0,1 → L₁ → M_1,2〉. Thus, we have the following Equations:

$${\omega }_{i2}=max(\upsilon -[(2n-1)\mu +(2n-3)\beta +{\beta }_0+{\sum }_1^{i-2}{\omega }_{i1}+{\sum }_{i+1}^n{\omega }_{i2}],0),i\in \{3,4,\dots ,n-1\}\mathrm{and}n>3$$

(24)

$${\omega }_{22}=max(\upsilon -[(2n-1)\mu +(2n-3)\beta +{\beta }_0+{\sum }_3^n{\omega }_{i2}],0),n>2$$

(25)

ω₂₂ = max(υ − (3μ + β + β₀), 0), n = 2

(26)

When i = n and n > 2, the robot performs task sequence 〈M_n,n−2 → A_(n−2)1 → U_n−2 → M_n−2,n−1 → L_n−1 → M_n−1,n−3 → … → M_2,0 → U₀ → M_0,1 → L₁ → M_1,n〉. Then, A_n2 should be performed. And the time taken for A_n2 is determined by the longest one between the time taken for a rotation operation of the PM and 〈M_n,n−2 → A_(n−2)1 → U_n−2 → M_n−2,n−1 → L_n−1 → M_n−1,n−3 → … → M_2,0 → U₀ → M_0,1 → L₁ → M_1,n〉. Then, we can obtain ω_n2 as follows:

$${\omega }_{n2}=max(\upsilon -[(2n-1)\mu +(2n-3)\beta +{\beta }_0+{\sum }_1^{n-2}{\omega }_{i1}],0),n>2$$

(27)

Similarly, we have

$${\omega }_{12}=max(\upsilon -[(2n-1)\mu +(2n-2)\beta +{\sum }_2^n{\omega }_{i2}],0).$$

(28)

According to σ₁₄, the time taken for task sequence 〈M_i,i−2 → A_(i−2)1 → U_i−2 → M_i−2,i−1 → L_i−1 → M_i−1,i−3 → … → M_2,0 → U₀ → M_0,1 → L₁ → M_1,n → A_n2 → U_n → M_n,n+1 → L_n+1 → M_n+1,n−1 → … → M_i+1,i−1 → A_(i−1)2 → U_i−1 → M_i−1,i → L_i → the internal chamber of the PM rotates → wafer processing → four wafers stay in the PM after processed (i.e., the delay time)〉 equals the wafer sojourn time of W_i,12, i ∈ N_n\N₂. Furthermore, the time taken for the task sequence 〈the internal chamber of the PM rotates → wafer processing → four wafers stay in the PM after processed (i.e., the delay time) → U_i → M_i,i+1 → L_i+1 → M_i+1,i−1 → A_(i−1)1 → U_i−1 → M_i−1,i → L_i → M_i,i−2 → … → M_2,0 → U₀ → M_0,1 → L₁ → M_1,n → A_n2 → U_n → M_n,n+1 → L_n+1 → M_n+1,n−1 → … → M_i+2,i → A_i2〉 equals the wafer sojourn time of W_i,34, i ∈ N_n\N₁. Hence, we have the following:

$${\tau }_{i,12}={\alpha }_i+d_i+\upsilon +\left(2n+1\right)\beta +{\beta }_0+\left(2n+2\right)\mu +{\sum }_1^{i-2}{\omega }_{i1}+{\sum }_{i-1}^n{\omega }_{i2},i\in {\mathbf{N}}_n\backslash {\mathbf{N}}_2,n>2$$

(29)

$${\tau }_{i,34}={\alpha }_i+d_i+\upsilon +\left(2n+1\right)\beta +{\beta }_0+\left(2n+2\right)\mu +{\sum }_1^{i-1}{\omega }_{i1}+{\sum }_i^n{\omega }_{i2},i\in {\mathbf{N}}_n\backslash {\mathbf{N}}_1$$

(30)

For Step 2, the time taken for task sequence 〈M_2,0 → U₀ → M_0,1 → L₁ → M_1,n → … → M_i+1,i−1 → A_(i−1)2 → U_i−1 → M_i−1,i → L_i → M_i,i−1 → … → M_3,1 → A₁₂ → U₁ → M_1,2 → L₂ → the internal chamber of the PM rotates → wafer processing → four wafers stay in the PM after processed (i.e., the delay time)〉 equals the wafer sojourn time of W_2,12 that can be calculated with Equation (31), and the wafer sojourn time of W_2,34 is the same as that of W_2,12. We have the following:

$${\tau }_{2,12}={\tau }_{2,34}={\alpha }_2+d_2+\upsilon +(2n+1)\beta +{\beta }_0+(2n+2)\mu +{\sum }_1^n{\omega }_{i2}$$

(31)

According to σ₁₅, the time taken for task sequence 〈M_1,n → A_n2 → U_n → M_n,n+1 → L_n+1 → M_n+1,n−1 → A_(n−1)2 → U_n−1 → M_n−1,n → L_n → M_n,n−2 → … → M_2,0 → U₀ → M_0,1 → L₁ → the internal chamber of the PM rotates → wafer processing → four wafers stay in the PM after processed (i.e., the delay time)〉 equals the wafer sojourn time of W_1,12. Furthermore, the time taken for task sequence 〈the internal chamber of the PM rotates → wafer processing → four wafers stay in the PM after processed (i.e., the delay time) → U₁ → M_1,2 → L₂ → M_2,0 → U₀ → M_0,1 → L₁ → M_1,n → A_n2 → U_n → M_n,n+1 → L_n+1 → M_n+1,n−1 → … → M_3,1 → A₁₂〉 equals the wafer sojourn time of W_1,34. Based on the above analysis, we show τ_1,12 = τ_1,34, and we have the following:

$${\tau }_{1,12}={\tau }_{1,34}={\alpha }_1+d_1+\upsilon +(2n+1)\beta +{\beta }_0+(2n+2)\mu +{\sum }_1^n{\omega }_{i2}$$

(32)

For TBS, with the robot-waiting activities being considered, σ₅ can be rewritten as ${\sigma }_5^1$ = 〈U_n → M_n,n+1 → L_n+1 → M_n+1,n−1 → A_(n−1)1 → U_n−1 → M_n−1,n → L_n → M_n,n−2 → … → M_3,1 → A₁₁ → U₁ → M_1,2 → L₂〉 and ${\sigma }_5^2$ = 〈U_n → M_n,n+1 → L_n+1 → M_n+1,n−1 → A_(n−1)2 → U_n−1 → M_n−1,n → L_n → M_n,n−2 → … → M_3,1 → A₁₂ → U₁ → M_1,2 → L₂〉; while σ₆ can be rewritten as ${\sigma }_6^1$ = 〈M_2,0 → U₀ → M_0,1 → L₁ → M_1,n → A_n2〉 and ${\sigma }_6^2$ = 〈M_2,0 → U₀ → M_0,1 → L₁ → M_1,n → A_n1〉. Then, under TBS, the robot cycle time ψ₃ taken by ${\sigma }_5^1$, ${\sigma }_5^2$, ${\sigma }_6^1$, and ${\sigma }_6^2$ together can be obtained as follows:

$${\psi }_3=4(n+1)\mu +2(2n+1)\beta +2{\beta }_0+{\sum }_1^n{\omega }_{i1}+{\sum }_1^n{\omega }_{i2}$$

(33)

3.4. Temporal Properties Under THTS

Similar to TBS, to complete four wafers by a PM for Step i, i ∈ N_n\N₂ and n > 2, by THTS, task sequence σ₁₆ = 〈U_i → M_i,i+1 → L_i+1 → M_i+1,i−1 → A_(i−1)1 → U_i−1 → M_i−1,i → L_i → M_i,i−2 → … → M_3,0 → U₀ → M_0,1 → A₁₁ → U₁ → the robot rotates → L₁ → M_1,2 → L₂ → M_2,n → A_n2 → U_n → M_n,n+1 → L_n+1 → M_n+1,n−1 → … → M_i+1,i−1 → A_(i−1)2 → U_i−1 → M_i−1,i → L_i → the internal chamber of the PM rotates → wafer processing → four wafers stay in the PM after processed (i.e., the delay time)〉 should be performed. Figure 6 presents the robot task sequence under the THTS strategy with part of the backward process omitted, in the figure, the meaning of the colored arrows is same as that in Figure 3. The steps with a yellow circular background similarly indicate the internal chamber rotation of the PM before the processing step. Thus, with m_i parallel PMs serving for Step i, according to σ₁₆, the time for processing four wafers at Step i, i ∈ N_n\N₂ and n > 2, can be calculated with Equation (34):

$${\theta }_i=[{\alpha }_i+d_i+(2n+5)\beta +{\beta }_0+(2n+5)\mu +\upsilon +{\sum }_1^{i-1}{\omega }_{i1}+{\sum }_{i-1}^n{\omega }_{i2}]/m_i,i\in {\mathbf{N}}_n\backslash {\mathbf{N}}_2\mathrm{and}n>2$$

(34)

For Step 2, n > 2, to complete four wafers by a PM, task sequence σ₁₇ = 〈U₂ → M_2,3 → L₃ → M_3,0 → U₀ → M_0,1 → A₁₁ → U₁ → the robot rotates → L₁ → M_1,2 → L₂ → M_2,n → A_n2 → U_n → M_n,n+1 → L_n+1 → M_n+1,n−1 → … → M_3,0 → U₀ → M_0,1 → A₁₂ → U₁ → the robot rotates → L₁ → M_1,2 → L₂ → the internal chamber of the PM rotates → wafer processing → four wafers stay in the PM after processed (i.e., the delay time)〉 should be performed. When n = 2, for Step 2, to complete four wafers by a PM, the task sequence σ₁₈ = 〈U₂ → M_2,0 → U₀ → the robot rotates → L₀ → M_0,1 → A₁₁ → U₁ → the robot rotates → L₁ → M_1,2 → L₂ → the internal chamber of the PM rotates → U₂ → M_2,0 → U₀ → the robot rotates → L₀ → M_0,1 → A₁₂ → U₁ → the robot rotates → L₁ → M_1,2 → L₂ → the internal chamber of the PM rotates → wafer processing → four wafers stay in the PM after processed (i.e., the delay time)〉 should be performed. With m₂ parallel PMs serving for Step 2, according to σ₁₇ and σ₁₈, the time for processing four wafers at Step 2 can be calculated using Equations (35) and (36):

$${\theta }_2=[{\alpha }_2+d_2+(2n+6)\beta +2{\beta }_0+(2n+7)\mu +\upsilon +{\mathsf{\omega }}_{11}+{\sum }_1^n{\omega }_{i2}]/m_2,n>2$$

(35)

θ₂ = (α₂ + d₂ + 10β + 2β₀ + 10μ + 2υ + ω₁₁ + ω₁₂)/m₂, n = 2

(36)

For Step 1, n > 2, to complete four wafers by a PM, task sequence σ₁₉ = 〈U₁ → the robot rotates → L₁ → M_1,2 → L₂ → M_2,n → A_n2 → U_n → M_n,n+1 → L_n+1 → M_n+1,n−1 → … → M_3,0 → U₀ → M_0,1 → A₁₂ → U₁ → the robot rotates → L₁ → the internal chamber of the PM rotates → wafer processing → four wafers stay in the PM after processed (i.e., the delay time)〉 should be performed. When n = 2, for Step 1, to complete four wafers by a PM, the task sequence σ₂₀ = 〈U₁ → the robot rotates → L₁ → M_1,2 → L₂ → the internal chamber of the PM rotates → U₂ → M_2,0 → U₀ → the robot rotates → L₀ → M_0,1 → A₁₂ → U₁ → the robot rotates → L₁ → the internal chamber of the PM rotates → wafer processing → four wafers stay in the PM after processed (i.e., the delay time)〉 should be performed. With m₁ parallel PMs serving for Step 1, according to σ₁₉ and σ₂₀, the time for processing four wafers at Step 1 can be calculated with Equations (37) and (38):

$${\theta }_1=[{\alpha }_1+d_1+(2n+3)\beta +{\beta }_0+(2n+3)\mu +\upsilon +{\sum }_1^n{\omega }_{i2}]/m_1,n>2$$

(37)

θ₁ = (α₁ + d₁ + 7β + β₀ + 6μ + 2υ + ω₁₂)/m₁, n = 2

(38)

By observing σ₁₆, the time taken for the robot-waiting activity A_i2, i ∈ {3, …, n − 1} and n > 3, is determined by the longest one between the time taken for a rotation operation of the PM and 〈M_i,i−2 → A_(i−2)1 → U_i−2 → M_i−2,i−1 → L_i−1 → M_i−1,i−3 → … → M_3,0 → U₀ → M_0,1 → A₁₁ → U₁ → the robot rotates → L₁ → M_1,2 → L₂ → M_2,n → A_n2 → U_n → M_n,n+1 → L_n+1 → M_n+1,n−1 → … → M_i+2,i〉. When n > 2, A_i2 is determined by the longest one between the time taken for a rotation operation of the PM and 〈M_n,n−2 → A_(n−2)1 → U_n−2 → M_n−2,n−1 → L_n−1 → M_n−1,n−3 → … → M_3,0 → U₀ → M_0,1 → A₁₁ → U₁ → the robot rotates → L₁ → M_1,2 → L₂ → M_2,n〉. Thus, ω_i2, i ∈ {3, …, n − 1} and n > 3, and ω_n2, n > 2 can be obtained with Equations (39) and (40):

$${\omega }_{i2}=\mathit{max}(\upsilon -[(2n-1)\mu +(2n-3)\beta +{\beta }_0+{\sum }_1^{i-2}{\omega }_{i1}+{\sum }_{i+1}^n{\omega }_{i2}],0),i\in \{3,4,\dots ,n-1\}\mathrm{and}n>3$$

(39)

$${\omega }_{n2}=\mathit{max}(\upsilon -[(2n-1)\mu +(2n-3)\beta +{\beta }_0+{\sum }_1^{n-2}{\omega }_{i1}],0),n>2$$

(40)

Observing σ₁₇ and σ₁₈, after the robot performs a loading task at Step 2 for the first time so as to complete a robot rotation operation, the internal chamber of the PM starts to rotate. Hence, the time taken for the robot-waiting activity A₂₂, n > 2, is determined by the longest one between the time taken for a rotation operation of the PM and 〈M_2,n → A_n2 → U_n → M_n,n+1 → L_n+1 → M_n+1,n−1 → … → M_5,3 → A₃₂ → U₃ → M_3,4 → L₄ → M_4,2〉. When n = 2, the robot just needs to wait for the completion of the internal rotation of the PM. Therefore, ω₂₂ should be calculated using Equations (41) and (42):

$${\omega }_{22}=\max (\upsilon -[(2n-3)\mu +2(n-2)\beta +{\sum }_3^n{\omega }_{i2}],0),n>2$$

(41)

ω₂₂ = υ, n = 2

(42)

Observing σ₁₉ and σ₂₀, after the robot performs a loading task at Step 1 for the first time so as to complete a robot rotation operation, the internal chamber of the PM starts to rotate. Hence, the time taken for robot-waiting activity A₁₂, n > 2, is determined by the longest one between the time taken for a rotation operation of the PM and 〈M_1,2 → L₂ → M_2,n → A_n2 → U_n → M_n,n+1 → L_n+1 → M_n+1,n−1 → … → M_5,3 → A₃₂ → U₃ → M_3,4 → L₄ → M_4,2 → A₂₂ → U₂ → M_2,3 → L₃ → M_3,0→ U₀ → M_0,1〉. When n = 2, the time taken for robot waiting activity A₁₂ is determined by the longest one between the time taken for a rotation operation of the PM and 〈M_1,2 → L₂ → A₂₂ → U₂ → M_2,0 → U₀ → the robot rotates → L₀ → M_0,1〉. Thus, ω₁₂ should be calculated with Equations (43) and (44):

$${\omega }_{12}=\max (\upsilon -[(2n+1)\mu +(2n-1)\beta +{\sum }_2^n{\omega }_{i2}],0),n>2$$

(43)

ω₁₂ = max(υ − (4μ + 3β + β₀ + υ), 0), n = 2

(44)

Similar to TBS, for Step i, i ∈ N_n\N₂, the wafer sojourn time of W_i,12 and W_i,34 can be obtained with (29) and (30), respectively. For Step 2, n > 2, the wafer sojourn time of W_2,12 and W_2,34 can be obtained using (31) and (32), respectively. For Step 2, n = 2, the time taken for task sequence 〈the internal chamber of the PM rotates → U₂ → M_2,0 → U₀ → the robot rotates → L₀ → M_0,1 → A₁₂ → U₁ → the robot rotates → L₁ →M_1,2 → L₂ → the internal chamber of the PM rotates → wafer processing → four wafers stay in the PM after processed (i.e., the delay time)〉 equals the wafer sojourn time of W_2,12. Furthermore, the time taken for task sequence 〈the internal chamber of the PM rotates → wafer processing → four wafers stay in the PM after processed (i.e., the delay time) → U₂ → M_2,0 → U₀ → the robot rotates → L₀ → M_0,1 → A₁₁ → U₁ → the robot rotates → L₁ → M_1,2 → L₂ → the internal chamber of the PM rotates〉 equals the wafer sojourn time of W_2,34. Therefore, the wafer sojourn time of W_2,12 and W_2,34 can be calculated using Equations (45) and (46):

τ_2,12 = α₂ + d₂ + 2υ + 5β + β₀ + 5μ + ω₁₂, n = 2

(45)

τ_2,34 = α₂ + d₂ + 2υ + 5β + β₀ + 5μ + ω₁₁, n = 2

(46)

For Step 1, n > 2, the time taken for the task sequence 〈M_1,2 → L₂ → M_2,n → A_n2 → U_n → M_n,n+1 → L_n+1 → M_n+1,n−1 → … → M_3,0 → U₀ → M_0,1 → A₁₂ → U₁ → the robot rotates → L₁ → the internal chamber of the PM rotates → wafer processing → four wafers stay in the PM after processed (i.e., the delay time)〉 equals the wafer sojourn time of W_1,12. Furthermore, the time taken for the task sequence 〈the internal chamber of the PM rotates → wafer processing → four wafers stay in the PM after processed (i.e., the delay time) → U₁ → the robot rotates → L₁ → M_1,2 → L₂ → M_2,n → A_n2 → U_n → M_n,n+1 → L_n+1 → M_n+1,n−1 → … → M_4,2 → A_4,22 → U₂ → M_2,3 → L₃ → M_3,0 → U₀ → M_0,1 → A₁₂〉 equals the wafer sojourn time of W_1,34. Based on the above analysis, we obtain that τ_1,12 = τ_1,34, n > 2, and they can be calculated as follows:

$${\tau }_{1,12}={\tau }_{1,34}={\alpha }_1+d_1+\upsilon +(2n+1)\beta +{\beta }_0+(2n+2)\mu +{\sum }_1^n{\omega }_{i2},n>2$$

(47)

For Step 1, n = 2, the time taken for task sequence 〈M_1,2 → L₂ → the internal chamber of the PM rotates → U₂ → M_2,0 → U₀ → the robot rotates → L₀ → M_0,1 → A₁₂ → U₁ → the robot rotates → L₁ → the internal chamber of the PM rotates → wafer processing → four wafers stay in the PM after processed (i.e., the delay time)〉 equals the wafer sojourn time of W_1,12. Furthermore, the time taken for task sequence 〈the internal chamber of the PM rotates → wafer processing → four wafers stay in the PM after processed (i.e., the delay time) → U₁ → the robot rotates → L₁ → M_1,2 → L₂ → the internal chamber of the PM rotates → U₂ → M_2,0 → U₀ → the robot rotates → L₀ → M_0,1 → A₁₂〉 equals the sojourn time of W_1,34. Therefore, the wafer sojourn time of W_1,12 and W_1,34 can be calculated using Equation (48):

τ_1,12 = τ_1,34 = α₁ + d₁ + 2υ + 5β + β₀ + 5μ + ω₁₂, n = 2

(48)

For THTS, with the robot-waiting activities being considered, σ₇ can be rewritten as ${\sigma }_7^1$ = 〈U_n → M_n,n+1 → L_n+1 → M_n+1,n−1 → A_(n−1)1 → U_n−1 → M_n−1,n → L_n → M_n,n−2 → … → M_4,2 → A₂₁ → U₂ → M_2,3 → L₃〉 and ${\sigma }_7^2$ = 〈U_n → M_n,n+1 → L_n+1 → M_n+1,n−1 → A_(n−1)2 → U_n−1 → M_n−1,n → L_n → M_n,n−2 → … → M_4,2 → A₂₂ → U₂ → M_2,3 → L₃〉, while σ₈ can be rewritten as ${\sigma }_8^1$ = 〈M_3,0 → U₀ → M_0,1 → A₁₁ → performing a swap operation at Step 1 → M_1,2 → L₂ → M_2,n → A_n1〉 and ${\sigma }_8^2$ = 〈M_3,0 → U₀ → M_0,1 → A₁₂ → performing a swap operation at Step 1 → M_1,2 → L₂ → M_2,n → A_n2〉. Then, under THTS, the robot cycle time ψ₄ taken by ${\sigma }_7^1$, ${\sigma }_7^2$, ${\sigma }_8^1$, and ${\sigma }_8^2$ together can be obtained as follows:

$${\psi }_4=4(n+1)\mu +2(2n+1)\mu +2{\mu }_0+{\sum }_1^n{\omega }_{i1}+{\sum }_1^n{\omega }_{i2}$$

(49)

3.5. Linear Programs for Solution

By any one of OBS, OHTS, TBS, and THTS, if an SF³–CT operates under the steady state, in a robot task cycle, each step completes four wafers, and four completed wafers are returned to LLs. Also, the time taken to complete four wafers at each step equals the robot cycle time. Thus, we have Propositions 1–4:

Proposition 1.

For an SF³–CT, if the tool is operated by OBS under the steady state, the robot cycle time equals the time for completing four wafers at each step, i.e., Equations (50)–(52) hold:

ψ₁ = θ₁

(50)

ψ₁ = θ_i, i ∈ N_n\N₁ and n > 2

(51)

ψ₁ = θ_n

(52)

where θ_n, θ_i, i ∈ N_n\N₁ and n > 2, and θ₁ are obtained by (3)–(5), respectively.

Proposition 2.

For an SF³–CT, if the tool is operated by OHTS under the steady state, the robot cycle time equals the time for completing four wafers at each step, i.e., Equations (53)–(56) hold:

ψ₂ = θ₁

(53)

ψ₂ = θ₂, n ≥ 2

(54)

ψ₂ = θ_i, i ∈ {2, 3, …, n − 1} and n > 3

(55)

ψ₂ = θ_n

(56)

where θ₂, n > 2; θ₂, n = 2; θ₁; θ_i, i ∈ {2, 3, …, n − 1} and n > 3; and θ_n are obtained by (14)–(16), (4), and (3), respectively.

Proposition 3.

For an SF³–CT, if the tool is operated by TBS under the steady state, the robot cycle time equals the time for completing four wafers at each step, i.e., Equation (57) holds:

ψ₃ = θ₁ = θ_i

(57)

where θ₁ and θ_i are obtained by (23) and (22), respectively.

Proposition 4.

For an SF³–CT, if the tool is operated by THTS under the steady state, the robot cycle time equals the time for completing four wafers at each step, i.e., Equations (58)–(60) hold:

ψ₄ = θ₁ = θ₂, n = 2

(58)

ψ₄ = θ₁ = θ₂, n > 2

(59)

ψ₄ = θ_i, i ∈ N_n\N₂ and n > 2

(60)

where θ_i, i ∈ N_n\N₂ and n > 2; θ₂, n > 2; θ₂, n = 2; θ₁, n = 2; and θ₁, n > 2, are obtained by (34)-(38), respectively.

Also to meet RTCs, (1) and (2) should be held when any strategy is applied. Note that A_i2 and A_i3 occur during the processes for unloading wafers from a PM and loading wafers into a PM, respectively. Thus, in terms of the satisfaction of RTCs, it is desired that ω_i2 and ω_i3 (the time taken by A_i2 and A_i3) should be as short as possible. Hence, with this observation in mind, according to the above analysis, ω_i2 and ω_i3 are already determined.

Due to that, for a steady-state schedule, the cycle time for each processing step is the same, and it should be equal to the robot cycle time; when the robot-waiting time at all the steps is determined, a schedule is obtained. Note that the robot-waiting time is a continuous variable. The problem becomes a continuous optimization problem but not a discrete optimization problem. Hence, given a strategy, to find a schedule is to determine ω_i1 (the time taken by A_i1). Based on Propositions 1–4, we establish four linear programs for different strategies to find optimal and feasible schedules with the objective of minimizing the robot cycle time, i.e., the system cycle time. Based on the property of a schedule, when a schedule is found, the robot’s time occupancy is known.

Linear Program 1 (LP1).

For an SF³–CT, if the tool is operated by OBS under the steady state, a linear program is established to obtain a schedule as follows:

Minimize ψ₁

Subject to: (1)–(13), (50)–(52).

In LP1, Constraints (1) and (2) guarantee that the wafer sojourn time is within the permissible time windows. Constraints (3)–(5) calculate the time required to complete four wafers at each step from Steps 1 to n. Then, Constraints (6)–(8) calculate the time for robot-waiting activities A_i2 and A_i3 at each step. Constraints (9)–(12) determine the sojourn time of W_i,12 and W_i,34. Equation (15) obtains the robot cycle time under OBS. Constraints (50)–(52) come from Proposition 1, and we can obtain ω_i1 and ψ₁.

Linear Program 2 (LP2).

For an SF³–CT, if the tool is operated by OHTS under the steady state, a linear program is established to obtain a schedule as follows:

Minimize ψ₂

Subject to: (1)–(3),

(14)–(21), (53)–(56)

(4) where i ∈ {2, 3, …, n − 1} and n > 3,

(6) and (10) where i ∈ N_n\N₁, and

(7) and (9) where i ∈ N_n\N₂.

In LP2, similar to LP1, Constraints (1) and (2) guarantee that the RTCs are satisfied. Constraints (3), (4), (14), and (15) calculate the time required to complete four wafers at each step from Steps 1 to n. Then, Constraints (6), (7), (17), and (18) calculate the time for robot-waiting activities A_i2 and A_i3 at each step. Constraints (9), (10), (19), and (20) determine the sojourn time of W_i,12 and W_i,34. Equation (20) obtains the robot cycle time under OHTS, i.e., the system cycle time. Constraints (53)–(56) come from Proposition 2, and we can obtain ω_i1 and ψ₂.

Linear Program 3 (LP3).

For an SF³–CT, if the tool is operated by TBS under the steady state, a linear program is established to obtain a schedule as follows.

Minimize ψ₃

Subject to: (1), (2), (22)–(33), (57)

Similar to LP1 and LP2, Constraints (1) and (2) guarantee that the RTCs are satisfied. Constraints (22) and (23) calculate the time required to complete four wafers at each step from Steps 1 to n. Then, Constraints (24)–(28) calculate the time for robot waiting activities A_i2 at each step. Constraints (29)–(32) determine the sojourn time of W_i,12 and W_i,34. Equation (33) obtains the robot cycle time under TBS. Constraint (57) comes from Proposition 3, and we can obtain ω_i1 and ψ₃.

Linear Program 4 (LP4).

For an SF³–CT, if the tool is operated by THTS under the steady state, a linear program is established to obtain a schedule as follows.

Minimize ψ₄

Subject to: (1), (2),

(34)–(49), (58)–(60),

(29) where i ∈ N_n\N₂ and n > 2,

(30) where i ∈ N_n\N₁ and n > 2, and

(31) in which n > 2.

Similar to the linear programs above, Constraints (1) and (2) guarantee that the RTCs are satisfied. Constraints (34)–(38) calculate the time required to complete four wafers at each step from Steps 1 to n. Then, Constraints (39)–(44) calculate the time for robot-waiting activities A_i2 at each step. Constraints (29)–(31) and (45)–(48) determine the sojourn time of W_i,12 and W_i,34. Equation (49) calculates the robot cycle time under THTS. Constraints (58)–(60) come from Proposition 4, and we can obtain ω_i1 and ψ₄.

For scheduling problems, to satisfy practical application requirements, computational efficiency is a very important issue. By the above-proposed methods, a schedule is obtained by a linear program if it exists. It is well-known that a linear program can be solved in polynomial time, implying that the proposed method is efficient and scalable.

This Section analyzes the temporal properties of the four scheduling strategies (OBS, OHTS, TBS, and THTS) in multi-space process modules with RTCs. It presents the mathematical models and equations for calculating the cycle time and robot task sequences for each strategy. The analysis focuses on optimizing robot-waiting time and task scheduling to achieve minimal cycle time while meeting the RTCs. Linear programming models are developed to determine feasible and optimal schedules for maximizing the throughput. It should be noted that, with LPs 1–4, by applying different strategies, the obtained results may be different due to different parameter combinations. Thus, given a group of parameters, we need to apply LPs 1–4 and select the best schedule.

4. Experiments

Although the addressed tool is equipped with a dual-arm robot, it can be used as just a single-arm one in some cases due to the fact that the arms should be identified as dirty and clean ones. Thus, we have to present and analyze different scheduling strategies, and the performance of these strategies may be different for different parameter combinations. Essentially, given a parameter combination, we need to use all the four linear programs for a solution, then choose the best one. Nevertheless, it is better to test the strategies to see the differences in these strategies under different parameter combinations. In this way, we can provide a guide to the practitioners. To do so, based on the data from real production processes, for each test case, we randomly generate one of the parameters and keep others constant. In the following, we present parts of the experimental results to show the properties of these strategies.

We use large amounts of data collected from a fab for experiments to test the proposed method. According to the actual production situations, the processing time of wafers in different process steps is different, and the constraints on the RTC in PM are also different. At the same time, we also consider the different rotation times in PM. With these experiments, we compare the performance of the four scheduling strategies under different parameters. The time unit is seconds and omitted in the following presentation. The algorithm is implemented using a Gurobi Python interface (gurobipy) on a personal computer equipped with Intel Core i3-10100 CPUs running at 3.60 GHz and 16.0 of RAM. To test LPs 1–4 resulting from the four scheduling strategies, a large number of experiments with different parameters are made and the results are presented as follows:

Example 1.

The wafer flow pattern of this example is (1, 1, 1). Steps 1–3 are served by PM₁, PM₂, and PM₃, respectively. There are three cases.

Case 1: The wafer processing time α₁ for Step 1 is randomly generated in [50.0, 100.0], α₂ = 60.0, and α₃ = 80.0; for RTCs, δ₁ = 30.0, δ₂ = 40.0, and δ₃ = 28.0; and the robot task time is β = 1.0, β₀ = 2.0, and μ = 1.0. The PM rotation time is υ = 2.0. Case 1 involves variations in α₁ while keeping all other parameters constant. The results are shown in Figure 7.

Case 2: The wafer-processing time is α₁ = 124.0; α₂ is randomly generated in [90.0, 140.0] and α₃ = 120.0; for RTCs, δ₁ = 48.0, δ₂ = 45.0, and δ₃ = 46.0; the robot task times are β = 2.0, β₀ = 4.0, and μ = 2.0. The PM rotation time is υ = 6.0. Case 2 involves variations in α₂ while keeping all other parameters constant. The results are shown in Figure 8.

Case 3: The wafer-processing times are α₁ = 131.0, α₂ = 135.0, and α₃ is randomly generated in [100.0, 160.0]; for RTCs, δ₁ = 45.0, δ₂ = 32.0, and δ₃ = 46.0; the robot task times are β = 1.0, β₀ = 2.0, and μ = 2.0; and the PM rotation time is υ = 2.0. Case 3 involves variations in α₃ while keeping all other parameters constant. The results are shown in Figure 9.

We test LPs 1–4 and calculate the parameter variation range within which feasible schedules can be found as shown in Figure 7, Figure 8 and Figure 9 and

Table 1. Industrial examples.

Examples			Case 1	Case 2	Case 3
Example 1 WFP = (1, 1, 1)	Parameters		α1 = [50.0, 100.0], α2 = 60.0, α3 = 80.0; δ1 = 30.0, δ2 = 40.0, δ3 = 28.0; β = 1.0, β0 = 2.0, μ = 1.0, υ = 2.0.	α1 = 124.0, α2 = [90.0, 140.0], α3 = 120.0; δ1 = 48.0, δ2 = 45.0, δ3 = 46.0; β = 2.0, β0 = 4.0, μ = 2.0, υ = 6.0.	α1 = 131.0, α2 = 135.0, α3 = [100.0, 160.0]; δ1 = 45.0, δ2 = 32.0, δ3 = 46.0; β = 1.0, β0 = 2.0, μ = 2.0, υ = 2.0.
	Cycle time	OBS	ψ1 = [97.0, 119.0]	ψ1 = [164.0, 176.0]	ψ1 = [159.0, 184.0]
		OHTS	ψ2 = [97.0, 114.0]	ψ2 = [156.0, 178.0]	ψ2 = [173.0, 180.0]
		TBS	ψ3 = [106.0, 107.0]	ψ3 = 180.0	ψ3 = [172.0, 177.0]
		THTS	ψ4 = [106.0, 112.0]	ψ4 = [174.0, 178.0]	ψ4 = [179.0, 180.0]
	Schedulable range	OBS	α1 = [50.0, 100.0]	α2 = [90.0, 140.0]	α3 = [100.0, 160.0]
		OHTS	α1 = [64.0, 100.0]	α2 = [90.0, 122.0]	α3 = [100.0, 156.0]
		TBS	α1 = [68.0, 80.0]	α2 = [121.0, 126.0]	α3 = [116.0, 140.0]
		THTS	α1 = [73.0, 90.0]	α2 = [105.0, 114.0]	α3 = [123.0, 143.0]
Example 2 WFP = (2, 1, 1)	Parameters		α1 = 300.0, α2 = 120.0, α3 = 130.0; δ1 = [30.0, 60.0], δ2 = 45.0, δ3 = 40.0; β = 1.0, β0 = 2.0, μ = 1.0, υ = 14.0.	α1 = 300.0, α2 = 120.0, α3 = 130.0; δ1 = [30.0, 60.0], δ2 = 45.0, δ3 = 40.0; β = 1.0, β0 = 2.0, μ = 1.0, υ = 4.0.	α1 = 310.0, α2 = 130.0, α3 = 140.0; δ1 = 42.0, δ2 = 45.0, δ3 = 42.0; β = 1.0, β0 = 2.0, μ = 1.0, υ = [2.0, 14.0].
	Schedulable conditions	OBS	δ1 = 39.0	δ1 = 9.0	Cycle time	OBS	ψ1 = [164.5, 191.0]
		OHTS	δ1 = 59.0	δ1 = 13.0		OHTS	ψ2 = [162.0, 176.0]
		TBS	δ1 = 36.0	δ1 = 21.0		TBS	ψ3 = [168.5, 173.0]
		THTS	δ1 = 51.0	δ1 = 21.0		THTS	ψ4 = [166.0, 177.0]
	Cycle time	OBS	ψ1 = 181.0	ψ1 = 161.0	Schedulable range	OBS	υ = [2.0, 14.0]
		OHTS	ψ2 = 181.0	ψ2 = 158.0		OHTS	υ = [2.0, 9.0]
		TBS	ψ3 = 172.0	ψ3 = 164.5		TBS	υ = [2.0, 13.0]
		THTS	ψ4 = 177.0	ψ4 = 162		THTS	υ = [2.0, 9.0]

. As can be seen from Figure 7, Figure 8 and Figure 9 and Table 1, OBS can find schedules for the largest parameter variation range. As shown in Figure 7 and Figure 9, when processing time for Steps 1 and 3 is short, OBS can find feasible schedules. Then, as the processing time increases, OHTS can also find feasible schedules. As shown in Figure 8, OHTS can find a feasible schedule when processing time for Step 2 is short. At the same time, the cycle time is the shortest. As the processing time increases, OBS achieves a shorter cycle time. In the given range of the parameter variation, the feasible ranges of TBS and THTS are smaller, and the cycle time is longer. In these cases, OBS and OHTS are obviously better.

Example 2.

The wafer flow pattern of this example is (2, 1, 1). PM₁ and PM₂ serve for Step 1, and PM₃ and PM₄ serve for Steps 2 and 3, respectively. There are three cases.

Case 1: The wafer-processing times are α₁ = 300.0, α₂ = 120.0, and α₃ = 130.0; for RTCs, δ₁ is generated randomly in [30.0, 60.0], δ₂ = 45.0, and δ₃ = 40.0; the robot task times are β = 1.0, β₀ = 2.0, and μ = 1.0; and the PM rotation time is υ = 14.0.

Case 2: Compared to Case 1, υ is reduced from 14 to 4, δ₁ is generated randomly in [30.0, 60.0], with other parameters unchanged. By applying LPs 1–4, when υ = 14.0, and δ₁ = 39.0, 59.0, 36.0, 51.0, OBS, OHTS, TBS, and THTS find feasible schedules with the system cycle time ψ₁ = 181.0, ψ₂ = 181.0, ψ₃ = 172.0, ψ₄ = 177.0, respectively. As δ₁ increases, TBS finds a feasible schedule first, while OHTS finds a feasible schedule at the latest time. As for cycle time, TBS shows a shorter cycle time, followed by THTS. When υ = 4.0 and δ₁ = 9.0, 13.0, 21.0, 21.0, OBS, OHTS, TBS, and THTS find feasible schedules with the system cycle time ψ₁ = 161.0, ψ₂ = 158.0, ψ₃ = 164.5, and ψ₄ = 162.0, respectively. This exhibits that when the internal chamber of the PM rotation time is shorter, OBS performs better for a strict RTC, while OHTS has a shorter cycle, but a looser RTC.

Case 3: The wafer-processing times are α₁ = 310.0, α₂ = 130.0, and α₃ = 140.0; for RTCs, δ₁ = 42.0, δ₂ = 45.0, and δ₃ = 42.0; the robot task times are β = 1.0, β₀ = 2.0, and μ = 1.0; and the PM rotation time υ falls into [2.0, 14.0].

By applying LPs 1–4, when the internal chamber of the PM rotation time is shorter, from Figure 10 and Table 1, we can find that OHTS performs better. With the increase in the internal chamber rotation time of a PM, TBS presents a shorter cycle time. Within the variation range of υ, OBS has the widest scheduling range.

5. Discussion

In the experiments, we test four scheduling strategies (LPs 1–4) and identify the parameter variation ranges within which feasible schedules can be found as shown in Figure 7, Figure 8 and Figure 9 and Table 1. The experimental results demonstrate that each strategy has its strengths under specific parameter conditions. Based on the parameter variation ranges, we can recommend the best scheduling strategy for different scenarios.

OBS Strategy: As shown in Figure 7 and Figure 9, when the processing time for Steps 1 and 3 is short, OBS can find feasible schedules. We can see in Figure 9 that when α₃ is in the range of [110, 140], OBS still achieves the shortest cycle time and the largest schedulable range. In Figure 2, we can see that when all four scheduling strategies are feasible, with α₁ = 80 and ψ₁ = 97, we have that ψ₁ is 2.02% shorter than the second smallest ψ₂ (99). Within the parameter variation range, OBS covers the widest scheduling range, indicating that OBS is the best choice in cases where task complexity is low and processing time is short. Additionally, as processing time increases, OBS still achieves a relatively short cycle time. Overall, OBS is very effective in scenarios with a shorter wafer-processing time, especially when resource constraints are minimal.

OHTS Strategy: OHTS performs well in certain cases, particularly as task complexity increases. As seen in Figure 7 and Figure 9, as processing time increases, OHTS can also find feasible schedules. When the processing time for Step 2 is short, OHTS achieves feasible schedules with the shortest cycle time (Figure 9). Therefore, OHTS is the preferred strategy when the task-processing time is longer and higher resource utilization is required.

TBS and THTS Strategies: As shown in Figure 10 and Table 1, the feasible scheduling ranges for TBS and THTS are relatively smaller, and the cycle time achieved is longer. As a result, OBS and OHTS are generally better in most cases. However, when the internal chamber rotation time of the PM increases, TBS achieves a shorter cycle time. Therefore, TBS is better in scenarios where the internal rotation time of the PM is long, while OHTS performs better when the rotation time is shorter.

From the above analysis, it is not difficult to see that the four scheduling strategies proposed in this paper also have certain limitations. When the RTC is too short, all four scheduling strategies become very difficult to find a feasible schedule due to the tool property of multi-space PMs. Similarly, when considering the RTC, if the robot’s loading/unloading or movement time is too long, none of the four scheduling methods can be applied. The experimental results can provide a guide for the practitioners. Especially, when a feasible schedule cannot be found by applying all the strategies, an engineer can think about how to redesign the process such that the fabrication of a type of wafers can be completed.

It also needs to be pointed out that this study is conducted based on the specific application of wafer fabrication for the addressed cluster tools. This may be the limitation of the proposed method. Nevertheless, the idea may be useful for scheduling other cluster tools and for other similar scheduling problems.

6. Conclusions

In this paper, we examine the scheduling problem of a four-finger four-space-PM cluster tool (SF³–CT), a typical type of cluster tool with multi-space PM and a multi-finger-arm robot adopted in modern fabs. With the configuration properties, we find that both the robot task sequences and the rotation operations of the internal chambers of PMs affect the wafer stay time in PMs. Due to the increased time within PMs by dealing with multiple spaces in a PM, fulfilling the residency time constraints becomes more challenging. Consequently, finding an optimal and feasible schedule for such tools is a significant issue. To solve this problem, four robot task sequences (OBS, OHTS, TBS, and THTS) as scheduling strategies are presented, and based on them, we establish four linear programs to find optimal and feasible schedules to minimize the cycle time. Since a linear program can be solved in polynomial time, the proposed method is computationally efficient. Also, based on the property of the method, a feasible and optimal schedule can be found if it exists. Finally, experiments are conducted with different cases to test the four strategies. It shows that for different parameter combinations, different strategies achieve different performance. Thus, given a group of parameters, one should apply all the strategies and then choose the best schedule obtained by one of the strategies.

With continuous experimentation, we have discovered that the delay time at each step is quite long. Our future endeavors will concentrate on minimizing delay time in the scheduling problem of an SF³–CT, while making efforts to reduce cycle time and enhance production efficiency.

In this paper, we focus on the scheduling strategies and solutions for finding feasible and optimal schedules for the addressed system. To do so, we assume that the activity time is known. However, in practice, uncertainty exists regarding the activity time, and this imposes another challenge for scheduling the addressed system. Today, a digital twin is a widely used technology for various application problems [33,34,35,36,37]. In our future work, based on the presented strategies, digital twin technology will be applied to extend the proposed method for the scheduling problem of the addressed cluster tools with activity-time uncertainty.

Currently, high-throughput screening systems are widely used for new chemical substance discovery, and their scheduling problem is also very challenging due to the residency time constraints similar to the wafer residency time constraints here [38,39,40]. We will examine the possibility of extending the proposed methods to study the scheduling problem of high-throughput screening systems.