Periodic Scheduling Optimization for Dual-Arm Cluster Tools with Arm Task and Residency Time Constraints via Petri Net Model

Abstract

In order to improve quality assurance in wafer manufacturing, there are strict process requirements. Besides the well-known residency time constraints (RTCs), a dual-arm cluster tool also requires each robot arm to execute a specific set of tasks. We call such a tool an arm task-constrained dual-arm cluster tool (ATC-DACT). To do this, one of the arms is identified as the dirty one and the other as the clean one. The dirty one can deal with raw wafers, while the clean one can deal with processed wafers. This requirement raises a new problem for scheduling a cluster tool. This paper discusses the scheduling problem of ATC-DACTs with RTCs. Due to the arm task constraints, the proven, effective swap strategy is no longer applicable to ATC-DACTs, making the scheduling problem difficult. To address this problem, we explicitly describe the robot waiting as an event and build a Petri net (PN) model. Then, we propose a hybrid task sequence (HTS) as an operation strategy by combining the swap and backward strategies. Based on the HTS, the necessary and sufficient conditions for schedulability are established; also, a linear programming model is developed. We then develop an algorithm using these results to optimally schedule the system. Industrial case studies demonstrate the application of this method.

1. Introduction

As a kind of complex wafer fabrication system that integrates various fabrication processes and robot operations in semiconductor manufacturing, cluster tools are crucial. Optimizing the operation of cluster tools is essential for enhancing the overall performance and efficiency of semiconductor production lines [1,2]. As shown in Figure 1, cluster tools comprise several process modules (PMs), a single-arm or dual-arm robot, and two loadlocks (LLs) for cassette loading and unloading. Single-wafer processing technology is employed in PMs, allowing each PM to process only one wafer at a time. Typically, 25 wafers with the same recipe are held in a cassette [3]. The robot follows a predetermined recipe to deliver wafers from a cassette to PMs for processing. Once all the operations are finished, a wafer is returned to its original position in the cassette.

In this article, the addressed cluster tool is equipped with a dual-arm robot; thus, it is named a dual-arm cluster tool. The two arms are closely coupled in its structure, allowing only one arm to load or unload a wafer into or from a PM at a time. Therefore, when one arm performs an unloading or loading task at a PM or LL, the arm should enter the PM or LL to pick up or place a wafer. Additionally, with several LLs, it ensures that raw wafers can enter the tool for processing in time. Thus, LLs are not the bottleneck in terms of a tool’s throughput.

Preventing wafer contamination is crucial for wafer quality and production efficiency, and it is the key factor in ensuring high-quality and sustainable manufacturing. For this purpose, one of the requirements is to impose strict wafer residency time constraints (RTCs) on the tool operation [4,5]. With RTCs, once a wafer is processed in a PM, it needs to be taken out from the PM within a limited time; if not, the chemical gas and high temperature would contaminate or damage the wafer. Notice that there may be dust on raw wafers, which are called dirty wafers in semiconductor fabs. After a dirty wafer visits a processing step, it is cleaned such that a processed wafer is called a clean wafer. Thus, if once a robot arm grasps a raw wafer, the arm may be contaminated. Then, if this arm is used to deliver a processed wafer, it may contaminate it. Thus, in wafer fabrication practice, an arm task constraint (ATC) is imposed to further ensure the wafer fabrication quality to avoid the mutual contamination of wafers via robot arms. Such a constraint is typically employed for chemical vapor deposition processes. By this constraint, the robot arms are classified into two types: dirty and clean ones. The dirty arm can perform tasks for grasping raw wafers (dirty wafers) only, while the clean arm should be dedicated to grasping processed wafers (clean wafers). As shown in Figure 1, we use F₁ and F₂ to denote the dirty and clean arms, respectively. Thereafter, we call this cluster tool an arm task-constrained dual-arm cluster tool (ATC-DACT in short).

The structure of this article is outlined below. After the related work is reviewed in the subsequent section, Section 3 then presents the scheduling strategy and develops the colored PN model for the system of an ATC-DACT under the scheduling strategy. In Section 4, we analyze the temporal properties and analytically derive the necessary and sufficient conditions for obtaining a feasible schedule. With these conditions, we propose an integrated scheduling algorithm that combines linear programming to achieve an optimal cycle time. In Section 5, the practical applicability of the proposed method is demonstrated through experiments. This demonstrates how the proposed method can be effectively applied and validated. Finally, Section 6 summarizes the findings and identifies further avenues for research directions, to address the remaining problems.

2. Literature Review

In recent years, great attention has been paid to the scheduling of dual-arm cluster tools in semiconductor manufacturing [4,6,7,8,9,10,11,12,13]. However, to the best of the authors’ knowledge, all of them are conducted under the assumption that both robot arms can perform any robot task, which is different from the problem addressed in this paper. As a result, the findings from these studies cannot be applied to the case here. Thus, we conduct this study on scheduling an ATC-DACT to respond to the demand of practical applications.

To increase productivity and ensure product consistency and production stability, a cluster tool typically operates under a steady state for most of the time. If the robot remains constantly busy and its task time dominates the cycle time, under such a state, the tool is said to be transport-bound. Conversely, under most real production environments, wafer processing in a PM takes significantly more time than robot tasks, making a tool be process-bound. For process-bound situations, productivity can be maximized if a backward strategy is employed for single-arm cluster tools [14,15] and a swap strategy is applied for dual-arm cluster tools [16]. These research results are obtained for tools without RTCs being imposed. Although an ATC-DACT is a dual-arm cluster tool, a traditional swap strategy cannot be used, since the strategy cannot be performed for some of the steps. For these steps, the tool can just act as a single-arm one. Thus, for ATC-DACTs, the scheduling strategy should be a hybrid one by combining the backward and swap strategies. With this observation, we study the scheduling problem of ATC-DACTs.

With RTCs, the authors in [4,7,17] propose several methods to devise feasible and optimal periodic schedules for cluster tools equipped with a dual-arm robot. Moreover, Wu et al. [3,8] develop a type of method from the control theory perspective for scheduling cluster tools for robots with either single or dual arms, aiming at the effective optimization and viability of schedules. Lim et al. [18] address the challenge of unbalanced processing parameters among the steps to enhance the effectiveness in meeting RTCs by introducing a novel category of robot task sequences. Ko et al. [9] address the concurrent handling of multiple wafer types by proposing a method for cluster tools with a dual-arm robot. Their method focuses on meeting RTCs and achieving the shortest cycle time by determining the optimal release sequence for different wafer types. Lim et al. [19] propose a flexible method to improve the stability of schedules for cluster tools with RTCs and processing time variations. The management of robot waiting time has been identified as a critical factor in scheduling single- and dual-arm cluster tools, while adhering to RTCs. Consequently, researchers have introduced a method referred to as the robot waiting time method, which is discussed in [11,15]. By utilizing this method, cluster tools with both RTCs and activity time variations can be effectively scheduled [1,19,20,21,22,23,24]. The above discussion is summarized in

Table 1. System characteristics and scheduling methods of cluster tools.

Scheduling Problem	Related Work	Arm Task Constraint	Scheduling Method	Scheduling Objective
Residency time constraint	[3]	No	Robot waiting time allocation	Optimal 1—wafer cycle
	[5]	No	Transition trigger sequence	Schedulability analysis
	[13]	No	A polynomial complexity algorithm	Optimal cyclic schedule
	[18]	No	A new class of sequences without interferences	Optimal cyclic schedule
Both RTCs and variations	[1]	No	A novel algorithm	Optimal cyclic schedule
	[19]	No	Adaptive scheduling	Optimal cyclic schedule
	[20]	No	A two-level real-time operational architecture and a real-time control policy.	Calculate the upper bound of wafer residency time delay.
	[25]	No	A systematic method of determining the schedulability of time-constrained decision-free discrete-event systems	Verify schedulability conditions and determine worst-case task delays
Wafer reentry processing	[12,22]	No	Robot waiting time allocation	Optimal cyclic schedule
Steady state	[8]	No	Robot waiting time allocation	Optimal 1—wafer cycle
Multiple wafer types	[9]	No	Transition trigger sequence	Minimize wafer delay
Cleaning plan	[10]	No	A cleaning rule named DGC (Dispersing and Gathering Cleaning)	Optimal cyclic schedule
Multiple cluster tool	[14]	No	Optimal lot-sizing and release policies	Optimal cyclic schedule
	[26]	No	Backward/swap strategy	Optimal k-wafer cycle
Non-cyclic schedule	[11]	No	A near-optimal solution of deadlock-free and non-cyclic scheduling	Optimal non-cyclic schedule
	[21]	No	A p ± time–event graph	Optimal non-cyclic schedule
Periodic schedule	[4]	No	Several heuristic algorithms	Optimal cyclic schedule
	[7]	No	Transition trigger sequence	Optimal cyclic schedule
	[17]	No	Mixed-integer programming	Minimum completion time

.

It follows from the above discussion that the existing studies are conducted under the assumption that there is no restriction on performing tasks for a robot arm. Thus, the robot task sequence for an ATC-DACT differs from both the backward and swap strategies that are employed in the existing methods. Hence, properly determining the robot task sequence is of utmost importance in analyzing the addressed problem. Also, we need to identify the robot’s two arms so that the tasks can be correctly performed. Thus, the existing techniques are not applicable to the addressed problem, and this work attempts to cope with it. To accurately describe the dynamic behavior of the system, we construct a PN model. In the developed model, we associate different colors with the two arms, ensuring the correct representation of their behavior. It is worth noting that this approach differs from the model presented in [25]. This model is highly compact, easily extendable, and capable of eliminating all infeasible states independently. Consequently, we can search for an optimal schedule within a feasible space, significantly simplifying the scheduling complexity. Based on this, proper robot task sequences are proposed, and an efficient scheduling method is derived. In summary, this work makes the following contributions: (1) proposing a scheduling strategy that can be applied to ATC-DACTs; (2) with a PN model built, necessary and sufficient schedulability conditions are derived; (3) an efficient scheduling algorithm is proposed to obtain a feasible and optimal schedule; and (4) industrial examples are given to show the applications of the proposed method.

3. System Modeling

The effectiveness of PNs in modeling discrete event systems, particularly in semiconductor manufacturing, has been demonstrated in many studies [22,23,27,28]. These studies emphasize the application of PNs to accurately model and analyze the behavior of cluster tools in semiconductor manufacturing. The efficient scheduling of cluster tools with both single-arm and dual-arm robots, while considering RTCs, has been achieved by analyzing the robot waiting based on PN models [3,8]. Since an ATC-DACT can neither operate as a single-arm cluster tool nor a dual-arm one, the PN models and scheduling methods in [3,8] are not applicable. A colored Petri net (CPN) model is presented for the discussed cluster tools under a hybrid operational strategy that combines the backward and swap strategies in this work. This model accurately represents the behavior of ATC-DACTs and allows for efficient analysis and scheduling optimization.

