Patent Grant
9333645
A portion of the disclosure of this patent document contains material, which is subject to copyright protection. The copyright owner has no objection to the facsimile reproduction by anyone of the patent document or the patent disclosure, as it appears in the Patent and Trademark Office patent file or records, but otherwise reserves all copyright rights whatsoever.
The present invention relates to a method for scheduling dual-armed cluster tools with wafer revisiting.
The following references are cited in the specification. Disclosures of these references are incorporated herein by reference in their entirety.
List of References:
To achieve better quality control and reduce lead time, cluster tools are widely used for wafer processing in semiconductor manufacturing systems with a single-wafer processing technology that processes wafer one by one at a process module (PM). They provide a reconfigurable, flexible and efficient environment [Bader et al., 1990; and Burggraaf, 1995]. A cluster tool consists of several PMs, an aligner module, a wafer handling robot (transfer module), and loadlocks (LL) for wafer cassette loading/unloading, which are mechanically linked together in a radial way and computer-controlled. With a single-arm or dual-arm robot, such tool is correspondingly called a single-arm or dual-arm cluster tool. The latter is shown in
A cluster tool with two LLs can be operated consecutively without being interrupted. Thus, it can operate in a steady state for most of time. Most prior studies [Chan et al., 2011; Ding et al., 2006; Perkinston et al., 1994; Perkinston et al., 1996; Venkatesh et al., 1997; Wu and Zhou, 2010; Yi et al., 2008; and Zuberek, 2001] were conducted to find an optimal periodical schedule. Only limited researches focused on transient states [Kim et al., 2013a; Kim et al., 2013b; Lee et al., 2012; Ahn and Morrison, 2010; and Wikborg and Lee, 2013] despite their increasing importance. With a given robot task sequence, the transient cycle time of a dual-arm cluster tool is minimized [Kim et al., 2013b]. Deadlock-free conditions are presented for lot switching periods of dual-arm cluster tools [Lee et al., 2012]. A model for transient and steady states is built [Ahn and Morrison, 2010]. When a robot task sequence is determined, an algorithm for an optimal transient cycle is proposed [Kim et al., 2013a, and Wikborg and Lee, 2013]. Since frequent switches between transient and steady states may lead to a deadlock problem, optimizing transient processes for cluster tools is recognized to be a big research challenge.
Some wafer fabrication processes, for instance, atomic layer deposition (ALD), require a wafer to visit more than once a PM under identical processing conditions. Due to such revisits, wafer processes are no longer a flow-shop, and the prior results without considering revisits, e.g. [Kim et al., 2013(a); and Wikborg and Lee, 2013], are no longer applicable. Such revisits make the optimal scheduling of transient processes much more challenging. Note that some well-developed theories or rules for a steady process [Lee and Lee, 2006] are not applicable for scheduling transient processes. Furthermore, deadlock often becomes an issue in a wafer fabrication process with revisit in a cluster tool [Lee and Lee, 2006]. It is certainly much more challenging to schedule a deadlock-prone system to obtain an optimal and deadlock-free schedule. In order to avoid deadlock and minimize makespan for a dual-arm cluster tool with wafer revisit, the studies [Wu and Zhou, 2010; and Zuberek, 2004] have developed Petri net models for performance evaluation and analyzed its cycle time under a swap strategy. They show that the steady state cycle time is determined by the time taken for completing one wafer at the step that has the heaviest workload. In fact, it is the lower bound of the cycle time for the system. However, this result is shown to be not correct in [Wu et al., 2013b], where a swap-based strategy is proposed and leads to a three-wafer cyclic schedule, which includes three local cycles for a revisiting process and three global cycles. It is also shown that the system can never enter its steady state under some conditions. In other words, the steady state-based analysis methods given in [Wu and Zhou, 2010; and Zuberek, 2004] are not applicable and the tool cannot reach the lower bound of cycle time. The multiple local and global cycles reduce the productivity of such cluster tools [Wu et al., 2013a]. Can a schedule with fewer local and global cycles improve the performance? The work [Wu et al., 2013b; and Qiao et al., 2013] answers this question by providing a schedule with two-wafer cycle, and also the one with one cycle only. It finds that the less the number of global cycles is, the shorter the robot waiting time is. Qiao et al. [2013] prove that one-wafer periodic schedule is optimal. They also provide a novel Petri net-based method to evolve a system from a transient state to a steady one. However, the transient process is not optimal despite its easy implementation according to the results to be presented in this work.
Although the minimum transient period is proposed for transient process scheduling [Kim et al., 2012], such conclusion is applicable to a non-revisiting case only. Their method cannot be extended a process with revisits without substantial research. The transient scheduling of dual-arm cluster tools with wafer revisiting to reach a desired steady state optimally is widely open as one has not found any study addressing it.
There is a need in the art for a method to obtain a schedule for dual-armed cluster tools with wafer revisiting process.
An aspect of the present invention is to provide a method for scheduling dual-armed cluster tools with wafer revisiting process under optimization of start-up transient processes.
According to an embodiment of the present claimed invention, a method for scheduling a dual-armed cluster tools with wafer revisiting, comprises: obtaining, by a processor, a wafer processing time, a wafer loading time, a wafer unloading time, a moving time from one process module to another, and a swapping time; determining, by a processor, one or more algorithms of transient process based on a program evaluation and review technique; computing, by a processor, a time to reach steady state via the algorithms based on the wafer processing time, the wafer loading time, the wafer unloading time, the moving time, and the swapping time; and determining, by a processor, a scheduling strategy given by the algorithm of transient process having a minimal time to reach steady state.
In order to speed up start-up transient processes, the present invention adopts a program evaluation and review technique for the analysis of start-up transient processes and develops optimization algorithms for their scheduling for dual-arm cluster tools.
Embodiments of the present invention are described in more detail hereinafter with reference to the drawings, in which:
In the following description, a method for scheduling dual-armed cluster tools with wafer revisiting process under optimization of start-up transient processes is set forth as preferred examples. It will be apparent to those skilled in the art that modifications, including additions and/or substitutions maybe made without departing from the scope and spirit of the invention. Specific details may be omitted so as not to obscure the invention; however, the disclosure is written to enable one skilled in the art to practice the teachings herein without undue experimentation.
The trends of increasing wafer diameter and smaller lot sizes have led to more transient periods in wafer fabrication. For some wafer fabrication processes, such as atomic layer deposition (ALD), wafers need to visit some process modules for a number of times, instead of once, thus leading to a so-called revisiting process. Most previous studies on cluster tool scheduling focus on steady periodic cycle, in which cluster tools repeat identical cycles. Research on transient processes of dual-arm cluster tools with wafer revisiting processes becomes urgently needed for high-performance wafer fabrication. In order to speed up start-up transient processes, the present invention adopts a program evaluation and review technique for the analysis of start-up transient processes and develops optimization algorithms for their scheduling for dual-arm cluster tools. Then, their complexity is analyzed. Finally, illustrative examples are given to show the applications of the proposed method.
Section A briefly introduces the processes and one-wafer scheduling method. Section B develops start-up transient process scheduling and optimization algorithms. Section C presents illustrative examples.
A.1 Atomic Layer Deposition Process
As for wafer fabrication, there are many operations for processing a wafer. If some operations require the same fabrication process as it visits its prior steps [Chan et al., 2011], it is called revisiting. If every operation of a wafer needs different fabrication processes, it is called non-revisiting. A revisiting process may contain only one step or more. A two-step revisiting process is typical and thus considered as an example in the present invention. For an ALD process, the thickness of the deposition layer is determined by the number of revisiting times. In an ALD process, there are three steps, and a wafer visits Step 1 once, and then Steps 2 and 3 for k≧2 times as shown in
A.2 Activity Description
There are several processing steps in a cluster tool for wafer fabrication. LLs can also be seen as a wafer processing step. Hence, one treats LLs as Step 0. According to [Shin et al., 2001], in operation of a cluster tool, PM activities follow the robot tasks. Thus, it is critically important to schedule robot activities. They include unloading a wafer from a PM, moving from a PM to another with a wafer carried, loading a wafer into a PM, moving from a PM to another without carrying a wafer, and waiting. The key in operating a cluster tool is to schedule the robot activities given the tool's status and process requirements. One uses ui and li to denote the robot unloading and loading a wafer from Pi, iεN3={1, 2, 3}, respectively. As mentioned in Background, a swap strategy is efficient for scheduling dual-arm cluster tools. A swap operation at PMi is executed as follows: the robot holds a wafer in one arm→unloads a processed wafer from a PMi by the other arm→the robot rotates→loads a raw wafer into PMi. In this way, a swap operation at PMi is completed. It follows from this process that li and ui together with a rotation form a swap operation at Step i, iεN3, and one uses si to denote it. One uses mij to denote the robot moving from Steps i to j. In the present invention, Steps 2 and 3 together form a revisiting process step. Therefore, m32 represents the robot moving from Steps 3 to 2.
For the purpose of scheduling, the temporal characterization for each activity is necessary. The time for the robot to unload a wafer is denoted as α. Similarly, the time for the robot to load a wafer to a PM and move from a PM to another are denoted as β and μ, respectively. They are listed in Table 2.1. Although a swap operation includes unloading and loading a wafer, the time of a swap operation is not simply their sum. One uses λ to denote the time. Besides the robot activities, one uses ai to denote the wafer processing time at Step i, iεN3.
A.3. One Wafer Scheduling Strategy
One first presents how to obtain an optimal periodic schedule for the k=2 case. One defines mij for the robot moving from PMi to PMj. l0 and u0 are defined to load a wafer to LL and unload a wafer from LL for the robot, respectively. If the robot executes tasks in the revisiting process (PM2, PM3)2 with a sequence σ1=swapping at PM3→m32→swapping at PM2→m23
that forms a cycle, one calls it a local cycle. If a robot executes tasks with a sequence σ2=
swapping at PM3→m30→l0→u0→m01→swapping at PM1→m12→swapping at PM2→m23
that forms a cycle involving all PMs once, one calls it a global cycle. One-wafer schedule should contain one local and one global cycle as shown in
swapping at PM1→m12→swapping at PM2→m23
, the system state becomes Mi+1={W4(1), W3(2), W2(3), R3(W1(5))}. By executing σ1, it becomes Mi+2={W4(1), W2(4), W1(5), R3(W3(3))}. Finally, by executing σ4=
swapping at PM3→m30→l0→u0→m01
, Mi+3={W4(1), W2(4), W3(3), R1(W5(1))} is obtained. One can find that σ3 and σ4 together form a global cycle. In the meantime, Mi and Mi+3 are equivalent. Therefore, a period including a local and a global cycle is formed. During this period, one wafer is unloaded from LL, while another is completed and returns to LL.
Next, one analyzes how the system can optimally enter the first desired steady state from the initial state.
Qiao et al. [2013] show that a one-wafer cyclic schedule is optimal for a dual-arm cluster tool with wafer revisiting in terms of cycle time. The first desired state Mi={W3(1), W1(4), W2(3), R1(W4(1))} in such a cyclic schedule. Thus, the question to be answered is how to reach it from initial state M0={Θ, Θ, Θ, R0(Θ)} in the fastest way, where Θ means the robot arm is empty and ready for unloading a wafer from LL. To do so, one develops the following method.
Let ωif denote waiting time for the robot to unload a wafer from a PMi during the period from states Mj-1 to Mj, j>0. At the initial state, there are no wafers being processed in PMs. Then, to reach M1={W1(1), Θ, Θ, R1(Θ)}, the robot performs a sequence unloading a wafer W1 from LL (u0), moving to PM1 (m01), and loading the wafer to PM1 (l1)
. To reach M2={W2(1), W1(2), Θ, R2(Θ)}, it performs
moving to LL (m10), unloading a wafer W2 from LL (u0), moving to PM1 (m01), waiting at PM1 (ω12), swapping at PM1, moving to PM2 (m12), and loading wafer W1 to PM2 (l2)
. To reach M3={W3(1), W2(2), W1(3), R3(Θ)}, the robot performs
moving to LL (m20), unloading the wafer W3 from LL (u0), moving to PM1 (m01), waiting at PM1 (ω13), swapping at PM1, moving to PM2 (m12), waiting at PM2 (ω23), swapping at PM2, moving to PM3 (m23), and loading the wafer W1 into PM3 (l3)
. Based on the above robot task sequence, one can obtain a program evaluation and review technique (PERT) chart shown in
To promptly reach the first desired steady state, according to the process time difference between PM2 and PM3, there are two cases. For Case 1, the system evolves as shown in
To reach M41={W3(1), W1(4), W2(3), R3(Θ)} at Node 9, the robot performs staying at PM3 (ω34), unloading wafer W1(3) from PM3 (u3), moving to PM2 (m32), waiting at PM2 (ω24), swapping at PM2, moving to PM3 (m23), and loading wafer W2(3) into PM3 (l3)
;
To reach M51={W3(1), W1(4), W2(3), R1(W4(1))} at Node 5F, the robot performs moving to LL (m30), unloading wafer W4(1) from LL (u0), moving to PM1 (m01), and waiting at PM1 (ω15)
;
To reach M61={W4(1), W3(2), W2(3), R3(W1(5))} at Node 9F, the robot performs swapping at PM1, moving to PM2 (m12), waiting at PM2 (ω26), swapping at PM2, moves to PM3 (m23), and waiting at PM3 (ω36)
;
To reach M71={W4(1), W2(4), W1(5), R3(W3(3))} at Node 11F, the robot performs swapping at PM3, moving to PM2 (m32), waiting at PM2 (ω27), swapping at PM2, moving to PM3 (m23), and waiting at PM3 (ω37)
;
To reach M81={W4(1), W2(4), W3(3), R1(W5(1))} at Node 12, the robot performs swapping at PM3, moving to LL (m30), loading wafer W1 to LL (l0), unloading wafer W5 from LL (u0), moving to PM1 (m01), and waiting at PM1 (ω18)
.
For Case 2, the system evolves as shown in
To reach M42={W3(1), W1(4), W2(3), R2(Θ)} at Node 9, the robot performs moving to PM2 (m32), waiting at PM2 (ω24), unloading wafer W2 from PM2 (u2), moving to PM3 (m23), waiting at PM3 (ω34), swapping at PM3, moving to PM2 (m32), and loading wafer W1 to PM2 (l2)
;
To reach M52={W3(1), W1(4), W2(3), R1(W4(1))} at Node 5F, the robot performs moving to LL (m20), unloading wafer W4 from LL (u0), moving to PM1 (m01), and waiting at PM1 (ω15)
;
To reach M62={W4(1), W3(2), W2(3), R3(W1(5))} at Node 8F, the robot performs swapping at PM1, moving to PM2 (m12), waiting at PM2 (ω26), swapping at PM2, moving to PM3 (m23), and waiting at PM3 (ω36)
;
To reach M72={W4(1), W2(4), W1(5), R3(W3(3))} at Node 11F, the robot performs swapping at PM3, moving to PM2 (m32), waiting at PM2 (ω27), swapping at PM2, moving to PM3 (m23), and waiting at PM3 (ω37)
;
To reach M82={W4(1), W2(4), W3(3), R1(W5(1))} at Node 12, the robot performs swapping at PM3, moving to LL (m30), loading wafer W1 to LL (l0), unloading wafer W5 from LL (u0), moving to PM1 (m01), and waiting at PM1 (ω18)
.
Let Γk denote the time from an initial state at Node 1 to a terminal state at Node k. Thus, to obtain the shortest feasible path Γk, the key is to search a critical path in the PERT charts shown in
Algorithm 1: If a dual-arm cluster tool with wafer revisiting operates as shown in
At the initial state, the cluster tool is empty. Then, one shows how Algorithm 1 is obtained. From the PERT chart in
To reach the state at Node 2 from Node 1 takes Γ2=α+μ+β time units at least.
To reach Node 2F from Node 2, there are two sequences of operations that must be finished. One takes a1 time units to finish the process, and the other takes 2μ+α time units to finish transportation. Hence, the time needed to reach Node 2F is max{a1, (2μ+α)} and Statement 2 holds.
To reach Node 3 takes at least Γ2F+λ time units and Statements 3 holds.
To reach Node 4 takes Γ3+μ+β time units and Statement 4 hold.
To reach Node 3F, there are two sequences to complete. One takes Γ3+a1 time units to finish the process from Node 3, and the other takes Γ4+2μ+α time units to finish transportation. Hence, the time needed to reach Node 3F is max{(Γ3+a1), (Γ4+2μ+α)} and Statement 5 holds.
To reach Node 5 takes at least Γ3F+λ time units. Thus, Statement 6 holds.
To reach Node 4F, it has two sequences to complete. One takes Γ4+a2 time units to finish the process from Node 4, and the other takes Γ3F+λ+μ time units to finish transportation. Hence, the time needed to reach Node 4F is max{(Γ3+a1), (Γ4+2μ+α)} and Statement 7 holds.
To reach Nodes 6, 7, and 7F takes at least Γ4F+λ, Γ6+μ+β and Γ7+a3 time units, respectively. Thus, Statements 8-10 hold.
To reach Node 6F, it has two sequences to complete. One takes Γ7F+α+μ time units to finish transportation, and the other takes Γ6+a2 time units to finish the process. Hence, the time needed to reach Node 6F is max {(Γ7F+α+μ), (Γ6+a2)} and Statement 11 holds.
To reach Nodes 8 and 9 takes σ6F+λ and Γ8+μ+β time units, respectively. Thus, Statements 12 and 13 hold.
To reach Node 5F, it has two sequences to complete. One takes Γ9+2μ+α time units to finish transportation, and the other takes Γ5+a1 time units to finish the process from Node 5. Hence, the time needed to reach Node 5F is max{(Γ9+2μ+α), (Γ5+a1)} time units and Statement 14 holds.
To reach Node 8F, it has two sequences to complete. One takes Γ5F+μ+λ time units to finish transportation, and the other takes Γ8+a2 time units to finish the process from Node 8. Hence, the time needed to reach Node 8F is max {(Γ5F+μ+λ), (Γ8+a2)} time units and Statement 15 holds.
To reach Node 10 takes at least Γ8F+λ time units and Statement 16 holds.
To reach Node 9F, it has two sequences to complete. One takes Γ10+μ time units to finish transportation, and the other takes Γ9+a3 time units to finish the process. Hence, the time needed to reach Node 9F is max{(Γ10+μ), (Γ9+a3)} time units and Statement 17 holds.
To reach Node 11 takes at least Γ9F+λ time units and Statement 18 holds.
To reach Node 10F, it has two sequences to complete. One takes Γ11+μ time units to finish transportation, and the other takes Γ10+a2 time units to finish the process from Node 10. Hence, the time needed to reach Node 10F is max{(Γ11+μ), (Γ10+a2)} time units and Statement 19 holds.
To reach Node 11F, it has two sequences to complete. One takes Γ10F+λ+μ time units to finish transportation, and the other takes Γ11+a3 time units to finish the process from Node 11. Hence, the time from Nodes 11 to 11F is max{(Γ10F+λ+μ), (Γ11+a3)} time units and Statement 20 holds.
To reach Node 12, one sequence takes (Γ11F+λ+2μ+α+β) time units to finish transportation, and the other takes (Γ5F+λ+a1) time units to finish the process. Hence, the time needed to reach Node 12 is max{(Γ5F+λ+a1), (Γ11F+λ+2μ+α+β)} time units and Statement 21 holds.
To reach Node 13 takes Γ12+λ time units.
A critical path from Node 1 to Node 13 could be found by Algorithm 1. So for Case 1, the time Γ13 is shortest time by Algorithm 1 for a dual-cluster tool to reach the first desired steady state from the initial state.
Algorithm 2: If a dual-arm cluster tool with wafer revisiting operates as shown in
Similar to Algorithm 1, a critical path from Node 1 to Node 13 could be found by Algorithm 2 for Case 2. Thus, Γ13 obtained by Algorithm 2 represents the shortest time for the cluster tool to reach the first desired steady state at Node 13 from the initial state.
Up to now, one knows that the transient process obtained by Algorithms 1 and 2 from the initial state to the state at Node 13 is the shortest time for Cases 1 and 2, respectively. Then, if the cycle time of the cluster tool is a constant and optimal in the following evolutions, by simulation results of Algorithm 1 and 2, one can know that which scheduling method is better than traditional method which adopts the concept of virtual wafers [Wu et al., 2013b]. Observing the processes of M51 to M61 and M52 to M62, M61 to M71 and M62 to M72, and M71 to M81 and M72 to M82, the robot activities for transforming the state from Mi1 to M(i+1)1 are same as the one for Mi2 to M(i+1)2, iε{5, 6, 7}. Thus, one uses Mi to denote states Mi1 and Mi2, iε{5, 6, 7}. Then, after state M8, the following evolutions of the cluster tool is shown.
From M8+3i to M9+3i={W(5+i)(1), W(4+i)(2), W(3+i)(3), R3(W(2+i)(5))}, i≧0, the robot performs a sequence of robot activities: swaps at PM1, moves to PM2 (m12), waits at PM2 (ω29+3i), swaps at PM2, moves to PM3 (m23), and waits at PM3 (ω39+3i)
;
From M9+3i to M10+3i={W(5+i)(1), W(3+i)(4), W(2+i)(5), R3(W(4+i)(3))}, i≧0, the robot performs a sequence of robot activities: swaps at PM3, moves to PM2 (m32), waits at PM2 (ω210+3i), swaps at PM2, moves to PM3 (m23), and waits at PM3 (ω310+3i)
;
From M10+3i to M11+3i={W(5+i)(1), W(3+i)(4), W(4+i)(3), R1(W(6+i)(1))}, i≧0, the robot performs a sequence of robot activities: swaps at PM3, moves to LL (m30), loads W(2+i) into LL (l0), unloads W(6+i) from LL (u0), moves to PM1 (m01), and waits at PM1 (ω111+3i)
.
When a wafer is processed, it is unloaded by the robot. It takes ai time units at Step i to process the wafer and λ time units to swap, iεN3. Let Πi=ai+λ denote the time needed for completing a wafer at Step i, and Πlocal=max{Π2, Π3}. Let φ1 denote the local robot cycle time without considering the robot waiting time. Then φ1=2μ+2λ. Let θij, j>i≧0, denote the robot task sequence which transfers Mi to Mj and Πij denote the time taken by θij. Then, one has the following theorem.
Theorem 1: For a dual-arm cluster tool with wafer revisiting with the start-up transient process scheduled by Algorithms 1 or 2, if Π1≦Πlocal+ψ1, then ω18+3i=0 must hold, i≧0.
Proof: Case 1: The start-up transient process is scheduled by Algorithm 1. Observe the robot task sequence θ1 during the period from M5 to M7, where θ1=swaps at PM2, moves to PM3 (m23), waits at PM3 (ω36), swaps at PM3, moves to PM2 (m32), waits at PM2 (ω27), swaps at PM2, moves to PM3 (m23), and waits at PM3 (ω37)
. The earliest strategy implies that the robot task time taken by θ1 must be greater than Π2+λ+μ or Π3+λ+μ. Therefore, the time needed for θ1 must be greater than Πlocal+λ+μ time units. Thus, the robot task sequence θ58=
swaps at PM1, moves to PM2 (m12), waits at PM2 (ω26), robot task sequence θ1, swaps at PM3, moves to LL (m30), loads W1 into LL (l0), unloads W5 from LL (u0), moves to PM1 (m01), and waits at PM1 (ω18)
must take Πlocal+3λ+4μ+α+β=Πlocal+ψ1 time units at least because θ1 must take Πlocal+λ+μ time units at least. Then, by the assumption of Π1≦Πlocal+ψ1, when the system reaches marking M9 for swapping at p1, ω18=0 must hold. Similarly, one can prove that ω18+3i=0, i≧0.
Case 1: The start-up transient process is scheduled by Algorithm 2. Similar to Case 1, one can have ω18+3i=0, i≧0.
Hence, the conclusion holds.
From Theorem 1, it shows that the time needed for the robot task sequence θ1 must be greater than Πlocal+λ+μ time units. θ1 consists of a local cycle, a swapping operation, and a robot moving activity. Thus, one has that the local cycle takes Πlocal time units at least. With the start-up transient process scheduled by Algorithms 1 or 2, when the system reaches marking M8+3i, the robot would swap at PM1 for unloading a wafer which is completed in PM1. Notice that this wafer has stayed in PM1 for a whole period including a global cycle and a local one. Because the global cycle without the robot waiting time being considered takes ψ1 time units, this wafer must stay in PM1 for Πlocal+ψ1 time units at least. With the assumption of Π1≦Πlocal+ψ1, one can easily know that, when the robot arrives at PM1 for unloading this wafer, it must be completed. Therefore, no waiting is needed before swapping at PM1. Then, based on Theorem 1, one can have the following theorem.
Theorem 2: For a dual-arm cluster tool handling an ALD process, for the following operations of the system after the robot performs all the tasks before Node 13 shown in
Proof: One has the following five situations. Situation 1: Π3≧Π2 and Π3≧ψ1. From the robot task sequence θ(6+3i)(9+3i)=swaps at PM3, moves to PM2 (m32), waits at PM2 (ω27+3i), swaps at PM2, moves to PM3 (m23), waits at PM3 (ω37+3i), swaps at PM3, moves to LL (m30), loads a completed wafer into LL (l0), unloads a row wafer from LL (u0), moves to PM1 (m01), waits at PM1 (ω18+3i), swaps at PM1, moves to PM2 (m12), waits at PM2 (ω29+3i), swaps at PM2, moves to PM3 (m23), and waits at PM3 (ω39+3i)
, i≧0, one has ω37+3i≦Π3−φ1 because Π3≧ψ1>φ1. In θ(6+3i)(9+3i), i≧0, for the robot task sequence θ2=
swaps at PM2, moves to PM3 (m23), waits at PM3 (ω37+3i), swaps at PM3, moves to LL (m30), loads a completed wafer into LL (l0), unloads a raw wafer from LL (u0), moves to PM1 (m01), waits at PM1 (ω18+3i), swaps at PM1, moves to PM2 (m12), waits at PM2 (ω29+3i)
, it takes ψ1+ω37+3i+ω29+3i time units. Thus, if ψ1+ω37+3i≧Π2, one has ω29+3i=0, and otherwise, ω29+3i=Π2−(ψ1+ω37+3i). From θ(7+3i)(9+3i)=
swaps at PM3, moves to LL (m30), loads a completed wafer into LL (l0), unloads a raw wafer from LL (u0), moves to PM1 (m01), waits at PM1 (ω18+3i), swaps at PM1, moves to PM2 (m12), waits at PM2 (ω29+3i), swaps at PM2, moves to PM3 (m23), and waits at PM3 (ω39+3i)
, i≧0, if ω29+3i=0, one has ω29+3i+ω39+3i=Π3−ψ1 because Π3≧ψ1, and if ω29+3i=Π2−(ψ1+ω37+3i)>0, one also has ω29+3i+ω39+3i=Π3−ψ1 because 0<ω29+3i=Π2−(ψ1+ω37+3i)≦Π2−ψ1≦Π3−ψ1. From θ(8+3i)(10+3i)=
swaps at PM1, moves to PM2 (m12), waits at PM2 (ω29+3i), swaps at PM2, moves to PM3 (m23), waits at PM3 (ω39+3i), swaps at PM3, moves to PM2 (m32), waits at PM2 (ω210+3i), swaps at PM2, moves to PM3 (m23), and waits at PM3 (ω310+3i)
, i≧0, one has ω210+3i=max{Π2−φ1−ω39+3i, 0}. If ω210+3i=0, one has ω210+3i+ω310+3i=Π3−φ1. If ω210+3i=Π2−φ1−ω39+3i, one also has ω210+3i+ω310+3i=Π3−φ1 because ω210+3i=Π2−φ1−ω39+3i≦Π2−φ1≦Π3−φ1. Thus, the robot task sequence θ(8+3i)(11+3i), i≧0 takes ψ1+φ1+ω29+3i+ω39+3i+ω210+3i+ω310+3i=ψ1+φ1+Π3−ψ1+Π3−φ1=2Π3 time units.
Situation 2: Π2>Π3 and Π2≧ψ1. Similar to Situation 1, one has ω29+3i+ω39+3i=Π2−ψ1 and ω210+3i+ω310+3i=Π2−φ1. Thus, the robot task sequence θ(8+3i)(11+3i), i≧0, takes ψ1+φ1+ω29+3i+ω39+3i+ω210+3i+ω310+3i=2Π2 time units.
Situation 3: Π3≧Π2 and ψ1>Π3≧φ1. Similar to Situation 1, one has ω29+3i+ω39+3i=0 and ω210+3i+ω310+3i=Π3−φ1. Thus, the robot task sequence θ(8+3i)(11+3i), i≧0, takes ψ1+φ1+ω29+3i+ω39+3i+ω210+3i+ω310+3i=Π3+ψ1 time units.
Situation 4: Π2>Π3 and ψ1>Π2≧φ1. Similar to Situation 1, one has ω29+3i+ω39+3i=0 and ω210+3i+ω310+3i=Π2−φ1. Thus, the robot task sequence θ(8+3i)(11+3i), i≧0, takes ψ1+φ1+ω29+3i+ω39+3i+ω210+3i+ω310+3i=Π2+ψ1 time units.
Situation 5: φ1>Πlocal. One can easily have that ω29+3i+ω39+3i=0 and ω210+3i+ω310+3i=0. Thus, the robot task sequence θ(8+3i)(11+3i), i≧0, takes ψ1+φ1+ω29+3i+ω39+3i+ω210+3i+ω310+3i=ψ1+φ1 time units.
Therefore, the conclusion holds.
By Theorem 2, if Πlocal≧ψ1 or Πlocal≧φ1, the system operates in the process-bound region for the local cycle. Thus, the local cycle takes Πlocal time units. If Πlocal<φ1, the system operates in the transport-bound region for the local cycle. For this situation, the local cycle takes φ1 time units. Then, if Πlocal≧ψ1, the system operates in the process-bound for the global cycle which takes Πlocal time units. If Πlocal<ψ1, the system operates in the transport-bound for the global cycle which takes ψ1 time units. Therefore, expression (1) can hold. The following theorem is for another case.
Theorem 3: For a dual-arm cluster tool handling an ALD process, for the following operations of the system after the robot performs all the tasks before Node 12 (except robot waiting ω18) shown in
Proof: One has two situations only. Situation 1: Π3≧Π2. It follows from Situation 1 in Theorem 2 that one has ω37+3i≦Π3−φ1. Then, in θ(6+3i)(9+3i), i≧0, for the robot task sequence θ3=swaps at PM2, moves to PM3 (m23), waits at PM3 (ω37+3i), swaps at PM3, moves to LL (m30), loads a completed wafer into LL (l0), unloads a raw wafer from LL (u0), moves to PM1 (m01), waits at PM1 (ω18+3i), swaps at PM1, moves to PM2 (m12), waits at PM2 (ω29+3i)
, it takes ψ1+ω37+3i+ω29+3i+ω18+3i time units. Thus if, ψ1+ω37+3i+ω18+3i≧Π2, one has ω29+3i=0, otherwise ω29+3i32 Π2−(ψ1+ω37+3i+ω18+3i). Observing θ(7+3i)(9+3i)=
swaps at PM3, moves to LL (m30), loads a completed wafer into LL (l0), unloads a raw wafer from LL (u0), moves to PM1 (m01), waits at PM1 (ω18+3i), swaps at PM1, moves to PM2 (m12), waits at PM2 (ω29+3i), swaps at PM2, moves to PM3 (m23), and waits at PM3 (ω39+3i)
, i≧0, if ω29+3i=0, one has ω18+3i+ω29+3i+ω39+3i=Π3−ψ1 because of ω18+3i≦Π1−(Πlocal+ψ1) and 2Πlocal≧Π1 leading to ω18+3i+ψ1≦Π1−(Π3+ψ1)+ψ1=Π1−Π3≦Π3. If ω29+3i=Π2−(ψ1+ω37+3i+ω18+3i)>0, one also has ω18+3i+ω29+3i+ω39+3i=Π3−ψ1 because of 0<ω29+3i=Π2−(ψ1+ω37+3i+ω18+3i)≦Π2−ψ1≦Π3−ψ1. Then, based on Situation 1 in Theorem 2, one has ω210+3i+ω310+3i=Π3−φ1. Observing the robot task sequence θ(7+3i)(11+3i), i≧0, one sets a robot task sequence σ8+3i=
waits at PM1 (ω18+3i), swaps at PM1, moves to PM2 (m12), waits at PM2 (ω29+3i), swaps at PM2, moves to PM3 (m23), waits at PM3 (ω39+3i), swaps at PM3, moves to PM2 (m32), waits at PM2 (ω210+3i), swaps at PM2, moves to PM3 (m23), waits at PM3 (ω310+3i), swaps at PM3, moves to LL (m30), loads a completed wafer into LL (l0), unloads a raw wafer from LL (u0), and moves to PM1 (m01)
, i≧0. Thus, the robot task sequence σ8+3i takes ψ1+φ1+ω18+3i+ω29+3i+ω39+3i+ω210+3i+ω310+3i=ψ1+φ1+Π3−ψ1+Π3−φ1=2Π3 time units.
Situation 2: Π2>Π3. Similar to Situation 1, one has ω18+3i+ω29+3i+ω39+3i=Π2−ψ1 and ω210+3i+ω310+3i=Π2−φ1. Thus, the robot task sequence σ8+3i, i≧0, takes ψ1+φ1+ω18+3i+ω29+3i+ω39+3i+ω210+3i+ω310+3i=2Π3 time units.
Therefore, the conclusion holds.
For this case, since Πlocal≧ψ1, one has that the system operates in the process-bound region for both the local and global cycles. With the assumption that 2Πlocal≧Π1, the local and global cycles take 2Πlocal time units. However, if Π1>2Πlocal and Πlocal≧ψ1, one has the following result.
Theorem 4: For a dual-arm cluster tool for an ALD process, for the following operations of the system after the robot performs all the tasks before Node 13 shown in
Proof: It is assumed that a robot task sequence θ(8+3i)(11+3i), i≧0, takes η1 time units and η1<Π1 holds. However, during the period of M8+3i to M11+3i, i≧0, there is a wafer staying at PM1. After performing θ(8+3i)(11+3i), the robot needs to swap at PM1 for unloading the wafer. With the assumption of η1<Π1, if the robot unloads the wafer, this wafer must be not completed. Therefore, one has η1≧Π1.
It is assumed that there exists a robot task sequence θ(8+3i)(11+3i) which takes η1 time units and η1>Π1 holds. With the earliest strategy, ω18+3i=0 because that, if ω18+3i>0, the wafer staying at PM1 during θ(8+3i)(11+3i) must just be completed such that θ(8+3i)(11+3i) takes Π1 time units leading to a conflict with the assumption of η1>Π1. Then, there are two situations only.
Situation 1: Π3≧Π2. In θ(8+3i)(10+3i), there is a robot task sequence θ4=swaps at PM2, moves to PM3 (m23), waits at PM3 (ω39+3i), swaps at PM3, moves to PM2 (m32), waits at PM2 (ω210+3i), swaps at PM2, moves to PM3 (m23), and waits at PM3 (ω310+3i)
. If ω39+3i=0, with the earliest strategy, one has ω210+3i=max{Π2−φ1, 0} holds. This means that 0≦ω310+3i=Π3−φ1−ω210+3i holds because of Π3−φ1≧max{Π2−φ1, 0}. Therefore, θ4 takes Π3+λ+μ+ω39+3i time units, where ω39+3i=0. If ω39+3i>0, with the earliest strategy, one has ω210+3i<max{Π2−φ1, 0} holds. This means that 0≦ω310+3i=Π3−φ1−ω210+3i holds because of Π3−φ1≧max{Π2−φ1, 0}. Therefore, θ4 takes Π3+λ+μ+ω39+3i time units, where ω39+3i>0. Thus, one has that the robot task sequence θ(8+3i)(11+3i) takes η1=5λ+6μ+α+β+ω29+3i+ω39+3i+ω210+3i+ω310+3i+ω111+3i=Π3+ψ1+ω29+3i+ω39+3i time units. With the assumption of η1>Π1, one has ω29+3i+ω39+3i>0 because of Π3+ψ1<Π1. If ω39+3i>0, with the earliest strategy and the robot task sequence θ(7+3i)(9+3i), it means that ω29+3i+ω39+3i≦Π3−ψ1. This makes that η1=Π3+ψ1+ω29+3i+ω39+3i≦2Π3<Π1 which leads a conflict with the assumption of η1>Π1. If ω39+3i=0 and ω29+3i>0, with the earliest strategy and the robot task sequence θ(6+3i)(9+3i), it means that ω29+3i≦Π2−ψ1 and Π2>ψ1 must hold. At this time, η1=Π3+ψ1+ω29+3i+ω39+3i≦Π3+Π2≦2Π3<Π1 which leads a conflict with the assumption of η1>Π1. Therefore, one has η1≦Π1 should hold. From above analysis, one knows that η1≧Π1 should hold. Thus, η1=Π1 holds.
Situation 2: Π3<Π2. Similar to Situation 1, one can easily have η1=Π1.
Hence, the conclusion holds.
It is known that the wafer in PM1 should stay for a whole period including a local cycle and a global one. Since Π1>2Πlocal, the wafer in PM1 should stay for Π1 time units at least. Therefore, the whole period takes Π1 time units, or Theorem 4 holds. When Π1>Πlocal+ψ1 and Πlocal<ψ1, one has the following theorem.
Theorem 5: For a dual-arm cluster tool handling an ALD process, for the following operations of the system after the robot performs all the tasks before Node 13 shown in
Proof: By Πlocal<ψ1, one can easily have ω29+3i+ω39+3i=0, i≧0. Then, based on theorems 1-3, one has ω210+3i+ω310+3i=Πlocal−φ1, i≧0. Thus, for the robot task sequence θ(8+3i)(11+3i), i≧0, it takes ψ1+φ1+ω29+3iω39+3i+ω210+3i+ω310+3iω111+3i=ψ1+φ1+Πlocal−φ1+ω111+3i=ψ1+Πlocal+ω111+3i. Because of Π1>Πlocal+ψ1, one has ω111+3i=Π1−(Πlocal+ψ1) time units. This implies that the robot task sequence θ(8+3i)(11+3i) takes Π1 time units. Therefore, the theorem holds.
In this case, the local cycle takes Πlocal time units. With Πlocal<ψ1, the global cycle takes ψ1 time units at least. Due to Π1>Πlocal+ψ1, one has that the whole period including a local and a global cycle must take Π1 time units. Hence, Theorem 5 holds. When Π1>Πlocal+ψ1 and Πlocal<φ1, there are two cases. Case 1: Π1>φ1+ψ1; Case 2: Π1≦φ1+ψ1. For these two cases, based on Theorem 5, one can easily have the following corollary.
Corollary 1: For a dual-arm cluster tool handling an ALD process, for the following operations of the system after the robot performs all the tasks before Node 13 shown in
From Theorems 2, 4, and 5 and Corollary 1, one knows that, for a dual-arm cluster tool handling an ALD process, for the following operations of the system after the robot performs all the tasks before Node 13 shown in
For the ALD case, when a wafer revisits a step it requires exactly the same processing environment as it visits in its prior step. Thus, there is only one PM for each step. The results obtained in this present invention are based on the wafer flow pattern (PM1, (PM2, PM3)2). However, the proposed method can be applied to cases of parallel PMs with some adjustments. First, one need find a one-wafer cyclic schedule to schedule the tool. As it is pointed out in [Qiao et al., 2013], at each state, the process progress of wafers is different. Hence, for such cases, one can adjust these states in a similar way as ones for the wafer flow pattern (PM1, (PM2, PM3)2) such that this requirement can be met when there are parallel PMs. After a one-wafer schedule is obtained, the algorithms similar to Algorithms 1 and 2 can be developed. In this way, the results in the present invention can be extended to cases including parallel PMs in a step.
The wafer processing time at Steps 1-3 is a1=80 s, a2=35 s, and a3=85 s, respectively, loading and unloading time from LL is α=β=4 s, moving time from one PM to another is μ=3 s, and swapping time is λ=8 s.
If one adopts the existing scheduling method [Qiao et al., 2013], one knows the time to reach the steady state is 586 s by simulation. However, if a2≦115 s, one finds that the result obtained by Algorithm 1 is better than that obtained by Algorithm 2 and its use leads to 491 s to reach the steady state. This is 16.2% reduction. If a2>115 s, the result obtained by Algorithm 2 is better than that obtained by Algorithm 1 and its use yields 612 s while the existing one needs 759 s. The time to reach the steady state is 612 s. This is 19.4% reduction. One can vary certain process time and examine how it impacts the time to reach the first desired steady state. Let A, B and C denote the time to reach the first desired steady state by Algorithm 1, Algorithm 2 and existing method, respectively. The horizontal and vertical axes denote the number of wafer and steady state time, respectively. The line of rhombus, circle, square and triangle denote the time a2, A (Algorithm 1), B (Algorithm 2) and C (existing method), respectively, as shown in
The wafer processing time at Steps 1-3 is a1=80 s, a2=85 s, and a3=35 s, respectively, loading and unloading time from LL is α=β=4 s, moving time from one PM to another is μ=3 s, and swapping time is λ=8 s.
According to [Qiao et al., 2013], the time to reach the steady state is 586 s by simulation. If a2≦90 s, one find that the result obtained by Algorithm 1 is better than that obtained by Algorithm 2 and its use leads to 491 s to reach the steady state. This is 16.2% reduction. If a2>90 s, the result obtained by Algorithm 2 is better than that obtained by Algorithm 1 and its use yields 512 s while the existing one needs 635 s. The time to reach the steady state is 512 s. This is 19.4% reduction. By varying certain process time one can examine how it impacts the time to reach the desired first steady state. As shown in
The industrial trend toward smaller wafer lot size and more variety of wafers tends to lead more and more frequent transient periods of cluster tools. Thus the research on transient processes becomes more important. Because a cluster tool has no buffer, scheduling and control become complex. Revisiting processes in wafer fabrication processes, e.g., an atomic layer deposition process, make such scheduling even more complex. Most previous researches focused on the steady state scheduling. Optimizing a schedule for start-up transient processes for dual-arm cluster tools is seriously lacking. The present invention presents the algorithms of the shortest time from an initial state to the first desired steady state and proves their effectiveness. Very significant reduction in time to reach the steady state is obtained in comparison with the existing method. Furthermore, when processing time fluctuates, one can observe the evolution of a transient process and how the desired steady state is reached, therefore enabling engineers to focus some critical processes for further improvement of the entire wafer fabrication process.
The embodiments disclosed herein may be implemented using general purpose or specialized computing devices, computer processors, or electronic circuitries including but not limited to digital signal processors (DSP), application specific integrated circuits (ASIC), field programmable gate arrays (FPGA), and other programmable logic devices configured or programmed according to the teachings of the present disclosure. Computer instructions or software codes running in the general purpose or specialized computing devices, computer processors, or programmable logic devices can readily be prepared by practitioners skilled in the software or electronic art based on the teachings of the present disclosure.
In some embodiments, the present invention includes computer storage media having computer instructions or software codes stored therein which can be used to program computers or microprocessors to perform any of the processes of the present invention. The storage media can include, but is not limited to, floppy disks, optical discs, Blu-ray Disc, DVD, CD-ROMs, and magneto-optical disks, ROMs, RAMs, flash memory devices, or any type of media or devices suitable for storing instructions, codes, and/or data.
The present invention may be embodied in other specific forms without departing from the spirit or essential characteristics thereof. The present embodiment is therefore to be considered in all respects as illustrative and not restrictive. The scope of the invention is indicated by the appended claims rather than by the foregoing description, and all changes that come within the meaning and range of equivalency of the claims are therefore intended to be embraced therein.
This application claims priority under 35 U.S.C. §119 to the U.S. Provisional Patent Application No. 62/102,111 filed Jan. 12, 2015, the disclosure of which is incorporated herein by reference in its entirety.
| Number | Name | Date | Kind |
|---|---|---|---|
| 6418350 | Hamidzadeh | Jul 2002 | B1 |
| 7451011 | Funk | Nov 2008 | B2 |
| 20040078109 | Babikian | Apr 2004 | A1 |
| 20110180148 | Xia | Jul 2011 | A1 |
| Entry |
|---|
| Petri Net-based scheduling analysis of dual-arm cluseter tools with wafer revisiting by Qiao et al. dated Aug. 20-24, 2012. |
| Petri Net-based cycle time analyis of dual-arm cluster tools with wafer revisiting and swapping strategy, by Wu et al. dated May 9-13, 2011. |
| Petri Net-based scheduling analysis of dual-arm cluseter tools subject to wafer revisiting and residency time constraints by Qiao et al. dated Apr. 10-12, 2013. |
| Scheduling and Analysis of Start-Up Transient Processes for Dual-Arm Cluster Tools With Wafer Revisiting by Pan et al. dated Jan. 12, 2015. |
| Number | Date | Country | |
|---|---|---|---|
| 62102111 | Jan 2015 | US |