3.1. Steady-State Process

Starting from its idle state, a cluster tool undergoes an initial transient process to be transferred into a steady state. Suppose that there are n processing steps for a specific wafer type and Step i is configured with m_i PMs. During the initial transient process, wafers are delivered to the PMs from LLs for processing. As the system evolves, when every PM is processing a wafer, i.e., there are ${\sum }_{i=1}^n{m}_i$ wafers being processed, the system enters a steady state and operates periodically. When a cluster tool is to be terminated, the ${\sum }_{i=1}^n{m}_i$ wafers in the system are completed one by one and returned to LLs without delivering raw wafers to the system. After completing them, the tool returns to the idle state. The primary focus of this research is the analysis of scheduling for the steady-state process in question.

There are extensive research reports that focus on modeling and evaluating the performance of scheduling cluster tools under a steady state [8,26,29]. According to Shin et al. [30], robot tasks are subsequently followed by process activities. Therefore, scheduling robot tasks is crucial for cluster tools. It is recognized that each robot task takes a constant time that is significantly shorter than that for wafer processing in PMs [7].

In wafer fabrication, wafers within a cassette are processed following a sequence of process steps guided by a recipe. Also, it is possible to configure a specific number of PMs for each step to achieve a proper workload distribution among the n steps [11], which is represented by the wafer flow pattern (m₁, m₂, m₃, …, m_n), where m_i indicates the number of PMs for Step i. Throughout this entire article, we discuss the scenarios where n ≥ 2. At the beginning, raw wafers are retrieved from an LL, while completed wafers are returned to the LL. Upon unloading the last wafer from the LL, the ATC-DACT processes wafers from cassettes in the other LLs. The tool continuously repeats a stable cycle through this pipeline-style processing until it has completed the processing of all the wafers that are required.

3.2. Finite Capacity PN

Scheduling an ATC-DACT involves dynamically assigning finite resources to its activities. Given that modeling resource allocation can be effectively achieved using a finite capacity PN, we propose a PN model for the ATC-DACT utilizing the concept of a finite capacity PN. This study derives the PN concept from the work introduced in [31,32]. A finite capacity PN refers to a specific type of directed graph that consists of transitions and places. Let N = {0, 1, 2, …} and N_n = {1, 2, 3, …, n}. Denote PN = (P, T, I, O, M, K), where (1) the finite set of places is denoted as P = {p₁, p₂, …, p_m}; (2) the finite set of transitions is denoted as T = {t₁, t₂, …, t_n}, satisfying P ∩ T = ∅ and P ∪ T ≠ ∅; (3) the input function is denoted as I: P × T → N; (4) the output function is denoted as O: P × T → N; (5) M: P → N is a marking that counts the tokens in places, and the initial marking is given as M₀; and (6) K: P → N_n is a capacity function, and K(p) gives p’s capacity.

The set of all input places to transition t is referred to as its preset, denoted as ^λt = {p: p ∈ P and I (p, t) > 0}; and the set of all output places from t is known as its postset, denoted as t^λ = {p: p ∈ P and O(p, t) > 0}. Likewise, the preset of p is expressed as ^λp = {t ∈ T: O(p, t) > 0}, and its postset is expressed as p^λ = {t ∈ T: I(p, t) > 0}.

Definition 1. 

For a transition t ∈ T in a finite capacity PN, it is considered enabled if both Conditions (1) and (2) are satisfied for ∀p ∈ P.

M(p) ≥ I(p, t)

(1)

and

K(p) ≥ M(p) − I(p, t) + O(p, t)

(2)

A transition is firable when it is enabled. The firing of a firable transition t results in a making evolution at marking M according to (3).

M(p) = M(p) − I(p, t) + O(p, t)

(3)

As for Definition 1, for a transition t to be firable, it requires that any place in ^λt should have adequate tokens, while any place in t^λ should have sufficient free space. Accordingly, t is referred to as process-enabled when Condition (1) is satisfied, while it is referred to as resource-enabled when Condition (2) is satisfied. Hence, it should be both process- and resource-enabled when t is enabled. A series of transition firings leads to a series of markings. A transition in a PN is considered live if it can fire at least once again in some firing sequence for every marking M reachable from M₀. We say that M is reachable from M₀ if there exists a series of transition firings that transform M₀ into M. Let R(M₀) denote the set comprising all markings that can be reached from M₀. A PN is deemed live when every t ∈ T is live. The property of liveness in a PN ensures the occurrence of all events and activities represented in the model.

3.3. PN Modeling for ATC-DACT

We number the processing steps as Steps 1 to n. To ensure brevity in the presentation, we assume that both Steps 0 and n + 1 are for LLs that are treated as resources for this processing step. As a result, with n steps, the system comprises a total of n + 1 steps. The m_i PMs configured for Step i, i ∈ N_n, are modeled by a timed place p_i with K(p_i) = m_i; while LLs (Steps 0 and n + 1) can be modeled by p₀ with K (p₀) = ∞, implying that they can store all the raw and completed wafers. In the model, we describe the robot using place r; we have K(r) = 2, indicating its capacity for holding two wafers simultaneously. Different colors are used to identify the two arms modeled by the two tokens. Then, we present how to model each processing step. For Step 1, a swap operation can be applied, and each robot arm can hold a wafer, allowing the robot to accommodate a total of two wafers. To schedule a cluster tool, at Step 1, the robot may wait before, after, or during swapping. Thus, for Step 1, besides p₁, we add timed places q₁₂ and q₁₃ with K(q₁₂) = K(q₁₃) = 1, meaning that the robot waits during a swap operation while holding a wafer. For Step i, i ∈ N_n, the presence of place q_i with K(q_i) = 1 represents the robot’s waiting before unloading a completed wafer from p_i. For cases with n > 2, from Steps 2 to n, only arm F₂ is allowed to be used and the robot acts as a single-arm one; thus, it follows the backward strategy. Hence, to operate an ATC-DACT, the robot follows a hybrid task strategy (HTS), i.e., a swap operation is adopted at both Steps 1 and 0, or Step 1 only, while a backward operation is employed in the subsequent steps.

Based on the HTS, the PN model that describes the dynamical behavior of an ATC-DACT is illustrated in Figure 2, where, pictorially, circles () represent places, bold black bars () represent transitions, and black and gray dots (● and ●) are used to denote the tokens for F₂ and F₁, respectively. Connections between transitions and places are depicted using directed arcs.

When n = 2, we can derive the PN depicted in Figure 3. In this case, the robot executes swap operations at Steps 1 and 0. Additionally, F₁ and F₂ can be utilized at LLs (Step 0).

After being released into the system via LLs, wafers proceed to the PMs following a predetermined order. The robot is responsible for wafer transportation, thereby engaging in various tasks, including unloading a wafer from a PM/LL and loading a wafer into a PM/LL, moving between PMs/LLs, and performing swaps. Each task consumes time and is captured and represented using timed transitions within the PN model. According to Figure 2, the transitions denoted as x_i in the model represent the robot’s movements between PMs/LLs while carrying a wafer. Transitions s₁₁ and s₁₂ represent the swapping process at p₁, symbolizing the unloading and loading of a wafer from and into p₁, respectively. The robot loading/unloading a wafer into/from Step i is denoted by transition s_i1 and s_i2, i ∈ N_n\N₁. To model the robot tasks associated with unloading a wafer from an LL, aligning it, and loading a wafer into an LL, the timed transitions s₀₁ and s₀₂ are employed. When n > 2, according to Figure 2, timed transition y_i represents the robot’s movement from Steps i + 2 to i. Similarly, y_i−1 represents the robot’s movement from Step 0 to n − 1, y₀ depicts the robot’s movement from Step 3 to 0, and y_n depicts the robot’s movement from Step 2 to n. When n = 2 in Figure 3, timed transition y₂ is used for the robot waiting at Step 2. For the nontimed places, transitions x_i−1 and s_i1 are connected by place z_i1, transitions s_i2 and x_i, are connected by z_i2, the connection between s₀₂ and x₀ is facilitated by z₀₂, and the connection between s₀₁ and x_n is facilitated by z₀₁.

Due to that, dirty and clean arms should be distinguished. The model is enhanced by incorporating colors into the PN model to address this issue. We use f₁ and f₂ to denote the two tokens for F₁ and F₂ in place r, and they have colors c₁ and c₂, respectively. Only the token with color c₁ can enable transitions s₀₂ and s₁₁, and tokens with color c₂ trigger all other transitions. Then, to determine which transition should be triggered at a given moment, the colors for transitions should be defined.

Definition 2. 

In the developed model, the color of s₀₂ and s₁₁ is defined as C(s₀₂) = C(s₁₁) = c₁; and the color of s_ij is defined as C(s_ij) = c₂, {(i, j)|i ∈ N_n, j ∈ {1, 2}}\{(0,2), (1,1)}. In this way, if q ∈ ^λs_ij and a token in q enables s_ij, then this token has the same color c₁ as that of s₀₂ or s₁₁, and color c₂ is same as the color of s_ij, {(i, j)|i ∈ N_n, j ∈ {1, 2}}\{(0,2), (1,1)}.

Notice that, according to Definition 2, if a token has color c₁, it indicates that f₁ enables s₀₂ or s₁₁, and when a token has color c₂, f₂ enables s_ij, {(i, j)|i ∈ N_n, j ∈ {1, 2}}\{(0,2), (1,1)}. The token f₁ in z₀₂ implies that it enables s₀₂; then token f₁ triggers x₀; so, the color of transition x₀ is C(x₀) = c₁. All other transitions x_i are initiated by f₂; thus, the colors of transitions x_i’s are defined as C(x_i) = c₂, i ∈ N_n. Nevertheless, it should be noted that the model is only applicable for analyzing qualitative properties [33].

Theoretically, M₀ should depict the system’s startup state, i.e., an idle condition where all PMs are free. However, considering the objective of achieving an optimal steady-state cyclic scheduling, all PMs are engaged in processing at the steady state. To tackle this issue, we can think that the system is initially processing virtual wafers, denoted as W₀. M₀(p_i) represents the number of tokens in p_i, disregarding the color of the tokens at M₀. Thus, M₀ can be described as M₀(p_i) = K(p_i) and M₀(q₁₂) = M₀(q₁₃) = M₀(q_i) = 0, i ∈ N_n. During the evolution of the PN model, virtual wafers are sequentially removed, while actual wafers are loaded into the system sequentially. The system enters a steady state once all virtual wafers have been removed. By definition, M(p_i) represents the number of tokens in p_i at M, disregarding the tokens’ color; M(p₀, c₁) is the number of tokens with color c₁ in p₀ at M; M(p_i, c₂) the number of tokens with color c₂ in p_i at M; M(r) the number of tokens in r, disregarding the tokens’ color at M; M(r, c₁) the counts of tokens with color c₁ in r at M; and M(r, c₂) the counts of tokens with color c₂ in r at M. This study presents a transition control policy formulated as follows to avoid deadlock for the PN model.

Definition 3. 

At marking M, for the PN model of an ATC-DACT with n > 2, transition y_i, i ∈ N_n\N₁, is said to be control-enabled if M(p_i+1, c₂) = m_i+1 − 1; and transition y_n is said to be control-enabled if M(p_i, c₂) = m_i, i ∈ N_n; transition y₀ is said to be control-enabled if M(p_i, c₂) = m_i, i ∈ N_n\{2}, and M(p₂, c₂) = m₂ − 1.

The control policy specified in Definition 3 is presumed to govern the PN model. According to Definition 3, at marking M₀, the only enabled transition is y_n. When y_n fires, it is succeeded by s_n2, x_n, and s₀₁ to reach M₁, at which only y_n−1 is enabled. The firing of y_n−1 is succeeded by s_(n−1)2, x_n−1, and s_n1 to reach M_k, at which only y_n−k is enabled. Then, the firing of y_n−k is followed by s_(n−k)2, x_n−k, and s_(n−k+1)1, resulting in the attainment of marking M_n−2 such that only y₀ is enabled. By firing y₀ and then s₀₂, x₀, and s₁₂, the system reaches M_n, at which only y₀ is enabled, resulting in the firing of y₀, s_n2, x_n, and s₀₁. Notice that markings M₀ and M_n are identical, implying a completed cycle.

Definition 4. 

For the PN model of an ATC-DACT with n = 2, at marking M, transition s₀₂ is considered to be control-enabled if M(p₀, c₁) = K(p₀), M(r, c₁) = 1, and M(q₀, c₂) = K(q₀); s₁₂ is considered to be control-enabled if M(p₁, c₂) = K(p₁), M(r, c₂) = 1, and M(q₁, c₁) = K(q₁); and s₂₂ is considered to be control-enabled if M(p₂, c₂) = m₂, M(r, c₁) = 1, and M(q₂, c₂) = K(q₂); and s₂₁ is considered to be control-enabled if M(p₁, c₂) = m₁ and M(p₂, c₂) = m₂ − 1.

Notice that if f₁ is in r and f₂ is in q₀, transition s₀₂ is firable; if f₂ is in r and f₁ is in q₁, s₁₂ is firable; if f₁ is in r and f₂ is in q₂, s₂₂ is firable. Triggering s₂₁ results in only one token with color c₂ in z₂₁. Hence, by Definitions 3 and 4, it can be readily verified that the PN model accurately represents the behavior of the steady-state process of an ATC-DACT.

With the above modeling, we provide the model structure, the state of the system (i.e., marking), rules for transition enabling and firing, and the logic governing the behavior of the system. Meanwhile, by controlling y₀ and y_i, i ∈ N_n\N₁, as stated in Definition 3, it ensures that the PN model is deadlock-free.

While the model can guarantee the deadlock-freeness in the system, it does not necessarily imply the liveness of the PN model. This is due to time delay constraints associated with certain activities, if we treat the violation of wafer RTCs as non-liveness. In contrast, it can be easily verified that if an unrestricted token residency time is permitted for every p_i, then the PN must exhibit its liveness. In other words, it is the RTCs that make the system non-live. To describe this, let τ_i represent the sojourn time of a wafer in a PM at Step i, i ∈ N_n. To meet the RTCs, once a wafer completes its processing at a step, it is required to depart from the PM within a limited time window. Let δ_i denote such a limited time at Step i, i ∈ N_n. Further, let α_i, i ∈ N_n, represent the required processing time of a wafer in a PM at Step i. Then, d_i = τ_i − α_i presents the wafer delay time of a wafer in a PM at Step i, i ∈ N_n. The liveness property of the PN allows us to derive the following proposition.

Proposition 1. 

Given the permissive wafer sojourn time window [α_i, α_i + δ_i] for Step i, i ∈ N_n, and the PN of an ATC-DACT being determined to be live when s_i2 is enabled at any reachable marking M, we can ensure the satisfaction of Constraint (4).

α_i ≤ τ_i ≤ α_i + δ_i

(4)

Within the context of the model illustrated in Figure 2, each place or transition symbolizes a specific task that consumes time. Consequently, it is imperative to assign temporal values to these elements. The time needed to fire transition x_i is expressed by μ, that is, the time duration for the robot to rotate between PMs/LLs; β signifies the firing time of transitions s_i1 and s_i2 (where i ≠ 0), indicating the time required for the robot to execute wafer unloading/loading operations, with β₀ representing the firing time of transition s₀₂, which represents the temporal duration necessary for the robot to unload and align wafers from an LL. If the robot does not wait during a swap operation at p₁, the time for firing transitions s₁₂ and s₁₁ together forms the duration of a swap operation, calculated as λ = 2β + μ, encompassing the time of unloading, rotation, and loading operations. To optimize the schedule of an ATC-DACT, the robot may intentionally wait some time; it can wait during a swap operation and before unloading a wafer for both a swap operation and non-swap operation. Let ω_is represent the robot waiting time during a swap operation at p_i, and ω_i1 the robot waiting time before unloading a wafer at p_i; both of them are the decision variables for the scheduling problem of an ATC-DACT.

Table 2. Time durations for places and transitions.

Place/Transition	Action	Duration
s02	Robot unloads a wafer from an LL and aligns it	β0
xi	Robot rotates from pi to pi+1, i ∈ Nn−1	μ
xn	Robot rotates to an LL	μ
yi	Robot rotates from Steps i + 2 to i, i ∈ Nn\N2, n > 2	μ
y0	Robot rotates from Step 3 to 0, n > 2	μ
yn	Robot rotates from Step 1 to n, n > 2	μ
yn−1	Robot rotates from Step 0 to n − 1, n > 2	μ
y2	Robot waits at Step 2, n = 2	0
pi	A wafer being processed in pi, i ∈ Nn	αi
si1	Robot loads a wafer into a pi at Step i or an LL, i ∈ Nn	β
si2	Robot unloads a wafer from Step i, i ∈ Nn	β
s11 and s12	Simple swap operation at p1	λ = 2β + μ
s01 and s02	Simple swap operation at p0	λ0 = β + β0 + μ
q12 and q13	Robot waits during a swap at p1	ω1s ∈ [0,+∞)
q02 and q03	Robot waits during a swap at p0	ω0s ∈ [0,+∞)
qi	Robot waits before unloading at pi, i ∈ Nn	ωi1 ∈ [0,+∞)

provides the definitions of places and transitions in the PN model and the corresponding time requirements.

Based on the established PN model and analysis, this work regards scheduling an ATC-DACT as a control strategy to investigate the schedulability of the system and obtain an effective scheduling method.

4. Schedulability Analysis and Scheduling Method

4.1. Temporal Properties

Due to the adoption of the swap operation at Step 1 and/or Step 0 and the employment of the backward operation in the subsequent steps of the task sequence, the number of steps involved affects how to schedule the system. Thus, we investigate the scheduling problem with two cases of n = 2 and n > 2, respectively.

For the first case with n = 2, let θ₁ represent the time taken for Step 1 to complete a wafer. At Step 1, the robot acts as a dual-arm system and uses both F₁ and F₂ to perform a swap operation. Under the steady state with the robot waiting time ω_1s during a swap operation, to complete a wafer, task sequence σ₁ = 〈firing s₁₁ and s₁₂ (λ + ω_1s) → wafer processing (α₁)〉 is performed. Hence, with m₁ PMs for Step 1, the time required for the completion of a wafer can be calculated using Equation (5).

θ₁ = (α₁ + δ₁ + λ + ω_1s)/m₁ = (α₁ + δ₁ + 2β + μ + ω_1s)/m₁

(5)

Let θ₂ be the required time for the completion of a wafer at Step 2. With Steps 1 and 2 being examined together, the robot acts as neither a single-arm nor a dual-arm one, since the robot performs a backward operation at Step 2 using F₂ only, while it performs a swap operation at both Steps 0 and 1 using both F₁ and F₂. The time for swapping at Step 0 is λ₀ = β + μ + β₀. Under the steady state, with the consideration of robot waiting, task sequence σ₂ = 〈firing s₂₂ (β) → firing x₂ (μ) → robot waiting in q₀ (ω₀₁) → firing s₀₂ and s₀₁ (λ₀ + ω_0s) → firing x₀ (μ) → robot waiting in q₁ (ω₁₁) → firing s₁₁ and s₁₂ (λ + ω_1s) → firing x₁ (μ) → firing s₂₁ (β) → wafer processing (α₂) → the wafer remains in the PM after processed (i.e., the delay time) (d₂)〉 is performed for the completion of a wafer at Step 2. Thus, with m₂ PMs for Step 2, θ₂ can be calculated using Equation (6).

$${\theta }_2=({\alpha }_2+d_2+2\beta +3\mu +{\lambda }_0+\lambda +{\sum }_{i=0}^1{\omega }_{is}+{\sum }_{i=0}^1{\omega }_{i1})/m_2=({\alpha }_2+d_2+5\beta +{\beta }_0+5\mu +{\sum }_{i=0}^1{\omega }_{is}+{\sum }_{i=0}^1{\omega }_{i1})/m_2$$

(6)

Under steady state, with the robot waiting activities being considered, the sequence of robot tasks within a cycle can be rewritten as σ₂ = 〈firing s₂₂ (β) → firing x₂ (μ) → robot waiting in q₀ (ω₀₁) → firing s₀₂ and s₀₁ (λ₀ + ω_0s) → firing x₀ (μ) → robot waiting in q₁ (ω₁₁) → firing s₁₁ and s₁₂ (λ + ω_1s) → firing x₁ (μ) → firing s₂₁ (β) → robot waiting in q₂ (ω₂₁)〉. We use ψ to denote the robot cycle time, and we can obtain

$$\psi =2\beta +3\mu +{\lambda }_0+\lambda +{\sum }_{i=0}^1{\omega }_{is}+{\sum }_{i=0}^2{\omega }_{i1}=5\beta +{\beta }_0+5\mu +{\sum }_{i=0}^1{\omega }_{is}+{\sum }_{i=0}^2{\omega }_{i1}$$

(7)

where ψ = ψ₁ + ψ₂, with ψ₁ = 5β + β₀ + 5μ being the robot task time and ψ₂ = ${\sum }_{i=0}^1{\omega }_{is}$ + ${\sum }_{i=0}^2{\omega }_{i1}$ being the robot waiting time.

The key to determining the feasibility of a solution lies in whether Constraint (4) can be met or not for each Step i, i ∈ N_n. To do so, an analysis of the wafer sojourn time in each PM is essential. The robot completes a wafer by performing the operations in σ₁ or σ₂. Therefore, the wafer sojourn time in p₁ and p₂ can be obtained by Equations (8) and (9), respectively.

τ₁ = m₁ × ψ − (2β + μ + ω_1s)

(8)

$${\tau }_2=m_2\times \psi -(5\beta +{\beta }_0+5\mu +{\sum }_{i=0}^1{\omega }_{is}+{\sum }_{i=0}^1{\omega }_{i1})$$

(9)

For the case with n > 2, the robot executes a swap operation at Steps 1 and 0 with both F₁ and F₂, respectively. From Steps 2 to n, F₂ performs the backward operation. Under the steady state, with the robot waiting activities being considered, the task sequence is the same as σ₁. With m₁ PMs for Step 1, according to σ₁, θ₁ can be calculated according to Equation (5).

From Steps 2 to n, F₂ performs the backward operation. Under the steady state, taking into account the robot waiting activities, task sequence σ₃ = 〈firing s₂₂ (β) → firing x₂ (μ) → firing s₃₁ (β) → firing y₀ (μ) → robot waiting in q₀ (ω₀₁) → firing s₀₂ (β₀) → firing x₀ (μ) → robot waiting in q₁ (ω₁₁) → firing s₁₁ and s₁₂ (λ + ω_1s) → firing x₁ (μ) → firing s₂₁ (β) → wafer processing (α₂) → the wafer remains in the PM after processed (i.e., the delay time) (d₂)〉 is performed for the completion of a wafer. With m₂ PMs for Step 2, according to σ₃, θ₂ is given by Equation (10).

$${\theta }_2=({\alpha }_2+d_2+3\beta +{\beta }_0+4\mu +\lambda +{\sum }_{i=0}^1{\omega }_{i1}+{\omega }_{1s})/m_2=({\alpha }_2+d_2+5\beta +{\beta }_0+5\mu +{\sum }_{i=0}^1{\omega }_{i1}+{\omega }_{1s})/m_2$$

(10)

Let θ_i be the completion time of a wafer at Step i, i ∈ N_n\N₂. Under the steady state, taking into account the robot waiting activities, task sequence σ₄ = 〈firing s_i2 (β) → firing x_i (μ) → firing s_(i+1)1 (β) → firing y_i−1 (μ) → robot waiting in q_i−1 (ω_(i−1)1) → firing s_(i−1)2 (β) → firing x_i−1 (μ) → firing s_i1 (β) → wafer processing (α_i) → the wafer remains in the PM after processed (i.e., the delay time) (d_i)〉 is performed to process a wafer. With m_i PMs for Step i, according to σ₄, θ_i can be determined using Equation (11).

θ_i = (α_i + d_i + 4β + 3μ + ω_(i−1)1)/m_i

(11)

For the satisfaction of Constraint (4), τ_i should be computed, and it relies on the cycle time of the robot. Therefore, it is necessary to analyze the periodic motion of the robot to determine its cycle time. The robot task sequence can be written as σ₅ = 〈firing s_n2 (β) → firing x_n (μ) → firing s₀₁ (β) → firing y_n−1 (μ) → robot waiting in q_n−1 (ω_(n−1)1) → firing s_(n−1)2 (β) → firing x_n−1 (μ) → firing s_n1 (β) → firing y_n−2 (μ) → firing y₂ (μ) → robot waiting in q₂ (ω₂₁) → firing s₂₂ (β) → firing x₂ (μ) → firing s₃₁ (β) → firing y₀ (μ) → robot waiting in q₀ (ω₀₁) → firing s₀₂ (β₀) → firing x₀ (μ) → robot waiting in q₁ (ω₁₁) → firing s₁₁ and s₁₂ (λ + ω_1s) → firing x₁ (μ) → firing s₂₁ (β) → firing y_n (μ) → robot waiting in q_n (ω_n1) → firing s_n2 again〉, and a cycle completes. Then, we can obtain the time taken for a robot task cycle as given by Equation (12).

$$\psi =(2n-1)\beta +{\beta }_0+(2n+1)\mu +\lambda +{\omega }_{1s}+{\sum }_{i=0}^n{\omega }_{i1}=(2n+1)\beta +{\beta }_0+(2n+2)\mu +{\omega }_{1s}+{\sum }_{i=0}^n{\omega }_{i1}$$

(12)

where ψ = ψ₁ + ψ₂, with ψ₁ = (2n + 1)β + β₀ + (2n + 2)μ being the robot task time and ψ₂ = ω_1s + ${\sum }_{i=0}^n{\omega }_{i1}$ being the robot waiting time.

A wafer is completed by performing the operations in σ₁, σ₃, σ₄, or σ₅. Therefore, the τ₁ is the same as that obtained by (8), and τ₂ and τ_i are obtained by Equations (13) and (14), respectively.

$${\tau }_2=m_2\times \psi -(5\beta +{\beta }_0+5\mu +{\sum }_{i=0}^1{\omega }_{i1}+{\omega }_{1s})$$

(13)

τ_i = m_i × ψ − (4β + 3μ + ω_(i−1)1)

(14)

4.2. Schedulability Conditions and Linear Programs for Solution

With the PN model and timeliness analysis described above, we can now discuss the existence of feasible solutions. Let Θ represent the cycle time. The following result can be derived.

Proposition 2. 

For an ATC-DACT, if the HTS operates under the steady state, the robot cycle time should equal the time required to complete a wafer at each step and the cycle time of the entire system, i.e., Equations (15) and (16) hold.

Θ = ψ = θ₁ = θ₂, n ≥ 2

(15)

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

(16)

where θ₁ with n ≥ 2, θ₂ with n = 2, θ₂ with n > 2, and θ_i, i ∈ N_n\N₂ and n > 2, are obtained by (5), (6), (10) and (11), respectively.

Under the conditions outlined in Proposition 2, we can adjust the waiting time of the robot to ensure that each PM takes the same time to complete a wafer. Therefore, the scheduling problem here is to optimally regulate the waiting time of the robot to maximize productivity and satisfy the RTCs as well. To make the PN model for an ATC-DACT live by finding a feasible schedule, the θ_i for Step i should be within a specific range. The upper and lower bounds of θ_i are denoted as Φ_iu and Φ_il, respectively, and they are determined as follows.

Φ_1u = (α₁ + δ₁ + 2β + μ)/m₁, n ≥ 2

(17)

Φ_1l = (α₁ + 2β + μ)/m₁, n ≥ 2

and

Φ_2u = (α₂ + δ₂ + 5β + β₀ + 5μ)/m₂, n ≥ 2

(18)

Φ_2l = (α₂ + 5β + β₀ + 5μ)/m₂, n ≥ 2

and

Φ_iu = (α_i +δ_i + 4β + 3μ)/m_i, i ∈ N_n\N₂, n > 2

(19)

Φ_il = (α_i + 4β + 3μ)/m_i, i ∈ N_n\N₂, n > 2

Given a schedule, if it makes θ_i ∈ [Φ_il, Φ_iu] and ∀i ∈ N_n and the PN for the system is live, then the schedule is feasible. Next, for n = 2, we discuss how to schedule the system by examining cases with different steps as the bottlenecks; while for n > 2, i ∈ N_n\N₂, we drive a linear programming model to schedule the system. Let Φ_lmax = max{Φ_il, i ∈ N_n}; the following lemmas can be developed.

Lemma 1. 

Under a steady-state process, if ψ₁ ≤ Φ_lmax ≤ Φ_iu, ∀i ∈ N_n, an ATC-DACT with RTCs is schedulable via the HTS strategy.

Proof. 

From Φ_lmax ≤ Φ_iu, it can be seen that [Φ_1l, Φ_1u] ∩ [Φ_2l, Φ_2u] ∩ [Φ_3l, Φ_3u] ∩…∩ [Φ_nl, Φ_nu] ≠ ∅ holds, meaning that we can set Θ = Φ_lmax = ψ. Let ψ₂ = ψ − ψ₁ = Φ_lmax − ψ₁. When n = 2, set ω_0s = ω_1s = 0 and ω₀₁ = ω₁₁ = 0; we can obtain ψ₂ = ω₂₁. According to (8) and (17), τ₁ = m₁ ×ψ − (2β + μ) = m₁ × Φ_lmax − (2β + μ) ≥ m₁ × (α₁ + 2β + μ)/m₁ − (2β + μ) = α₁, and τ₁ = m₁ ×ψ − (2β + μ) = m₁ ×Φ_lmax − (2β + μ) ≤ m₁ × (α₁ + δ₁ + 2β + μ)/m₁ − (2β + μ) = α₁ + δ₁. Then, from (3.5) and (3.14), τ₂ = m₂ ×ψ − (5β + β₀ + 5μ) = m₂ × Φ_lmax − (5β + β₀ + 5μ) ≥ m₂ × (α₂ + 5β + β₀ + 5μ)/m₂ − (5β + β₀ + 5μ) = a₂, and τ₂ = m₂ ×ψ − (5β + β₀ + 5μ) = m₂ × Φ_lmax − (5β + β₀ + 5μ) ≤ m₂ × (α₂ + δ₂ + 5β + β₀ + 5μ)/m₂ − (5β + β₀ + 5μ) = α₂ + δ₂. Setting ω_0s = 0 in Equation (13) is equivalent to setting ω_0s = ω_1s = 0 in (9). In this case, (13) also conforms to Constraint (4). This makes the RTCs satisfied. If n > 2 and i ∈ N_n\N₂, set ω_1s = 0 and ω_i1 = 0, i ∈ {0, 1, 2, …, n − 1}, by (14), τ_i = m_i × ψ − (4β + 3μ + ω_(i−1)1) = m_i × Φ_lmax − (4β + 3μ) ≥ m_i × (α_i + 4β + 3μ)/m_i − (4β + 3μ) = α_i, and τ_i = m_i × ψ − (4β + 3μ + ω_(i−1)1) = m_i × Φ_lmax − (4β + 3μ) ≤ m_i × (α_i + δ_i + 4β + 3μ)/m_i − (4β + 3μ) = α_i + δ_i, satisfying the RTCs. Therefore, the lemma holds and the tool is process-bound. □

Lemma 2. 

Under a steady-state process, if Φ_lmax ≤ ψ₁ ≤ Φ_iu, ∀i ∈ N_n, an ATC-DACT with RTCs is schedulable via the HTS strategy in all cases except the case that n = 2 and the bottleneck is Step 2 with m₂ = 1.

Proof. 

From Φ_lmax ≤ Φ_iu, it can be seen that [Φ_1l, Φ_1u] ∩ [Φ_2l, Φ_2u] ∩ [Φ_3l, Φ_3u] ∩…∩ [Φ_nl, Φ_nu] ≠ ∅ holds, meaning that Θ ∈ [Φ_lmax, Φ_umin] exists such that the robot does not wait anywhere, making (15) and (16) valid. In this case, we just let ${\sum }_{i=0}^1{\omega }_{is}$ = 0 and ${\sum }_{i=0}^n{\omega }_{i1}$ = 0, ψ = ψ₁ + ψ₂ = ψ₁ = Θ. If n ≥ 2, according to (8) and (17), τ₁ = m₁ × ψ − (2β + μ) = m₁ × ψ₁ − (2β + μ) ≥ m₁ × (a₁ + 2β + μ)/m₁ − (2β + μ) = α₁, and τ₁ = m₁ × ψ − (2β + μ) = m₁ × ψ₁ − (2β + μ) ≤ m₁ × (α₁ + δ₁ + 2β + μ)/m₁ − (2β + μ) = α₁ + δ₁. The requirements of the RTCs are met for Step 1. When Φ_lmax ≤ ψ₁ ≤ Φ_iu, ∀i ∈ N_n\N₁, apart from the case that n = 2 and the bottleneck is Step 2 with m₂ > 1, it can be derived from Equations (9) and (18) that τ₂ = m₂ ×ψ − (5β + β₀ + 5μ) = m₂ × ψ₁ − (5β + β₀ + 5μ) ≥ m₂ × (α₂ + 5β + β₀ + 5μ)/m₂ − (5β + β₀ + 5μ) = α₂, and τ₂ = m₂ × ψ − (5β + β₀ + 5μ) = m₂ × ψ₁ − (5β + β₀ + 5μ) ≤ m₂ × (α₂ + δ₂ + 5β + β₀ + 5μ)/m₂ − (5β + β₀ + 5μ) = α₂ + δ₂. Setting ω_0s = 0 in Equation (13) is equivalent to setting ω_0s = ω_1s = 0 in (9). In this case, Equation (13) also conforms to Constraint (4). The system satisfies the RTCs. If n > 2 and i ∈ N_n\N₂, according to (14) and (19), τ_i = m_i × ψ − (4β + 3μ + ω_(i−1)1) = m_i × ψ₁ − (4β + 3μ + ω_(i−1)1) ≥ m_i × (α_i + 4β + 3μ)/m_i − (4β + 3μ) = α_i, and τ_i = m_i × ψ − (4β + 3μ + ω_(i−1)1) = m_i × ψ₁ − (4β + 3μ + ω_(i−1)1) ≤ m_i × (α_i +δ_i + 4β + 3μ)/m_i = α_i + δ_i. The system also satisfies the RTCs. We will show in the following that when Φ_lmax ≤ ψ₁ ≤ Φ_iu, ∀i∈N_n, if n = 2 and the bottleneck is Step 2 with m₂ = 1, an ATC–DACT with RTCs is not schedulable. Hence, the lemma holds. □

In Lemma 2, we excluded the situation where n = 2 and the bottleneck is Step 2 with m₂ = 1 without giving proof. We present the proof for that by giving a corollary in the following.

Corollary 1. 

Under a steady-state process, if Φ_lmax ≤ ψ₁ ≤ Φ_iu, ∀i ∈ N_n, n = 2, and the bottleneck is Step 2 with m₂ = 1, an ATC-DACT with RTCs is unschedulable via the HTS strategy.

Proof. 

With Φ_lmax ≤ ψ₁ ≤ Φ_iu, ∀i ∈ N_n, if n = 2 and the bottleneck is Step 2, we have ψ₁ = 5β + β₀ + 5μ and Φ_lmax = Φ_2l = (α₂ + 5β + β₀ + 5μ)/m₂, leading to (α₂ + 5β + β₀ + 5μ)/m₂ ≤ 5β + β₀ + 5μ, i.e., α₂ ≤ (m₂ − 1)(5β + β₀ + 5μ) must hold. If m₂ = 1, to make this result hold, α₂ = 0 must hold, this is meaningless and the corollary is proved. □

Both Lemmas 1 and 2 discuss the cases that [Φ_1l, Φ_1u] ∩ [Φ_2l, Φ_2u] ∩ [Φ_3l, Φ_3u] ∩…∩ [Φ_nl, Φ_nu] ≠ ∅. Nevertheless, [Φ_1l, Φ_1u] ∩ [Φ_2l, Φ_2u] ∩ [Φ_3l, Φ_3u] ∩…∩ [Φ_nl, Φ_nu] = ∅ may occur, implying that, for some steps, Φ_lmax > Φ_iu may hold. In this case, let E = {i|Φ_lmax > Φ_iu, i ∈ N_n}, F ∈ N_n\E. Then, the robot waiting times ω_i1, ω_0s, and ω_1s, for ∀i ∈ N₂, can be set as follows.

ω_1s = 0, i = 1, i ∈ F, n ≥ 2

(20)

$${\sum }_{i=0}^1{\omega }_{i1}=0,{\omega }_{0s}=\left(m_2-m_1\right) \Theta +{\alpha }_1+{\delta }_1-\left({\alpha }_2+3\beta +{\beta }_0+4\mu \right) \mathrm{a}\mathrm{n}\mathrm{d} {\omega }_{0s}>0,i=2,i\in \mathit{F},n=2$$

(21)

ω_1s = m₁ × (Θ − Φ_1u), i = 1, i ∈ E, n ≥ 2

(22)

$${\omega }_{0s}+{\sum }_{i=0}^1{\omega }_{i1}=m_2\times \left({\Phi }_{lmax}-{\Phi }_{2u}\right),i=2,i\in \mathit{E},n=2$$

(23)

For the case of [Φ_1l, Φ_1u] ∩ [Φ_2l, Φ_2u] = ∅, we then present the following results.

Lemma 3. 

Under a steady-state process, for an ATC-DACT with RTCs, when n = 2 and Step 2 is the bottleneck, assume that [Φ_1l, Φ_1u] ∩ [Φ_2l, Φ_2u] = ∅ and ψ₁ < Φ_lmax. Let Φ_lmax + ΔΦ = ψ = Θ, ΔΦ ≥ 0. In this case, if m₁ ≥ m₂, an ATC-DACT with RTCs is unschedulable.

Proof. 

It will be included in the proof of Lemma 4 presented in the following. □

Lemma 4. 

Under a steady-state process, for an ATC-DACT with RTCs, when n = 2 and Step 2 is the bottleneck, if [Φ_1l, Φ_1u] ∩ [Φ_2l, Φ_2u] = ∅ and ${\sum }_{i=0}^1{\omega }_{is}$ + ${\sum }_{i=0}^1{\omega }_{i1}$ ≤ Θ − ψ₁, let Φ_lmax + ΔΦ = ψ = Θ, ΔΦ ≥ 0. Then, if there exist ω_1s > 0, m₁ < m₂ and [m₁ × (α₂ + 5β + β₀ + 5μ)/m₂ − (α₁ + δ₁ + 2β + μ) + ${\sum }_{i=0}^1{\omega }_{i1}$ + ω_0s]/(m₂ − m₁) ≤ ΔΦ ≤ [m₁ × (α₂ + 5β + β₀ + 5μ)/m₂ − (α₁ + δ₁ + 2β + μ) + δ₂ + ${\sum }_{i=0}^1{\omega }_{i1}$ + ω_0s]/(m₂ − m₁), the system is schedulable and the minimum cycle is Θ_min = α₂/(m₂ − 1).

Proof. 

When n = 2 and Step 2 is the bottleneck, we have Φ_lmax = Φ_2l > Φ_1u. Let Φ_lmax + ΔΦ = ψ = Θ. By Equation (8) and Φ_2l > Φ_1u, we have τ₁ = m₁ × ψ − (2β + μ + ω_1s) = m₁ × (Φ_2l + ΔΦ) − (2β + μ + ω_1s) > m₁ × (Φ_1u + ΔΦ) − (2β + μ + ω_1s) = α₁ + δ₁ + 2β + μ + m₁ × ΔΦ − (2β + μ + ω_1s) = α₁ + δ₁ + m₁ × ΔΦ − ω_1s. For a feasible schedule, τ₁ ≤ α₁ + δ₁ and ΔΦ ≥ 0 must hold. We can make τ₁ ≤ α₁ + δ₁ and ΔΦ ≥ 0 satisfied by simply setting ω_1s > 0. By Proposition 2 and Constraint (4), under a steady state, we have θ₂ = Φ_lmax + ΔΦ = (τ₂ + 5β + β₀ + 5μ + ${\sum }_{i=0}^1{\omega }_{is}$ + ${\sum }_{i=0}^1{\omega }_{i1}$)/m₂ = (α₂ + 5β + β₀ + 5μ)/m₂ + ΔΦ, and α₂ ≤ τ₂ = α₂ + m₂ × ΔΦ − ${\sum }_{i=0}^1{\omega }_{is}-{\sum }_{i=0}^1{\omega }_{i1}$ ≤ α₂ + δ₂, leading to the following Equation (24).

$${\sum }_{i=0}^1{\omega }_{is}+{\sum }_{i=0}^1{\omega }_{i1}\le m_2\times \mathrm{\Delta }\Phi \le {\sum }_{i=0}^1{\omega }_{is}+{\sum }_{i=0}^1{\omega }_{i1}+{\delta }_2$$

(24)

By Proposition 2, we have θ₁ = Φ_lmax + ΔΦ = (τ₁ + 2β + μ + ω_1s)/m₁ = (α₂ + 5β + β₀ + 5μ)/m₂ + ΔΦ, τ₁ = m₁ × (α₂ + 5β + β₀ + 5μ)/m₂ + m₁ × ΔΦ − (2β + μ + ω_1s). Based on Equation (24), one can obtain τ₁ = m₁ × (α₂ + 5β + β₀ + 5μ)/m₂ + m₁ × ΔΦ − (2β + μ + ω_1s) ≥ m₁ × (α₂ + 5β + β₀ + 5μ)/m₂ + m₁ × ΔΦ − (2β + μ + m₂ × ΔΦ) = m₁ × Φ_2l + (m₁ − m₂) × ΔΦ − (2β + μ) > m₁ × Φ_1u + (m₁ − m₂) × ΔΦ − (2β + μ) = α₁ + δ₁ + (m₁ − m₂) × ΔΦ. Then, if m₁ ≥ m₂, leading to τ₁ > α₁ + δ₁, Constraint (4) is violated and it is the case of Lemma 3, i.e., we present the proof of Lemma 3. On the contrary, if m₁ < m₂, by Equations (5) and (22), we have τ₁ = α₁ + δ₁. In this case, for a feasible schedule, α₂ ≤ τ₂ ≤ α₂ + δ₂ should hold. By Equation (8), α₂ ≤ τ₂ ≤ α₂ + δ₂ and ω_1s = m₁ × (Φ_lmax + ΔΦ − Φ_1u), we can obtain the following Equation (25).

$$[m_1\times ({\alpha }_2+5\beta +{\beta }_0+5\mu )/m_2-({\alpha }_1+{\delta }_1+2\beta +\mu )+{\sum }_{i=0}^1{\omega }_{i1}+{\omega }_{0s}]/(m_2-m_1)\le \mathrm{\Delta }\Phi \le [m_1\times ({\alpha }_2+5\beta +{\beta }_0+5\mu )/m_2-({\alpha }_1+{\delta }_1+2\beta +\mu )+{\delta }_2+{\sum }_{i=0}^1{\omega }_{i1}+{\omega }_{0s}]/(m_2-m_1)$$

(25)

Let ${\sum }_{i=0}^1{\omega }_{i1}$ = 0, ΔΦ_min = [m₁ × (α₂ + 5β + β₀ + 5μ)/m₂ − (α₁ + δ₁ + 2β + μ) + ω_0s]/(m₂ − m₁). Based on Equation (21), ΔΦ_min = [m₁ × (α₂ + 5β + β₀ + 5μ)/m₂ − (α₁ + δ₁ + 2β + μ) + α₁ + δ₁ + (1 − m₁) Θ − 3β − β₀ − 4μ]/(m₂ − m₁) = [(α₂ + 5β + β₀ + 5μ) − m₂ × (5β + β₀ + 5μ)]/[m₂ × (m₂ − 1)].

Hence, we can find a feasible schedule by setting the cycle time as Θ_min = Φ_lmax + ΔΦ = Φ_2l + ΔΦ_min = α₂/(m₂ − 1), which is the shortest one. Thus, Lemma 4 is proven. □

Lemma 5. 

Under a steady-state, for an ATC-DACT with RTCs, when n = 2 and Step 1 is the bottleneck, suppose that [Φ_1l, Φ_1u] ∩ [Φ_2l, Φ_2u] = ∅ and Φ_lmax − ψ₁ ≥ ${\sum }_{i=0}^1{\omega }_{is}$ + ${\sum }_{i=0}^1{\omega }_{i1}$. Then, the system is schedulable.

Proof. 

When n = 2 and Step 1 is the bottleneck, we have Φ_lmax = Φ_1l > Φ_2u. It follows from Φ_lmax − ψ₁ ≥ ${\sum }_{i=0}^1{\omega }_{is}$ + ${\sum }_{i=0}^1{\omega }_{i1}$ that ω₂₁ = ψ₂ − (${\sum }_{i=0}^1{\omega }_{is}$ + ${\sum }_{i=0}^1{\omega }_{i1}$) = Φ_lmax − ψ₁ − (${\sum }_{i=0}^1{\omega }_{is}$ + ${\sum }_{i=0}^1{\omega }_{i1}$) ≥ 0. Therefore, we have ψ = Φ_lmax. For Step 1 ∈ F, by Equation (8), τ₁ = m₁ × ψ − (2β + μ + ω_1s) = m₁ × Φ_1l − (2β + μ)= m₁ × (α₁ + 2β + μ)/m₁ − (2β + μ) = α₁. For Step 2 ∈ E, by Equations (9) and (21), setting ${\sum }_{i=0}^1{\omega }_{i1}$ = 0, τ₂ = m₂ × ψ − (5β + β₀ + 5μ + ω_0s) = m₂ × Φ_lmax − [5β + β₀ + 5μ + m₂ × (Φ_lmax − Φ_2u)] = α₂ + δ₂. Because E ∪ F = N₂ and E ∩ F = ∅, the RTCs are satisfied for both steps. Therefore, it is schedulable. □

Lemmas 4 and 5 provide the necessary and sufficient conditions for the system to be schedulable under [Φ_1l, Φ_1u] ∩ [Φ_2l, Φ_2u] = ∅ and ψ₁ < Φ_lmax when n = 2 without discussing the case for n > 2. Based on Equations (5), (10) and (11), when i > 2, the robot waiting time to be considered by Step i has no correlation with that of Steps 1 and 2. Unlike Steps 1 and 2, the correlation can be generated by ω_1s. Hence, it becomes significantly more challenging to determine the robot waiting time that satisfies the RTCs while minimizing the cycle time. In this case, deriving the necessary and sufficient conditions for optimally scheduling the system is very difficult. To solve this problem, we can use the analysis’s insights to express the problem as a linear program. This formulation enables us to identify a feasible and optimal schedule efficiently.

Linear Programming Model (LPM). 

Under a steady-state process, for an ATC-DACT with RTCs, when n > 2, suppose that [Φ_1l, Φ_1u] ∩ [Φ_2l, Φ_2u] ∩ [Φ_3l, Φ_3u] ∩…∩ [Φ_nl, Φ_nu] = ∅ and ψ₁ < Φ_lmax. Let Φ_lmax + ΔΦ = ψ = Θ, ΔΦ ≥ 0. A linear program is established to obtain a schedule as follows.

Minimize Θ

$$\mathrm{Subject} \mathrm{to}$$

α_i ≤ τ_i ≤ α_i + δ_i

(4)

τ₁ = m₁ × ψ − (2β + μ + ω_1s)

(8)

$$\psi =(2n-1)\beta +{\beta }_0+(2n+1)\mu +\lambda +{\omega }_{1s}+{\sum }_{i=0}^n{\omega }_{i1}=(2n+1)\beta +{\beta }_0+(2n+2)\mu +{\omega }_{1s}+{\sum }_{i=0}^n{\omega }_{i1}$$

(12)

$${\tau }_2=m_2\times \psi -(5\beta +{\beta }_0+5\mu +{\sum }_{i=0}^1{\omega }_{i1}+{\omega }_{1s})$$

(13)

τ_i = m_i × ψ − (4β + 3μ + ω_(i−1)1)

(14)

Θ = ψ = θ₁ = θ₂, n ≥ 2

(15)

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

(16)

Φ_lmax + ΔΦ = Θ, ΔΦ ≥ 0

(26)

Φ_lmax = max{Φ_il, i ∈ N_n}

(27)

In the LPM, Constraint (4) guarantees that the wafer sojourn time is within the permissible time windows. Then, Equation (12) obtains the robot cycle time. Constraints (8), (13) and (14) determine the sojourn time under the HTS. Constraints (15) and (16) come from Proposition 2. These two equations combined with Equations (26) and (27) are used to calculate ω_is, ω_i1, and Θ. By the LPM, if a feasible schedule is found, the system is schedulable; otherwise, it is unschedulable.

With [Φ_1l, Φ_1u] ∩ [Φ_2l, Φ_2u] ∩ [Φ_3l, Φ_3u] ∩…∩ [Φ_nl, Φ_nu] ≠ ∅, we present Lemmas 1 and 2, where it is assumed that ψ₁ ≤ Φ_iu, ∀i ∈ N_n. However, with [Φ_1l, Φ_1u] ∩ [Φ_2l, Φ_2u] ∩ [Φ_3l, Φ_3u] ∩…∩ [Φ_nl, Φ_nu] ≠ ∅, there may be a Step k ∈ N_n such that ψ₁ > Φ_ku. As stated by Lemma 6 below, the system is not schedulable in this case.

Lemma 6. 

Under a steady-state process, for an ATC-DACT with RTCs, if Φ_lmax ≤ Φ_iu, ∀i ∈ N_n, and there exists Step k such that ψ₁ > Φ_ku, then the tool is not schedulable via the HTS strategy.

Proof. 

If k = 1 and n ≥ 2, by Equations (8) and (17), and ψ₁ > Φ_1u, τ₁ = m₁ × ψ − (2β + μ + ω_1s) = m₁ × (ψ₁ + ψ₂) − (2β + μ + ω_1s) > m₁ × Φ_1u − (2β + μ + ω_1s) = α₁ + δ₁ − ω_1s. Due to Φ_lmax ≤ Φ_1u, we can obtain ω_1s = 0, so that τ₁ > α₁ + δ₁, violating the RTC. If k = 2 and n = 2, by Equations (9) and (18), and ψ₁ > Φ_2u, τ₂ = m₂ × ψ − (5β + β₀ + 5μ +${\sum }_{i=0}^1{\omega }_{is}$ + ${\sum }_{i=0}^1{\omega }_{i1}$) = m₂ × (ψ₁ + ψ₂) − (5β + β₀ + 5μ +${\sum }_{i=0}^1{\omega }_{is}$ + ${\sum }_{i=0}^1{\omega }_{i1}$) > m₂ × (Φ_2u+ ψ₂) − (5β + β₀ + 5μ +${\sum }_{i=0}^1{\omega }_{is}$ + ${\sum }_{i=0}^1{\omega }_{i1}$) = α₂ + δ₂ + m₂ × ω₂₁ + (m₂ − 1)(${\sum }_{i=0}^1{\omega }_{is}$ + ${\sum }_{i=0}^1{\omega }_{i1}$). Based on Equation (21), m₂ × ω₂₁ + (m₂ − 1)(${\sum }_{i=0}^1{\omega }_{is}$ + ${\sum }_{i=0}^1{\omega }_{i1}$) ≥ 0. Then, we have τ₂ > α₂ + δ₂; the lemma holds. If k = 2 and n > 2, by Equations (13) and (18), and ψ₁ > Φ_2u, τ₂ = m₂ × ψ − (5β + β₀ + 5μ +${\sum }_{i=0}^1{\omega }_{is}$ + ω_1s) = m₂ × (ψ₁ + ψ₂) − (5β + β₀ + 5μ + ${\sum }_{i=0}^1{\omega }_{i1}$ + ω_1s) > m₂ × (Φ_2u + ψ₂) − (5β + β₀ + 5μ + ${\sum }_{i=0}^1{\omega }_{i1}$ + ω_1s) = α₂ + δ₂ + m₂ × ω₂₁ + (m₂ − 1)(ω_1s + ${\sum }_{i=0}^1{\omega }_{i1}$). Again, we obtain m₂ × ω₂₁ + (m₂ − 1)(ω_1s + ${\sum }_{i=0}^1{\omega }_{i1}$) ≥ 0. Then, we have τ₂ > α₂ + δ₂, violating Constraint (4); the lemma holds. If k > 2 and n > 2, by Equations (14) and (19), and ψ₁ > Φ_ku, τ_k = m_k × ψ − (4β + 3μ + ω_(k−1)1) = m_k × (ψ₁ + ψ₂) − (4β + 3μ + ω_(k−1)1) > m_k × (Φ_ku + ψ₂) − (4β + 3μ + ω_(k−1)1) = α_k + δ_k + m_k × ω_1s + (m_k × ${\sum }_{i=0}^n{\omega }_{i1}$ − ω_(k−1)1). We can obviously obtain m_k × ω_1s + (m_k × ${\sum }_{i=0}^n{\omega }_{i1}$ − ω_(k−1)1) ≥ 0. Then, we have τ_k > α_k + δ_k, violating Constraint (4); it is not schedulable either in this case. □

In the above discussion, we build the necessary and sufficient conditions for ATC-DACTs with RTCs to be schedulable under a steady state. Next, with the above results, Algorithm 1 is given to optimally schedule the system by calculating ω_is, i ∈ {0,1}and ω_i1, i ∈ {0} ∪ N_n.

Algorithm 1. If an ATC-DACT is schedulable, find a schedule by setting the robot waiting time
	Input: αi, β, β0, μ, mi, i ∈ Nn
	Output: ωis, i ∈ {0,1} and ωi1, i ∈ {0} ∪ Nn, Θ
(1)	Calculate Φil, i ∈ Nn, and ψ1 by (7), (12) and (17)–(19)
(2)	If the conditions stated in Lemma 1 are met
	(2.1)	ωis = 0, i ∈ {0, 1};
	(2.2)	ωi1 = 0, ∀i ∈ Nn−1;
	(2.3)	ωn1 = Φlmax − ψ1;
	(2.4)	Θ = ψ = Φlmax.
(3)	If the conditions stated in Lemma 2 are met
	(3.1)	ωi1 = 0, ∀i ∈ {0} ∪ Nn;
	(3.2)	ωis = 0, i ∈ {0, 1};
	(3.3)	Θ = ψ = ψ1.
(4)	If the conditions stated in Lemma 4 are met
	(4.1)	For Step 1 ∈ E, ω1s = m1 × (Θ − Φ1u);
	(4.2)	For Step 2 ∈ F, ω0s = (m2 − m1) Θ + α1 + δ1 − (α2 + 3β + β0 + 4μ) and ${\sum }_{i=0}^1{\omega }_{i1}$ = 0;
	(4.3)	ωn1 = Θ − ψ1 − ${\sum }_{i=0}^1{\omega }_{is}$;
	(4.4)	Θmin = Φ2l + ΔΦmin = α2/(m2 − 1).
(5)	If the conditions stated in Lemma 5 are met
	(5.1)	For Step 1 ∈ F, ω1s = 0;
	(5.2)	For Step 2 ∈ E, ω0s = m2 × (Φlmax − Φ2u) and ${\sum }_{i=0}^1{\omega }_{i1}$ = 0;
	(5.3)	Θ = Φlmax = Φ1l.
(6)	Else
		Call LPM.

Through Algorithm 1, under the HTS strategy, if an ATC-DACT is checked to be schedulable according to Lemmas 1, 2, 4, and 5, a feasible schedule can be achieved by simply setting the robot waiting time. Also, by the LPM, a feasible schedule can be efficiently found if it exists. The primary concern is whether the resulting schedule is optimal, which is addressed by the following theorem.

Theorem 1. 

If an ATC-DACT is schedulable by the HTS strategy checked by Lemmas 1, 2, 4, and 5, then a schedule obtained through Algorithm 1 is deemed optimal.

Proof. 

By Algorithm 1, for Lemmas 1 and 5, the system’s cycle time Θ = Φ_lmax. Suppose a steady-state schedule exists under the HTS strategy with Θ < Φ_lmax. Without loss of generality, suppose that Step k is the bottleneck step represented as Φ_lmax = Φ_kl. When n ≥ 2, k = 1, by (8), we can obtain τ₁ = m₁ × ψ − (2β + μ + ω_1s) = m₁ × Θ − (2β + μ + ω_1s) < m₁ × Φ_lmax − (2β + μ + ω_1s) = m₁ × Φ_1l − (2β + μ + ω_1s). Then, by (17), we have τ₁ < α₁ − ω_1s. Because ω_1s = 0, τ₁ < α₁, violating the RTCs. Hence, in this case, there is no feasible schedule if Θ < Φ_lmax. When n = 2, k = 2, by (9), we can obtain τ₂ = m₂ × ψ − (5β + β₀ + 5μ + ${\sum }_{i=0}^1{\omega }_{is}$ + ${\sum }_{i=0}^1{\omega }_{i1}$) = m₂ × Θ − (5β + β₀ + 5μ + ${\sum }_{i=0}^1{\omega }_{is}$ + ${\sum }_{i=0}^1{\omega }_{i1}$) < m₂ × Φ_2l − (5β + β₀ + 5μ + ${\sum }_{i=0}^1{\omega }_{is}$ + ${\sum }_{i=0}^1{\omega }_{i1}$). Then, by (18), we have τ₂ < α₂ − (${\sum }_{i=0}^1{\omega }_{is}$ + ${\sum }_{i=0}^1{\omega }_{i1})$. Because ${\sum }_0^1{\omega }_{is}$ + ${\sum }_0^1{\omega }_{i1}$ ≥ 0, τ₂ < α₂, there is no feasible schedule if Θ < Φ_lmax. When n > 2, k = 2, by (13), we can obtain τ₂ = m₂ × ψ − (5β + β₀ + 5μ + ${\sum }_{i=0}^1{\omega }_{i1}$ + ω_1s) = m₂ × Θ − (5β + β₀ + 5μ + ${\sum }_{i=0}^1{\omega }_{i1}$ + ω_1s) < m₂ × Φ_2l − (5β + β₀ + 5μ + ${\sum }_{i=0}^1{\omega }_{i1}$ + ω_1s). Then, by (18), we have τ₂ < α₂ − (${\sum }_{i=0}^1{\omega }_{i1}$ + ω_1s), implying no feasible schedule in this case if Θ < Φ_lmax. When n > 2, k ∈ N_n\N₂, by (14), we can obtain τ_k = m_k × ψ − (4β + 3μ + ω_(k−1)1) < m_k × Φ_kl − (4β + 3μ + ω_(k−1)1). Then, by (19), we have τ_k < α₂ − ω_(k−1)1; it is not possible to find a feasible schedule if Θ < Φ_lmax. For Lemma 2, by Algorithm 1, the resulting schedule is considered unfeasible when the system is scheduled with Θ = ψ < ψ₁. For Lemma 4, by Algorithm 1, the system’s minimum cycle time Θ_min = Φ_2l + ΔΦ_min = α₂/(m₂ − 1). Suppose a steady-state schedule exists under the HTS strategy with the condition that ΔΦ₁ < ΔΦ_min. That is, ΔΦ₁ < [(α₂ + 5β + β₀ + 5μ) − m₂ × (5β + β₀ + 5μ)]/[m₂ × (m₂ − 1)]. By Proposition 2 and Constraint (4), under a steady state, we have θ₂ = Φ_lmax + ΔΦ₁ = (τ₂ + 5β + β₀ + 5μ + ${\sum }_{i=0}^1{\mathrm{\omega }}_{is}$ + ${\sum }_{i=0}^1{\omega }_{i1}$)/m₂ = (α₂ + 5β + β₀ + 5μ)/m₂ + ΔΦ₁, and α₂ ≤ τ₂ = α₂ + m₂ × ΔΦ₁ − ${\sum }_{i=0}^1{\omega }_{is}-{\sum }_{i=0}^1{\omega }_{i1}$. Then, we have ΔΦ₁ ≥ (${\sum }_{i=0}^1{\omega }_{is}$ + ${\sum }_{i=0}^1{\omega }_{i1}$)/m₂. Let ${\sum }_{i=0}^1{\omega }_{i1}$ = 0, by Equations (21) and (22), we have ΔΦ₁ ≥ [(α₂ + 5β + β₀ + 5μ) − m₂ × (5β + β₀ + 5μ)]/[m₂ × (m₂ − 1)]. This conflicts with the assumption that ΔΦ₁ < [(α₂ + 5β + β₀ + 5μ) − m₂ × (5β + β₀ + 5μ)]/[m₂ × (m₂ − 1)]. Hence, there is no ΔΦ₁ smaller than ΔΦ_min for a feasible solution. Finally, linear programming can reliably produce an optimal solution for a given problem, so the cycle time obtained using the LPM is minimized. □

So far, we have established necessary and sufficient conditions for the schedulability of ATC-DACTs and presented the corresponding algorithm to obtain a feasible and optimal schedule, if one exists. Next, we present cases to demonstrate the practical application of the methods outlined in this paper.

Cluster tools are widely applied to wafer fabrication for various processes in semiconductor manufacturing fabs. The vendor of cluster tools should govern the fabrication of wafers that require these processes and fabs provide just the fabrication parameters. Thus, if a cluster tool is developed for some processes, scheduling algorithms dedicated to these processes are necessary. Then, controller should be developed by the vendor for this cluster tool such that relevant scheduling algorithms can be embedded into the controller. Then, in operating this cluster tool, the operator in fabs needs to input the relevant parameters only to complete the fabrication for a given process. Thus, the proposed algorithm here is for the development of controllers for cluster tools in semiconductor manufacturing.

5. Demonstrative Examples

To show how the to apply the proposed method and demonstrate its efficiency and effectiveness, some industrial examples are presented in this section. The research group of this paper is working with some semiconductor-manufacturing equipment venders and semiconductor-manufacturing fabs. The data for the presented examples are obtained from them. In the dataset, the time unit is seconds and omitted in the following cases. The algorithm is coded using the 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.

Example 1. 

The WFP of this example is (1, 1, 1). Steps 1, 2, and 3 are served by PM₁, PM₂, and PM₃, respectively, and we discuss four cases.

Case 1: The processing time is α₁ = 160.0, α₂ = 100.0, α₃ = 138.0; the RTCs are given as δ₁ = 30.0, δ₂ = 20.0, and δ₃ = 30.0; the robot task time is β = 10.0, β₀ = 15.0, and μ = 2.0. This case’s PN model is as in Figure 2 with n = 3. We can obtain Φ_1l = 182.0, Φ_1u = 212.0, Φ_2l = 175.0, Φ_2u = 195.0, Φ_3l = 186.0, Φ_3u = 216.0, and ψ₁ = 101.0. Thus, Φ_lmax = Φ_3l = 186.0 > ψ₁ and Φ_lmax < Φ_2u < Φ_1u; the conditions stated in Lemma 1 are met, i.e., a feasible schedule exists. Based on Algorithm 1, we have Θ = ψ = Φ_lmax = 186.0, ψ₂ = ψ − ψ₁ = 186.0 − 101.0 = 85.0. Also, by Algorithm 1, ω_1s = ω₀₁ = ω₁₁ = ω₂₁ = 0.0 and ω₃₁ = 85.0 are set; we obtain a feasible and optimal schedule.

Case 2: The processing time is α₁ = 90.0, α₂ = 37.0, α₃ = 78.0; the RTCs are given as δ₁ = 32.0, δ₂ = 20.0, and δ₃ = 25.0; β = 15.0, β₀ = 20.0, and μ = 3.0. This case’s PN model is as in Figure 2 with n = 3. We can obtain Φ_1l = 123.0, Φ_1u = 155.0, Φ_2l = 147.0, Φ_2u = 167.0, Φ_3l = 139.0, Φ_3u = 164.0, and ψ₁ = 149.0. Thus, Φ_lmax < ψ₁ < Φ_umin; the conditions in Lemma 2 are satisfied, implying the existence of a feasible schedule. By Algorithm 1, we have Θ = ψ₁ = 149.0, so ψ = ψ₁ = 149.0. Then, a feasible and optimal schedule is obtained by simply setting ω_1s = ω₀₁ = ω₁₁ = ω₂₁ = ω₃₁ = 0.0 via Algorithm 1.

Case 3: In Case 2, the permissive delay time at Step 1 is changed to δ₁ = 25.0, with the other parameters being unchanged. This case’s PN model is as in Figure 2, with n = 3. We can obtain Φ_1l = 123.0, Φ_1u = 148.0, Φ_2l = 147.0, Φ_2u = 167.0, Φ_3l = 139.0, Φ_3u = 164.0, and ψ₁ = 149.0. Thus, Φ_lmax = 147.0 < Φ_1u <Φ_3u and ψ₁ > Φ_1u, the conditions stated in Lemma 6 are met, and it is evident that scheduling is not feasible.

Case 4: The processing time is α₁ = 90.0, α₂ = 67.0, α₃ = 78.0; the RTCs are given as δ₁ = 15.0, δ₂ = 20.0, and δ₃ = 25.0; β = 15.0, β₀ = 20.0, and μ = 3.0. This case’s PN model is as in Figure 2, with n = 3. We can obtain Φ_1l = 123.0, Φ_1u = 138.0, Φ_2l = 177.0, Φ_2u = 197.0, Φ_3l = 139.0, Φ_3u = 164.0, and ψ₁ = 149.0. Thus, [Φ_1l, Φ_1u] ∩ [Φ_2l, Φ_2u] ∩ [Φ_3l, Φ_3u] = ∅ and ψ₁ < Φ_lmax. By applying the LPM, it shows that no feasible schedule can be found.

Example 2. 

The WFP of this example is (1, 2); PM₁ serves for Step 1, and PM₂ and PM₃ serve for Step 2. There are five cases.

Case 1: The wafer processing time is α₁ = 100.0 and α₂ = 180.0; the RTCs are given as δ₁ = 25.0 and δ₂ = 25.0; β = 6.0, β₀ = 10.0, and μ = 3.0. This case’s PN model is as in Figure 3, with n = 2. We can obtain Φ_1l = 115.0, Φ_1u = 140.0, Φ_2l = 117.5, Φ_2u = 130.0, and ψ₁ = 55.0. Thus, Φ_lmax = Φ_2l = 117.5 > ψ₁ and Φ_lmax < Φ_2u < Φ_1u; the conditions stated in Lemma 1 are met. In this case, it is schedulable. By Algorithm 1, we have Θ = ψ = Φ_lmax = 117.5, so ψ₂ = ψ − ψ₁ = 117.5 − 55.0 = 62.5. By setting ω_0s = ω_1s = ω₀₁ = ω₁₁ = 0.0 and ω₂₁ = 62.5 via Algorithm 1, we obtain a feasible and optimal schedule.

Case 2: The processing time is α₁ = 70.0 and α₂ = 105.0; the RTCs are given as δ₁ = 20.0 and δ₂ = 15.0; the robot task time is β = 15.0, β₀ = 20.0, and μ = 3.0. This case’s PN model is as in Figure 3, with n = 2. We can obtain Φ_1l = 103.0, Φ_1u = 123.0, Φ_2l = 107.5, Φ_2u = 122.5, and ψ₁ = 110.0. Thus, Φ_lmax = Φ_2l = 107.5 < ψ₁ = 110.0, Φ_lmax < ψ₁ < Φ_2u < Φ_1u and m₂ = 2; the conditions stated in Lemma 2 are met, i.e., it is schedulable. By Algorithm 1, we set Θ = ψ = ψ₁ = 107.5, and ω_0s = ω_1s = ω₀₁ = ω₁₁ = ω₂₁ = 0.0 to achieve a schedule that is feasible and optimal.

Case 3: In Case 2, the processing time at Step 1 is changed to α₁ = 50.0, the permissive delay time at Step 1 is changed to δ₁ = 25.0, and the other parameters are unchanged. This case’s PN model is as in Figure 3, with n = 2. We can obtain Φ_1l = 83.0, Φ_1u = 108.0, Φ_2l = 107.5, Φ_2u = 122.5, and ψ₁ = 110.0. Thus, Φ_lmax = Φ_2l = 107.5 < Φ_1u < Φ_2u and ψ₁ > Φ_1u; the conditions stated in Lemma 6 are met. In this case, it shows that no feasible schedule can be found.

Case 4: In Case 3, the processing time at Step 2 is changed to α₂ = 120.0, the permissive delay time at Step 1 is changed to δ₁ = 30.0, and the other parameters are unchanged. This case’s PN model is as in Figure 3 with n = 2. We can obtain Φ_1l = 83.0, Φ_1u = 113.0, Φ_2l = 115.0, Φ_2u = 122.5, and ψ₁ = 110.0. Thus, [Φ_1l, Φ_1u] ∩ [Φ_2l, Φ_2u] = ∅, ψ₁ < Φ_lmax. and m₁ < m₂. It is checked that the conditions stated in Lemma 4 are met, showing that a feasible schedule can be found. In this case, Θ_min = α₂/(m₂ − 1) = 120.0. Based on Algorithm 1, let ${\sum }_{i=0}^1{\omega }_{i1}$ = 0.0, we have ω_0s = (m₂ − m₁) Θ_min + α₁ + δ₁ − (α₂ + 3β + β₀ + 4μ) = 3.0, ω_1s = m₁ × (Θ_min − Φ_1u) = 120.0 − 113.0 = 7.0. Hence, ω₂₁ = Θ − ψ₁ − ${\sum }_{i=0}^1{\omega }_{is}$ = 120.0 − 110.0 − 3.0 − 7.0 = 0.0.

Case 5: In Case 2, the processing time at Step 1 is changed to α₁ = 90.0, and the other parameters are unchanged. This case’s PN model is as in Figure 3, with n = 2. We can obtain Φ_1l = 123.0, Φ_1u = 143.0, Φ_2l = 107.5, Φ_2u = 122.5, and ψ₁ = 110.0. Thus, Φ_lmax = Φ_1l = 123.0 > Φ_2u and ψ₁ < Φ_lmax. By (20) and (23); let ${\sum }_{i=0}^1{\omega }_{i1}$ = 0.0, we have ω_1s = 0.0 and ω_0s = m₂ × (Φ_lmax − Φ_2u) = 1.0, and ${\sum }_{i=0}^1{\omega }_{is}$ + ${\sum }_{i=0}^1{\omega }_{i1}$ = 1.0 < Φ_lmax − ψ₁ = 13.0. The conditions stated in Lemma 5 are met. Therefore, based on Algorithm 1, by setting ω_1s = 0.0, ω_0s = 1.0 and ω₂₁ = 13.0 − 1.0 = 12.0, a schedule that is feasible and optimal is successfully found.

As discussed above, there may exist unscheduled cases. The results of the experiments can be clearly seen in

Table 3. Summary of experimental results for industrial examples.

Examples		Case 1	Case 2	Case 3	Case 4	Case 5
Example 1 WFP = (1, 1, 1)	Parameters	α1 = 160.0, α2 = 100.0, α3 = 138.0; δ1 = 30.0, δ2 = 20.0, δ3 = 30.0; β = 15.0, β0 = 20.0, μ = 3.0.	α1 = 90.0, α2 = 37.0, α3 = 78.0; δ1 = 32.0, δ2 = 20.0, δ3 = 25.0; β = 15.0, β0 = 20.0, μ = 3.0.	α1 = 90.0, α2 = 37.0, α3 = 78.0; δ1 = 25.0, δ2 = 20.0, δ3 = 25.0; β = 15.0, β0 = 20.0, μ = 3.0.	α1 = 90.0, α2 = 67.0, α3 = 78.0; δ1 = 15.0, δ2 = 20.0, and δ3 = 25.0; β = 15.0, β0 = 20.0, and μ = 3.0.
	Cycle time	186.0	149.0	Unschedulable	Unschedulable
	Algorithm verification	Lemma 1	Lemma 2	Lemma 6	LPM
Example 2 WFP = (1, 2)	Parameters	α1 = 100.0 and α2 = 180.0; δ1 = 25.0, δ2 = 25.0; β = 6.0, β0 = 10.0, μ = 3.0.	α1 = 70.0 and α2 = 105.0; δ1 = 20.0, δ2 = 15.0; β = 15.0, β0 = 20.0, μ = 3.0.	α1 = 50.0 and α2 = 105.0; δ1 = 25.0, δ2 = 15.0; β = 15.0, β0 = 20.0, μ = 3.0.	α1 = 50.0 and α2 = 120.0; δ1 = 30.0, δ2 = 15.0; β = 15.0, β0 = 20.0, μ = 3.0.	α1 = 90.0 and α2 = 105.0; δ1 = 20.0, δ2 = 15.0; β = 15.0, β0 = 20.0, μ = 3.0.
	Cycle time	117.5	107.5	Unschedulable	120.0	123.0
	Algorithm verification	Lemma 1	Lemma 2	Lemma 6	Lemma 4	Lemma 5

. If such a case is detected by the proposed method, this provides process engineers with a message, and engineers can redesign the process to cope with the problem.

6. Conclusions

Within this study, we explore the scheduling optimization problem under steady state for arm task-constrained dual-arm cluster tools (ATC-DACTs) with RTCs using a PN model. With the configuration properties, we find that when the two arms of a dual-arm robot should be distinguished as dirty and clean ones, meeting the RTCs is more challenging in scheduling such a cluster tool. Thus, finding an optimal and feasible schedule for such tools is a critical issue, and the existing methods are not applicable.

To address this issue, this work builds a colored PN model for it. The PN model explicitly describes when the robot should wait, and the robot waiting is modeled explicitly as an event, thereby revealing the relationship between the wafer sojourn time in a PM and the system cycle time. The PN model uses colors to distinguish the dirty and clean arms. Based on the model, a hybrid task strategy (HTS) for the robot is proposed as a scheduling strategy by combining the swap and backward strategies. We then present necessary and sufficient conditions for the schedulability of an ATC-DACT with RTCs. It is shown that the presence of a feasible schedule is contingent upon both the number of fabrication process steps and the identification of the bottleneck step. We discuss different situations in establishing the schedulability conditions in the case of n = 2. For n > 2, i ∈ N_n\N₂, an LPM is established. Then, by summarizing the obtained results, we give an algorithm that can efficiently find a schedule that is both feasible and optimal, if one exists. Finally, this article validates these findings through various case studies.

While this work makes significant strides in addressing the steady-state scheduling problem for ATC-DACTs with RTCs, there are still avenues for further research. First, the current study focuses solely on the steady-state behavior of the system, neglecting the transient processes that occur during system starting or following changes in the production plan. Optimizing these transient processes could further enhance the overall throughput and efficiency of ATC-DACTs. Second, the built model assumes perfect knowledge of all system parameters and does not account for potential uncertainties or disruptions, such as machine breakdowns or wafer defects. Incorporating robust scheduling strategies that can adapt to such uncertainties represents an important direction for future work.