 K singlecluster tools denoted as C_{i}, i=1, 2, . . . , K, the singlecluster tool C_{i }having a robot R_{i }for wafer handling, the multicluster tool being decomposable into a plurality of clustertoolchains (CTCs) each having a serial topology, an individual CTC consisting of singlecluster tools C_{i}, C_{i+1}, . . . C_{i′} being denoted as CTC[i, i′], processing steps performed by C_{i }being indexed from 0 to n[i], a first processing step of C_{i }having an index 0 and being a step of loading a wafer from a loadlock or a buffer module of C_{i }to R_{i}, the method comprising: determining values of ω_{ij}, i=1, 2, . . . , K, and j=0, 1, . . . , n[i], wherein ω_{ij }is a robot waiting time for R_{i }to wait at a jth step in C_{i }before unloading the wafer from a process module used for performing the jth step in C_{i}
 for any i∈{1, 2, . . . , K} and any j∈{0, 1, . . . , n[i]}, when R_{i }arrives at the process module for the jth step for unloading the wafer therefrom in the jth step performed in C_{i}, waiting, by R_{i}, for the robot waiting time of ω_{ij}
 after the robot waiting time of ω_{ij }expires, unloading, by R_{i}, the wafer from the process module for the jth step
 after the wafer is unloaded from the process module for the jth step, transporting, by R_{i}, the wafer to the process module for a next step that is either a (j+1)th step, or a zeroth step when j=n[i]
 and after the wafer arrives at the process module for the next step, loading, by R_{i}, the wafer to the second process module
 wherein the determining of ω_{ij}, i=1, 2, . . . , K, and j=0, 1, . . . , n[i], comprises: determining candidate values of ω_{ij }for the singlecluster tools in an individual CTC by performing a CTCCheck algorithm under a constraint that Θ is equal to a lower bound of cycle time of the multicluster tool, the lower bound of cycle time of the multicluster tool being a fundamental period of a bottleneck tool among the K singlecluster tools
 responsive to finding that the candidate ω_{ij }values for the individual CTC are nonnegative, setting the candidate ω_{ij }values as the determined values of ω_{ij }for the individual CTC
 andresponsive to finding that at least one of the candidate ω_{ij }values for the individual CTC is negative, performing: determining a minimum cycle time for the individual CTC
 and determining the values of ω_{ij }for the individual CTC as the candidate values of ω_{ij }obtained by performing the CTCCheck algorithm under a revised constraint that Θ the determined minimum cycle time for the individual CTC
 wherein the CTCCheck algorithm for CTC[f, l] is configured to compute the candidate values of ω_{ij }such that ω_{i(n[i]) }is minimized for each value of i selected from N_{[f, l−1]}, and the CTCCheck algorithm comprises the steps of: setting ω_{ij}=min{Θ−(4λ_{l}+3μ_{l}+α_{l(j+1)}), Θ−2(n[l]+1)(λ_{l}+μ_{l})−Σ_{m∈Ω}_{j}_{\{j}}ω_{lm}}, j∈Ω_{n[l]−1}
 setting ω_{l(n[l])}=Θ−2(n[l]+1)(λ_{l}+μ_{l})−Σ_{m=0}^{n[l]−1}ω_{lm}
 setting τ_{l0}=Θ−φ_{l0}
 andsetting values of ω_{ij}'s, i=l−1 to f, according to: ω_{i(b[i]−1)}=min{τ_{(i+}1)0−(4λ_{i}+3μ_{i}), Θ−2(n[i]+1)(λ_{i}+μ_{i})}
 ω_{ij}=min{Θ−(4λ_{i}+3μ_{i}+α_{i(j+1)}), Θ_{0}−2(n[i]+1)(λ_{i}+μ_{i})−Σ_{m∈Ω}_{j}_{\{j}}ω_{im}} for j∈Ω_{n[i]−1}\{b[i]−1, n[i]}
 ω_{i(n[i])}=Θ−2(n[i]+1)(λ_{i}+μ_{i})−Σ_{m=0}^{n[i]−1}ω_{im}
 and τ_{i0}=Θ−φ_{i0}, where: b[l] is an index denoting a step of putting the wafer in C_{l }to a buffer module shared by C_{l }and C_{l+1}
 θ_{ij}=τ_{ij}+4λ_{i}+3μ_{i}+ω_{i(j−1)}, i∈N_{K }and j∈N_{n[i]}
 θ_{i0}=τ_{i0}+4λ_{i}+3μ_{i}+ω_{i(n[i])}, i∈N_{K}
 Θ is a cycle time of the multicluster tool
 α_{ij }is a time taken in processing the wafer at the jth step in C_{i}
 τ_{ij }is a wafer sojourn time at the jth step in C_{i}
 λ_{i }is a time taken by R_{i }to load or unload a wafer in C_{i}
 μ_{i }is a time taken by R_{i }to move between process modules of C_{i }for transiting from one processing step to another
 N_{L}={1, 2, . . . , L} for a positive integer L
 and Ω_{L}=N_{L}∪{0}.
Optimal onewafer scheduling of singlearm multicluster tools with treelike topology
Updated Time 12 June 2019
Patent Registration DataPublication Number
US10001773
Application Number
US14/918577
Application Date
21 October 2015
Publication Date
19 June 2018
Current Assignee
MACAU UNIVERSITY OF SCIENCE AND TECHNOLOGY
Original Assignee (Applicant)
MACAU UNIVERSITY OF SCIENCE AND TECHNOLOGY
International Classification
G05B19/41,G05B19/418
Cooperative Classification
G05B19/4187,G05B2219/45031,G05B2219/50291,Y02P90/205,Y02P90/26
Inventor
WU, NAIQI,ZHU, QINGHUA,QIAO, YAN,ZHOU, MENGCHU
Patent Images
This patent contains figures and images illustrating the invention and its embodiment.
Abstract
The scheduling problem of a multicluster tool with a tree topology whose bottleneck tool is processbound is investigated. A method for scheduling the multicluster tool to thereby generate an optimal onewafer cyclic schedule for this multicluster tool is provided. A Petri net (PN) model is developed for the multicluster tool by explicitly modeling robot waiting times such that a schedule is determined by setting the robot waiting times. Based on the PN model, sufficient and necessary conditions under which a onewafer cyclic schedule exists are derived and it is shown that an optimal onewafer cyclic schedule can be always found. Then, efficient algorithms are given to find the optimal cycle time and its optimal schedule. Examples are used to demonstrate the scheduling method.
Claims
1. A method for controlling robots of a treelike multicluster tool in wafer processing, the multicluster tool comprising K singlecluster tools denoted as C_{i}, i=1, 2, . . . , K, the singlecluster tool C_{i }having a robot R_{i }for wafer handling, the multicluster tool being decomposable into a plurality of clustertoolchains (CTCs) each having a serial topology, an individual CTC consisting of singlecluster tools C_{i}, C_{i+1}, . . . C_{i′} being denoted as CTC[i, i′], processing steps performed by C_{i }being indexed from 0 to n[i], a first processing step of C_{i }having an index 0 and being a step of loading a wafer from a loadlock or a buffer module of C_{i }to R_{i}, the method comprising: determining values of ω_{ij}, i=1, 2, . . . , K, and j=0, 1, . . . , n[i], wherein ω_{ij }is a robot waiting time for R_{i }to wait at a jth step in C_{i }before unloading the wafer from a process module used for performing the jth step in C_{i}; for any i∈{1, 2, . . . , K} and any j∈{0, 1, . . . , n[i]}, when R_{i }arrives at the process module for the jth step for unloading the wafer therefrom in the jth step performed in C_{i}, waiting, by R_{i}, for the robot waiting time of ω_{ij}; after the robot waiting time of ω_{ij }expires, unloading, by R_{i}, the wafer from the process module for the jth step; after the wafer is unloaded from the process module for the jth step, transporting, by R_{i}, the wafer to the process module for a next step that is either a (j+1)th step, or a zeroth step when j=n[i]; and after the wafer arrives at the process module for the next step, loading, by R_{i}, the wafer to the second process module; wherein the determining of ω_{ij}, i=1, 2, . . . , K, and j=0, 1, . . . , n[i], comprises: determining candidate values of ω_{ij }for the singlecluster tools in an individual CTC by performing a CTCCheck algorithm under a constraint that Θ is equal to a lower bound of cycle time of the multicluster tool, the lower bound of cycle time of the multicluster tool being a fundamental period of a bottleneck tool among the K singlecluster tools; responsive to finding that the candidate ω_{ij }values for the individual CTC are nonnegative, setting the candidate ω_{ij }values as the determined values of ω_{ij }for the individual CTC; andresponsive to finding that at least one of the candidate ω_{ij }values for the individual CTC is negative, performing: determining a minimum cycle time for the individual CTC; and determining the values of ω_{ij }for the individual CTC as the candidate values of ω_{ij }obtained by performing the CTCCheck algorithm under a revised constraint that Θ the determined minimum cycle time for the individual CTC; wherein the CTCCheck algorithm for CTC[f, l] is configured to compute the candidate values of ω_{ij }such that ω_{i(n[i]) }is minimized for each value of i selected from N_{[f, l−1]}, and the CTCCheck algorithm comprises the steps of: setting ω_{ij}=min{Θ−(4λ_{l}+3μ_{l}+α_{l(j+1)}), Θ−2(n[l]+1)(λ_{l}+μ_{l})−Σ_{m∈Ω}_{j}_{\{j}}ω_{lm}}, j∈Ω_{n[l]−1}; setting ω_{l(n[l])}=Θ−2(n[l]+1)(λ_{l}+μ_{l})−Σ_{m=0}^{n[l]−1}ω_{lm}; setting τ_{l0}=Θ−φ_{l0}; andsetting values of ω_{ij}'s, i=l−1 to f, according to:
ω_{i(b[i]−1)}=min{τ_{(i+}1)0−(4λ_{i}+3μ_{i}), Θ−2(n[i]+1)(λ_{i}+μ_{i})};
ω_{ij}=min{Θ−(4λ_{i}+3μ_{i}+α_{i(j+1)}), Θ_{0}−2(n[i]+1)(λ_{i}+μ_{i})−Σ_{m∈Ω}_{j}_{\{j}}ω_{im}} for j∈Ω_{n[i]−1}\{b[i]−1, n[i]};
ω_{i(n[i])}=Θ−2(n[i]+1)(λ_{i}+μ_{i})−Σ_{m=0}^{n[i]−1}ω_{im}; and
τ_{i0}=Θ−φ_{i0}, where: b[l] is an index denoting a step of putting the wafer in C_{l }to a buffer module shared by C_{l }and C_{l+1}; θ_{ij}=τ_{ij}+4λ_{i}+3μ_{i}+ω_{i(j−1)}, i∈N_{K }and j∈N_{n[i]}; θ_{i0}=τ_{i0}+4λ_{i}+3μ_{i}+ω_{i(n[i])}, i∈N_{K}; Θ is a cycle time of the multicluster tool; α_{ij }is a time taken in processing the wafer at the jth step in C_{i}; τ_{ij }is a wafer sojourn time at the jth step in C_{i}; λ_{i }is a time taken by R_{i }to load or unload a wafer in C_{i}; μ_{i }is a time taken by R_{i }to move between process modules of C_{i }for transiting from one processing step to another; N_{L}={1, 2, . . . , L} for a positive integer L; and Ω_{L}=N_{L}∪{0}.
2. The method of claim 1, wherein the robots R_{i}, i=1, 2, . . . , K, are singlearm.
3. A method for controlling robots of a treelike multicluster tool in wafer processing, the multicluster tool comprising K singlecluster tools denoted as C_{i}, i=1, 2, . . . , K, the singlecluster tool C_{i }having a robot R_{i }for wafer handling, the multicluster tool being decomposable into a plurality of clustertoolchains (CTCs) each having a serial topology, an individual CTC consisting of singlecluster tools C_{i}, C_{i+1}, . . . C_{i′} being denoted as CTC[i, i′], processing steps performed by C_{i }being indexed from 0 to n[i], a first processing step of C_{i }having an index 0 and being a step of loading a wafer from a loadlock or a buffer module of C_{i }to R_{i}, the method comprising: determining values of ω_{ij}, i=1, 2, . . . , K, and j=0, 1, . . . , n[i], wherein ω_{ij }is a robot waiting time for R_{i }to wait at a jth step in C_{i }before unloading the wafer from a process module used for performing the jth step in C_{i}; for any i∈{1, 2, . . . , K} and any j∈{0, 1, . . . , n[i]}, when R_{i }arrives at the process module for the jth step for unloading the wafer therefrom in the jth step performed in C_{i}, waiting, by R_{i}, for the robot waiting time of ω_{ij}; after the robot waiting time of ω_{ij }expires, unloading, by R_{i}, the wafer from the process module for the jth step; after the wafer is unloaded from the process module for the jth step, transporting, by R_{i}, the wafer to the process module for a next step that is either a (j+1)th step, or a zeroth step when j=n[i]; and after the wafer arrives at the process module for the next step, loading, by R_{i}, the wafer to the second process module; wherein the determining of ω_{ij}, i=1, 2, . . . , K, and j=0, 1, . . . , n[i], comprises: identifying an LCTC set consisting of first individual CTCs each having a leaf tool therein, whereby one or more second individual CTCs not in the LCTC set are also identified; for each of the first individual CTCs, determining a minimum cycle time and then determining the values of ω_{ij }by performing a CTCCheck algorithm under a constraint that Θ is equal to the determined minimum cycle time; for each second individual CTC, determining candidate values of ω_{ij }for each singlecluster tool therein by performing the CTCCheck algorithm under an initial constraint that Θ is equal to a maximum value of the minimum cycle times already determined for the first individual CTCs; responsive to finding that the candidate ω_{ij }values for the second individual CTC are nonnegative, setting the candidate ω_{ij }values as the determined values of ω_{ij }for the second individual CTC; andresponsive to finding that at least one of the candidate ω_{ij }values for the second individual CTC is negative, performing: determining a minimum cycle time for the second individual CTC; and determining the values of ω_{ij }for the second individual CTC as the candidate values of ω_{ij }obtained by performing the CTCCheck algorithm under a revised constraint that Θ is equal to the determined minimum cycle time for the second individual CTC; wherein the CTCCheck algorithm for CTC[f, l] is configured to compute the candidate values of ω_{ij }such that ω_{i(n[i]) }is minimized for each value of i selected from N_{[f, l−1]}, and the CTCCheck algorithm comprises the steps of: setting ω_{ij}=min{Θ−(4λ_{l}+3μ_{l}+α_{l(j+1)}), Θ−2(n[l]+1)(λ_{l}+μ_{l})−Σ_{m∈Ω}_{j}_{\{j}}ω_{lm}}, j∈Ω_{n[l]−1}; setting ω_{l(n[l])}=Θ−2(n[l]+1)(λ_{l}+μ_{l})−Σ_{m=0}^{n[l]−1}ω_{lm}; setting τ_{l0}=Θ−φ_{l0}; andsetting values of ω_{ij}'s, i=l−1 to f, according to:
ω_{i(b[i]−1)}=min{τ_{(i+1)0}−(4λ_{i}+3μ_{i}), Θ−2(n[i]+1)(λ_{i}+μ_{i})};
ω_{ij}=min{Θ−(4λ_{i}+3μ_{i}+α_{i(j+1)}), Θ_{0}−2(n[i]+1)(λ_{i}+μ_{i})−Σ_{m∈Ω}_{j}_{\{j}}ω_{im}} for j∈Ω_{n[i]−1}\{b[i]−1, n[i]};
ω_{i(n[i])}=Θ−2(n[i]+1)(λ_{i}+μ_{i})−Σ_{m=0}^{n[i]−1}ω_{im}; and
τ_{i0}=Θ−φ_{i0}, where: b[l] is an index denoting a step of putting the wafer in C_{l }to a buffer module shared by C_{l }and C_{l+1}; θ_{ij}=τ_{ij}+4λ_{i}+3μ_{i}+ω_{i(j−1)}, i∈N_{K }and j∈N_{n[i]}; θ_{i0}=τ_{i0}+4λ_{i}+3μ_{i}+ω_{i(n[i])}, i∈N_{K}; Θ is a cycle time of the multicluster tool; α_{ij }is a time taken in processing the wafer at the jth step in C_{i}; τ_{ij }is a wafer sojourn time at the jth step in C_{i}; λ_{i }is a time taken by R_{i }to load or unload a wafer in C_{i}; μ_{i }is a time taken by R_{i }to move between process modules of C_{i }for transiting from one processing step to another; N_{L}={1, 2, . . . , L} for a positive integer L; and Ω_{L}=N_{L}∪{0}.
4. The method of claim 3, wherein the robots R_{i}, i=1, 2, . . . , K, are singlearm.
Claim Tree

11. A method for controlling robots of a treelike multicluster tool in wafer processing, the multicluster tool comprising

2. The method of claim 1, wherein
 the robots R_{i}, i=1, 2, . . . , K, are singlearm.


33. A method for controlling robots of a treelike multicluster tool in wafer processing, the multicluster tool comprising
 K singlecluster tools denoted as C_{i}, i=1, 2, . . . , K, the singlecluster tool C_{i }having a robot R_{i }for wafer handling, the multicluster tool being decomposable into a plurality of clustertoolchains (CTCs) each having a serial topology, an individual CTC consisting of singlecluster tools C_{i}, C_{i+1}, . . . C_{i′} being denoted as CTC[i, i′], processing steps performed by C_{i }being indexed from 0 to n[i], a first processing step of C_{i }having an index 0 and being a step of loading a wafer from a loadlock or a buffer module of C_{i }to R_{i}, the method comprising: determining values of ω_{ij}, i=1, 2, . . . , K, and j=0, 1, . . . , n[i], wherein ω_{ij }is a robot waiting time for R_{i }to wait at a jth step in C_{i }before unloading the wafer from a process module used for performing the jth step in C_{i}
 for any i∈{1, 2, . . . , K} and any j∈{0, 1, . . . , n[i]}, when R_{i }arrives at the process module for the jth step for unloading the wafer therefrom in the jth step performed in C_{i}, waiting, by R_{i}, for the robot waiting time of ω_{ij}
 after the robot waiting time of ω_{ij }expires, unloading, by R_{i}, the wafer from the process module for the jth step
 after the wafer is unloaded from the process module for the jth step, transporting, by R_{i}, the wafer to the process module for a next step that is either a (j+1)th step, or a zeroth step when j=n[i]
 and after the wafer arrives at the process module for the next step, loading, by R_{i}, the wafer to the second process module
 wherein the determining of ω_{ij}, i=1, 2, . . . , K, and j=0, 1, . . . , n[i], comprises: identifying an LCTC set consisting of first individual CTCs each having a leaf tool therein, whereby one or more second individual CTCs not in the LCTC set are also identified
 for each of the first individual CTCs, determining a minimum cycle time and then determining the values of ω_{ij }by performing a CTCCheck algorithm under a constraint that Θ is equal to the determined minimum cycle time
 for each second individual CTC, determining candidate values of ω_{ij }for each singlecluster tool therein by performing the CTCCheck algorithm under an initial constraint that Θ is equal to a maximum value of the minimum cycle times already determined for the first individual CTCs
 responsive to finding that the candidate ω_{ij }values for the second individual CTC are nonnegative, setting the candidate ω_{ij }values as the determined values of ω_{ij }for the second individual CTC
 andresponsive to finding that at least one of the candidate ω_{ij }values for the second individual CTC is negative, performing: determining a minimum cycle time for the second individual CTC
 and determining the values of ω_{ij }for the second individual CTC as the candidate values of ω_{ij }obtained by performing the CTCCheck algorithm under a revised constraint that Θ is equal to the determined minimum cycle time for the second individual CTC
 wherein the CTCCheck algorithm for CTC[f, l] is configured to compute the candidate values of ω_{ij }such that ω_{i(n[i]) }is minimized for each value of i selected from N_{[f, l−1]}, and the CTCCheck algorithm comprises the steps of: setting ω_{ij}=min{Θ−(4λ_{l}+3μ_{l}+α_{l(j+1)}), Θ−2(n[l]+1)(λ_{l}+μ_{l})−Σ_{m∈Ω}_{j}_{\{j}}ω_{lm}}, j∈Ω_{n[l]−1}
 setting ω_{l(n[l])}=Θ−2(n[l]+1)(λ_{l}+μ_{l})−Σ_{m=0}^{n[l]−1}ω_{lm}
 setting τ_{l0}=Θ−φ_{l0}
 andsetting values of ω_{ij}'s, i=l−1 to f, according to: ω_{i(b[i]−1)}=min{τ_{(i+1)0}−(4λ_{i}+3μ_{i}), Θ−2(n[i]+1)(λ_{i}+μ_{i})}
 ω_{ij}=min{Θ−(4λ_{i}+3μ_{i}+α_{i(j+1)}), Θ_{0}−2(n[i]+1)(λ_{i}+μ_{i})−Σ_{m∈Ω}_{j}_{\{j}}ω_{im}} for j∈Ω_{n[i]−1}\{b[i]−1, n[i]}
 ω_{i(n[i])}=Θ−2(n[i]+1)(λ_{i}+μ_{i})−Σ_{m=0}^{n[i]−1}ω_{im}
 and τ_{i0}=Θ−φ_{i0}, where: b[l] is an index denoting a step of putting the wafer in C_{l }to a buffer module shared by C_{l }and C_{l+1}
 θ_{ij}=τ_{ij}+4λ_{i}+3μ_{i}+ω_{i(j−1)}, i∈N_{K }and j∈N_{n[i]}
 θ_{i0}=τ_{i0}+4λ_{i}+3μ_{i}+ω_{i(n[i])}, i∈N_{K}
 Θ is a cycle time of the multicluster tool
 α_{ij }is a time taken in processing the wafer at the jth step in C_{i}
 τ_{ij }is a wafer sojourn time at the jth step in C_{i}
 λ_{i }is a time taken by R_{i }to load or unload a wafer in C_{i}
 μ_{i }is a time taken by R_{i }to move between process modules of C_{i }for transiting from one processing step to another
 N_{L}={1, 2, . . . , L} for a positive integer L
 and Ω_{L}=N_{L}∪{0}.

4. The method of claim 3, wherein
 the robots R_{i}, i=1, 2, . . . , K, are singlearm.
Description
LIST OF ABBREVIATIONS
BM buffer module
CTC clustertoolchain
FP fundamental period
LL loadlock
PM process module
PN Petri net
R robot
ROPN resourceoriented PN
BACKGROUND
Field of the Invention
The present invention generally relates to scheduling a treelike multicluster tool. In particular, the present invention relates to a method for scheduling this multicluster tool to thereby generate an optimal onewafer cyclic schedule.
List of References
There follows a list of references that are occasionally cited in the specification. Each of the disclosures of these references is incorporated by reference herein in its entirety.
 W. K. Chan, J. G. Yi, and S. W. Ding, “Optimal Scheduling of Multicluster Tools with Constant Robot Moving Times, Part I: TwoCluster Analysis,”IEEE Transactions on Automation Science and Engineering, vol. 8, no. 1, pp. 516, 2011a.
 W. K. Chan, J. G. Yi, S. W. Ding, and D. Z. Song, “Optimal Scheduling of Multicluster Tools with Constant Robot Moving Times, Part II: TreeLike Topology Configurations,”IEEE Transactions on Automation Science and Engineering, vol. 8, no. 1, pp. 1728, 2011b.
 T. H. Cormen, C. E. Leiserson, R. L. Rivest, and C. Stein, Introduction to algorithms: MIT press, 2001.
 M. Dawande, C. Sriskandarajah, and S. P. Sethi, “On Throughput Maximization in Constant Traveltime Robotic Cells,”Manufacture Service Operation Manage, vol. 4, no. 4, pp. 296312, 2002.
 S. W. Ding, J. G. Yi, and M. T. Zhang, “Multicluster Tools Scheduling: an Integrated Event Graph and Network Model Approach,”IEEE Transactions on Semiconductor Manufacturing, vol. 19, no. 3, pp. 339351, 2006.
 I. Drobouchevitch, S. P. Sethi, and C. Sriskandarajah, “Scheduling Dual Gripper Robotic Cells: Oneunit Cycles,”European Journal of Operational Research, vol. 171, no. 2, pp. 598631, 2006.
 H. Geismar, C. Sriskandarajah, and N. Ramanan, “Increasing Throughput for Robotic Cells With Parallel Machines and Multiple Robots,”IEEE Transactions on Automation Science and Engineering, vol. 1, no. 1, pp. 8489, 2004.
 J. H. Kim, T. E. Lee, H. Y. Lee, and D. B. Park, “Scheduling analysis of timedconstrained dualarmed cluster tools,”IEEE Transactions on Semiconductor Manufacturing, vol. 16, no. 3, pp. 521534, 2003.
 J. H. Lee, T. E. Lee, “Concurrent processing of multiple wafer types in a singlearmed cluster tool,”IEEE Conference on Automation Science and Engineering, pp. 102107, 2011.
 T. E. Lee, H. Y. Lee, and Y. H. Shin, “Workload balancing and scheduling of a singlearmed cluster tool,” in Proceedings of the 5th APIEMS Conference, Gold Coast, Australia, pp. 115, 2004.
 T. E. Lee and S. H. Park, “An extended event graph with negative places and tokens for timed window constraints,”IEEE Transactions on Automation Science and Engineering, vol. 2, no. 4, pp. 319332, 2005.
 M. J. Lopez and S. C. Wood, “Systems of multiple cluster tools—configuration, reliability, and performance,”IEEE Transactions on Semiconductor Manufacturing, vol. 16, no. 2, pp. 170178, 2003.
 T. Murata, “Petri nets: Properties, analysis and applications,”Proceedings of IEEE, vol. 77, no. 4, pp. 541580, April 1989.
 M. X. Liu and B. H. Zhou, “Modelling and scheduling analysis of multicluster tools with residency constraints based on time constraint sets”. International Journal of Production Research, vol. 51, no. 16, pp. 48354852, 2013.
 T. L. Perkinson, P. K. MacLarty, R. S. Gyurcsik, and R. K. Cavin III, “Singlewafer cluster tool performance: An analysis of throughput,”IEEE Transactions on Semiconductor Manufacturing, vol. 7, no. 3, pp. 369373, 1994.
 T. L. Perkinson, R. S. Gyurcsik, and P. K. MacLarty, “Singlewafer cluster tool performance: An analysis of the effects of redundant chambers and revisitations sequences on throughput,”IEEE Transactions on Semiconductor Manufacturing, vol. 9, no. 3, pp. 384400, 1996.
 Y. Qiao, N. Q. Wu, and M. C. Zhou, “Petri Net Modeling and Wafer Sojourn Time Analysis of SingleArm Cluster Tools With Residency Time Constraints and Activity Time Variation,”IEEE Transactions on Semiconductor Manufacturing, vol. 25, no. 3, pp. 432446, 2012a.
 Y. Qiao, N. Q. Wu, and M. C. Zhou, “RealTime Scheduling of SingleArm Cluster Tools Subject to Residency Time Constraints and Bounded Activity Time Variation,”IEEE Transactions on Automation Science and Engineering, vol. 9, no. 3, pp. 564577, 2012b.
 Y. Qiao, N. Q. Wu, and M. C. Zhou, “A Petri netbased Novel Scheduling Approach and Its Cycle Time Analysis for DualArm Cluster Tools with Wafer Revisiting,”IEEE Transactions on Semiconductor Manufacturing, vol. 26, no. 1, pp. 100110, 2013.
 S. Rostami, B. Hamidzadeh, and D. Camporese, “An optimal periodic scheduler for dualarm robots in cluster tools with residency constraints,”IEEE Transactions on Robotics and Automation, vol. 17, no. 5, pp. 609618, 2001.
 S. Venkatesh, R. Davenport, P. Foxhoven, and J. Nulman, “A steady state throughput analysis of cluster tools: Dualblade versus singleblade robots,”IEEE Transactions on Semiconductor Manufacturing, vol. 10, no. 4, pp. 418424, 1997.
 N. Q. Wu, “Necessary and Sufficient Conditions for Deadlockfree Operation in Flexible Manufacturing Systems Using a Colored Petri Net Model,”IEEE Transaction on Systems, Man, and Cybernetics, Part C, vol. 29, no. 2, pp. 192204, 1999.
 N. Q. Wu, C. B. Chu, F. Chu, and M. C. Zhou, “A Petri net method for schedulability and scheduling problems in singlearm cluster tools with wafer residency time constraints,”IEEE Transactions on Semiconductor Manufacturing, vol. 21, no. 2, pp. 224237, 2008.
 N. Q. Wu, F. Chu, C. B. Chu, and M. C. Zhou, “Petri net modeling and cycle time analysis of dualarm cluster tools with wafer revisiting,”IEEE Transactions on Systems, Man, &Cybernetics: Systems, vol. 43, no. 1, pp. 196207, 2013a.
 N. Q. Wu, F. Chu, C. Chu, and M. Zhou, “Petri NetBased Scheduling of SingleArm Cluster Tools With Reentrant Atomic Layer Deposition Processes,”IEEE Transactions on Automation Science and Engineering, vol. 8, no. 1, pp. 4255, 2011.
 N. Q. Wu, F. Chu, C. B. Chu, and M. C. Zhou, “Petri net modeling and cycle time analysis of dualarm cluster tools with wafer revisiting,”IEEE Transactions on Systems, Man, &Cybernetics: Systems, vol. 43, no. 1, pp. 196207, 2013b.
 N. Q. Wu and M. C. Zhou, “Avoiding deadlock and reducing starvation and blocking in automated manufacturing systems based on a Petri net model,”IEEE Transactions on Robotics and Automation, vol. 17, no. 5, 658669, 2001.
 N. Q. Wu and M. C. Zhou, “Modeling and deadlock control of automated guided vehicle systems,”IEEE/ASME Transactions on Mechatronics, vol. 9, no. 1, pp. 5057, 2004.
 N. Q. Wu and M. C. Zhou, System modeling and control with resourceoriented Petri nets, CRC Press, Taylor & Francis Group, New York, October 2009.
 N. Q. Wu and M. Zhou, “Analysis of wafer sojourn time in dualarm cluster tools with residency time constraint and activity time variation,”IEEE Transactions on Semiconductor Manufacturing, vol. 23, no. 1, pp. 5364, 2010a.
 N. Q. Wu and M. C. Zhou, “A closedform solution for schedulability and optimal scheduling of dualarm cluster tools based on steady schedule analysis,”IEEE Transactions on Automation Science and Engineering, vol. 7, no. 2, pp. 303315, 2010b.
 N. Q. Wu and M. C. Zhou, “Modeling, analysis and control of dualarm cluster tools with residency time constraint and activity time variation based on Petri nets,”IEEE Transactions on Automation Science and Engineering, vol. 9, no. 2, 446454, 2012a.
 N. Q. Wu and M. C. Zhou, “Schedulability analysis and optimal scheduling of dualarm cluster tools with residency time constraint and activity time variation,”IEEE Transactions on Automation Science and Engineering, vol. 9, no. 1, pp. 203209, 2012b.
 N. Q. Wu, M. C. Zhou, F. Chu, and C. B. Chu, “A Petrinetbased scheduling strategy for dualarm cluster tools with wafer revisiting,”IEEE Transactions on Systems, Man, &Cybernetics: Systems, vol. 43, no. 5, pp. 11821194, September 2013b.
 N. Q. Wu, M. C. Zhou, and Z. W. Li, Resourceoriented Petri net for deadlock avoidance in flexible assembly systems, IEEE Transactions on System, Man, &Cybernetics, Part A, vol. 38, no. 1, 5669, 2008b.
 F. J. Yang, N. Q. Wu, Y. Qiao, and M. C. Zhou, Optimal onewafer cyclic scheduling of singlearm multicluster tools with twospace buffering modules, IEEE Transactions on Systems, Man, &Cybernetics: Systems, vol. 44, no. 12, 15841597, 2014.
 J. Yi, S. Ding, and D. Song, “Steadystate throughput and scheduling analysis of multicluster tools for semiconductor manufacturing: A decomposition approach,” in Proceedings of 2005 IEEE International Conference on Robotics and Automation, pp. 292298, 2005.
 J. G. Yi, S. W. Ding, D. Z. Song, and M. T. Zhang, “SteadyState Throughput and Scheduling Analysis of MultiCluster Tools for Semiconductor Manufacturing: A Decomposition Approach,”IEEE Transactions on Automation Science and Engineering, vol. 5, no. 2, pp. 321336, 2008.
 M. C. Zhou and M. D. Jeng, “Modeling, Analysis, Simulation, Scheduling, and Control of Semiconductor Manufacturing Systems: A Petri Net Approach,”IEEE Transactions on Semiconductor Manufacturing, vol. 11, no. 3, pp. 333357, 1998.
 W. M. Zuberek, “Timed Petri nets in modeling and analysis of cluster tools,”IEEE Transactions on Robotics Automation, vol. 17, no. 5, pp. 562575, October 2001.
 Q. H. Zhu, N. Q. Wu, Y. Qiao, and M. C. Zhou, “Scheduling of SingleArm MultiCluster Tools to Achieve the Minimum Cycle Time,” in Proceedings of 2013 IEEE International Conference on Robotics and Automation, Karlsruhe, Germany, pp. 35553560, May 2013a.
 Q. H. Zhu, N. Q. Wu, Y. Qiao, and M. C. Zhou, “Petri NetBased Optimal OneWafer Scheduling of SingleArm MultiCluster Tools in Semiconductor Manufacturing,”IEEE Transactions on Semiconductor Manufacturing, vol. 26, no. 4, pp. 578591, 2013b.
 Q. H. Zhu, N. Q. Wu, Y. Qiao, and M. C. Zhou, “Modeling and Schedulability Analysis of SingleArm MultiCluster Tools with Residency Time Constraints via Petri Nets” in Proc. IEEE Int. Conf. Auto. Sci. Eng., Taipei, Taiwan, pp. 8186, 2014.
 Q. H. Zhu, N. Q. Wu, Y. Qiao, and M. C. Zhou, “Scheduling of SingleArm Multicluster Tools With Wafer Residency Time Constraints in Semiconductor Manufacturing”IEEE Transactions on Semiconductor Manufacturing, vol. 28, no. 1, 2015.
There follows a list of patent(s) and patent application(s) that are occasionally cited in the specification.
 D. Jevtic, “Method and Apparatus for Managing Scheduling a Multiple Cluster Tool,” European Patent Application Publication No. 1,132,792 A2, Sep. 12, 2001.
 D. Jevtic and S. Venkatesh, “Method and Apparatus for Scheduling Wafer Processing within a Multiple Chamber Semiconductor Wafer Processing Tool Having a Multiple Blade Robot,” U.S. Pat. No. 6,224,638 B1, May 1, 2001.
Description of Related Art
With single wafer processing technology, cluster tools are increasingly used in the semiconductor industry. Generally, a singlecluster tool is composed of four to six process modules (PM), one waferdelivering robot (R), and two loadlocks (LL) for cassette loading/unloading. The robot can be single or dualarm one resulting in single or dualarm cluster tools. Several singlecluster tools are connected together by shared buffer modules (BMs) to form a more integrated manufacturing system called a multicluster tool. It has higher performance and becomes more and more popular in the semiconductor industry. However, it is very challenging to effectively operate such a system.
Extensive studies have been done on modeling, performance evaluation, and scheduling for singlecluster tools [Kim et al., 2003; Lee et al., 2004; Lee and Park, 2005; Lopez and Wood, 2003; Wu et al., 2008a; Wu and Zhou, 2010b; Qiao et al., 2012a and 2012b; and Wu et al., 2013a and 2013b]. It is found that a cluster tool may operate in processbound or transportbound region. For a singlecluster tool, if one of its process steps is the bottleneck of the tool in the sense of workload, it is processbound. In this case, the cycle time of the system is determined by the wafer processing time. Otherwise, if the robot is the bottleneck, it is transportbound and the cycle time is determined by the robot task time. In practice, the robot task time is much shorter than the wafer processing time [Kim et al., 2003; and Lopez and Wood, 2003] such that, for a singlearm cluster tool, a backward strategy is shown to be optimal [Lee et al., 2004; Dawande 2002; and Lopez and Wood, 2003]. Some wafer fabrication processes require that a processed wafer should leave a PM within a given time interval, which is called wafer residency time constraints [Kim et al., 2003; Lee and Park, 2005]. Without immediate buffer between the PMs in a tool, this greatly complicates the problem of scheduling singlecluster tools. This problem is studied by using Petri nets and mathematical programming models for dualarm cluster tools to find an optimal periodic schedule in [Kim et al., 2003; Lee and Park, 2005]. It is further studied for both single and dualarm cluster tools in [Wu et al., 2008; Wu and Zhou, 2010b; and Qiao et al., 2012a and 2012b] by developing generic Petri net (PN) models. With these models, robot waiting is explicitly modeled as an event to parameterize a schedule by robot waiting time. Then, to find a schedule is to determine the robot waiting time. With these models, schedulability conditions are presented and closedform scheduling algorithms are given to find an optimal periodic schedule if schedulable.
In recent years, attention has been paid to the problem of scheduling multicluster tools. A multicluster tool composed of K singlecluster tools is called a Kcluster tool. A heuristic method is proposed in [Jevtic, 2001] for it by dynamically assigning priorities to PMs. However, the performance of such a schedule is difficult to evaluate. Geismar et al. examine a serial 3cluster tool composed of singlearm tools and parallel processing modules. By simulation, they find that, for 87% of instances, the backward strategy achieves the lowerbound of cycle time. In [Ding et al., 2006], an event graph model is used to describe the dynamic behavior of the system and a simulationbased search method is proposed to find a periodic schedule.
To reduce the computational complexity, without considering the robot moving time, a decomposition method is proposed in [Yi et al., 2005 and 2008]. By this method, the fundamental period (FP) for each tool is calculated as done for scheduling singlecluster tools. Then, by analyzing time delays resulting from accessing the shared buffers, the global fundamental period, or the cycle time for the system is determined. In this way, a schedule is found.
With robot moving time considered, a polynomial algorithm is presented to find a multiwafer schedule for a serial multicluster tool in [Chan et al., 2011a]. A Kcluster tool is said to be processdominant if its bottleneck tool is processbound. It is known that there is always an optimal onewafer schedule for a processdominant serial multicluster tool [Zhu et al., 2013a, 2012; and Zhu et al., 2013b]. In studying the effect of buffer spaces in BMs on productivity, Yang et al. [2014] show that, for a processdominant serial multicluster tool with twospace BMs, there is a onewafer cyclic schedule such that the lower bound of cycle time is reached. For a singlearm multicluster tool with twospace BMs and wafer residency time constraints, Liu and Zhou [2013] propose a nonlinear programming model and a heuristic algorithm to solve it. For a singlearm multicluster tool with singlespace BMs and wafer residency time constraints, Zhu et al. [2014 and 2015] present sufficient and necessary schedulability conditions and an efficient algorithm to find a onewafer optimal cyclic schedule if schedulable.
Chan et al. [2011b] study the problem of scheduling a treelike multicluster tool, which is the only report on treelike multicluster tool scheduling to our best knowledge. The obtained schedule is a multiwafer cyclic one. It derives conditions under which a treelike multicluster tool can be scheduled by a decomposition method. Further, if decomposable, conditions under which a backward scheduling strategy is optimal are presented.
Since a onewafer cyclic schedule is easy to implement and understand by a practitioner, it gives rise to a question if there exists a onewafer cyclic schedule for a treelike multicluster tool and how such a schedule can be found if it exists. There is a need in the art to derive the conditions for which this schedule exists and to develop a method for scheduling a treelike multicluster tool with a onewafer cyclic schedule.
SUMMARY OF THE INVENTION
An aspect of the present invention is to provide a computerimplemented method for scheduling a treelike multicluster tool to generate a onewafer cyclic schedule. The multicluster tool comprises plural singlecluster tools each having a robot for wafer handling, and is decomposable into a plurality of CTCs each having a serial topology.
The method comprises determining robot waiting times for the robots. In particular, the method makes use of Theorem 1 detailed below to determine the robot waiting times.
Preferably, a CTCCheck algorithm as detailed hereinafter computes candidate values of the robot waiting times for at least one individual CTC. The CTCCheck algorithm is configured to compute these candidate values such that the robot waiting time at a last processing step of each singlecluster tool in the individual CTC apart from the leaf tool therein is minimized.
With the use of the CTCCheck algorithm, the robot waiting times may be determined according to Algorithms 1 and 2 detailed below.
Other aspects of the present invention are disclosed as illustrated by the embodiments hereinafter.
BRIEF DESCRIPTION OF THE DRAWINGS
FIG. 1 depicts an example of a treelike multicluster tool.
FIG. 2 depicts a PN model for an individual cluster tool C_{i }as an illustrative example.
FIG. 3 depicts a PN model for a BM shared by adjacent clusters C_{i }and C_{a }as an illustrative example.
FIG. 4 shows a multicluster tool considered for analysis in Example 1.
DETAILED DESCRIPTION
Since a onewafer cyclic schedule is easy to implement and understand by a practitioner, it gives rise to a question if there exists a onewafer cyclic schedule for a treelike multicluster tool and how such a schedule can be found if it exists. The present work provides a solution of schedulability and a method for scheduling the treelike multicluster tool with the onewafer cyclic schedule. Since the robot task time is much shorter than the wafer processing time in practice [Kim et al., 2003; and Lopez and Wood, 2003], it is reasonable to assume that the bottleneck tool of a multicluster tool is processbound, or it is processdominant. Hence, we address a processdominant treelike multicluster tool in this work. The key for scheduling a Kcluster tool is to coordinate the activities of the multiple robots in accessing the BMs. In scheduling singlecluster tools, Wu et al. [2008] and Wu and Zhou [2010a] find that it is crucial to determine when a robot should wait and how long it should wait if necessary. By following this idea, the present work develops a PN model for a treelike multicluster tool with the robot waiting being explicitly modeled. With the model, a schedule for the system is parameterized by the robot waiting time. For a processdominant treelike multicluster tool, necessary and sufficient conditions under which a onewafer cyclic schedule exists are derived. It is then shown that there is always a onewafer cyclic schedule. An efficient algorithm is developed and disclosed herein to find the minimal cycle time and the onewafer cyclic schedule.
A. System Modeling by Petri Net
A.1. Treelike Multicluster Tool
The configuration of a treelike multicluster tool is illustrated in FIG. 1. A treelike multicluster tool composed of K singlecluster tools is called a Ktreecluster tool. It follows from Chan et al. [2011b] that a Ktreecluster tool can be described as follows. Let N_{K}={1, 2, . . . , K} be the index set of the cluster tools that form a Ktreecluster tool. The tool with the LLs in it is called the “root” and is denoted by C_{1}. If C_{i}, i∈N_{K}\{1}, has only one adjacent tool, it is called a leaf tool. From C_{1 }to each leaf, there is a directed path. On such a path, if C_{i }is closer to C_{1 }than C_{j}, C_{i }is the upstream tool of C_{j}.
As done in [Chan et al. 2011b], for a Ktreecluster tool, we assume: 1) the root has two LLs; 2) a BM shared by two adjacent tools can hold one wafer at a time without a processing function; 3) a PM can process one wafer at a time; 4) all the wafers in a cassette should be processed in an identical sequence specified in the recipe and visit a PM no more than once (except for a BM); 5) the loading, unloading, moving time of the robots, and the processing time of a wafer at a PM are deterministic and known; 6) the loading and unloading time of a robot is same, and the robot moving time from a PM to another is also same regardless of whether it carries a wafer or not; and 7) there is no parallel module, or only one PM is configured for each processing step.
With two LLs, while one lot of wafers in one LL is being processed, the other LL can be used for loading/unloading another lot of wafers. In this way, a multicluster tool can work consecutively without interruption. Thus, it operates in a steady state at most of time and there are always wafers to be processed. This is equivalent to that the LLs have infinite capacity.
A.2. Operation Process
The wafer fabrication process can be illustrated by the 5treecluster tool shown in FIG. 1. With the LL and BMs being treated as a step, let PS_{ij }denote the jth step in C_{i}. Then, the processing route of a wafer is: PS_{10 }(LL)→PS_{11}→PS_{12}(PS_{20})→PS_{21}→PS_{22}→PS_{23}→PS_{24}→PS_{20 }(PS_{12})→PS_{13}→(PS_{30})→PS_{31}→PS_{32 }(PS_{40})→PS_{41}→PS_{42 }(PS_{50})→PS_{51}→PS_{52}→PS_{53}→PS_{54}→PS_{50 }(PS_{42})→PS_{43}→PS_{44}→PS_{40 }(PS_{32})→PS_{33}→PS_{34}→PS_{30 }(PS_{13})→PS_{14}→PS_{10 }(LL).
In C_{i}, i∈N_{K}\{1}, the BM denoted as PM_{i0 }can be viewed as a virtual LL for injecting wafers from an upstream tool, while the other BM(s) PM_{ij }(j>0) can be viewed as a virtual process module(s). The BM shared by adjacent tools C_{i }and C_{j }is called an outgoing buffer for C_{i }and an incoming one for C_{j}. The LLs in C_{1 }can be treated as an incoming buffer with infinite capacity. There are a number of processing steps in each individual tool and a BM connecting two tools is treated as a processing step with processing time being zero. Let Ψ denote the index set of leaf tools and DI(C_{i}) the index set of the immediate downstream tools of C_{i }(i∉Ψ). We have DI(C_{i})=Ø if i∈Ψ. Further, let PM_{i(b[i,k]) }denote the BM shared by C_{i }and C_{k}, k∈DI(C_{i}), with PM_{k0 }being the incoming buffer or virtual LL for C_{k}. It is called Step b[i,k] for C_{i }and Step 0 for C_{k}, respectively. Assume that, except the incoming buffer, there are n[i] steps in C_{i}. Then, there are n[i]+1 steps in C_{i }denoted as PS_{i0}, PS_{i1}, . . . , PS_{i(n[i]) }with PS_{i0 }and PS_{i(b[i,k]) }being the incoming and outgoing steps. Let R_{i }denote the robot in C_{i}. As discussed above, at most of time, a multicluster tool operates in a steady state. Under such a state, for a processdominant multicluster tool, a backward strategy [Dawande 2002] is optimal for each individual tool.
A.3. Modeling the Wafer Flow
We model a multicluster tool system by extending the resourceoriented PN (ROPN) proposed in [Wu, 1999; Wu et al., 2008a and 2008b; and Wu and Zhou, 2009]. It is a finite capacity PN=(P, T, I, O, M, K), where P is a finite set of places; T is a finite set of transitions, P∪T≠Ø, and P∩T=Ø; I:P×T→N={0, 1, 2, . . . } is an input function; O:P×T→N is an output function; M:P→N is a marking denoting the number of tokens in P with M_{0 }being the initial marking; and K:P→N\{0} is a capacity function with K(p) being the number of tokens that p can hold at a time. The basic concept, transition enabling and firing rules of Petri nets (PN) can be found in [Zhou et al., 1998; Wu and Zhou, 2009].
To model a multicluster tool, one needs to model the individual tools and the BMs. The behavior of Step j in C_{i }is modeled as follows. The PM for Step j in C_{i }with i≠1 and j≠0 is modeled by timed place p_{ij }with K(p_{ij})=1. Place p_{10 }models the LLs in C_{1 }with K(p_{10})=∞. Places z_{ij }and d_{ij }model R_{i}'s holding a wafer (token) for loading into p_{ij }and moving from Steps j to j+1 (or Step 0 if j=n[i]), respectively. Place q_{ij }models R_{i}'s waiting at Step j for unloading a wafer there. Transitions t_{ij }and u_{ij }model R_{i}'s loading and unloading a wafer into and from PM_{ij}, respectively. Then, with arcs (z_{ij}, t_{ij}), (t_{ij}, p_{ij}), (p_{ij}, u_{ij}), (q_{ij}, u_{ij}), and (u_{ij}, d_{ij}), of the PN model for Step j in C_{i }is obtained as shown in FIG. 2.
With the model for a step as a module, tool C_{i }is modeled as follows. Place r_{i }models R_{i }with K(r_{i})=1, meaning that, with only one arm, the robot can hold one wafer at a time. Timed y_{ij }with arcs (r_{i}, y_{ij}) and (y_{ij}, q_{ij}) for connecting r_{i }and q_{ij}, representing that R_{i }moves from Steps j+2 to j, j=0, 1, . . . , n[i]−2 (y_{i(n[i]−1) }for moving from Steps 0 to n[i]−1, and y_{i(n[i]) }for moving from Steps 1 to n[i]). Finally, x_{ij}, j=0, 1, 2, . . . , n[i]−1, are added between d_{ij }and z_{i(j+1) }with arcs (d_{ij}, x_{ij}) and (x_{ij}, z_{i(j+1)}); and x_{i(n[i]) }is added between d_{i(n[i]) }and z_{i0 }with arcs (d_{i(n[i])}, x_{i(n[i])}) and (x_{i(n[i])}, z_{i0}). In this way, the modeling of C_{i }is completed as shown in FIG. 2.
A BM linking C_{i }and C_{a}, a∈DI(C_{i}), is denoted by PM_{i(b[i,a]) }in C_{i }and PM_{a0 }in C_{a}. Thus, p_{i(b[i,a]) }and p_{a0 }with p_{i(b[i,a])}=p_{a0 }are used to model the BM. Then, Step b[i,a] for C_{i }is modeled by {p_{i(b[i,a])}, q_{i(b[i,a])}, z_{i(b[i,a])}, d_{i(b[i,a])}, t_{i(b[i,a])}, u_{i(b[i,a])}} and Step 0 for C_{a }by {P_{a0}, q_{a0}, z_{a0}, d_{a0}, t_{a0}, u_{a0}}, respectively. Thereafter, when we refer to Step b[i,a] in C_{i}, we use p_{i(b[i,a])}, whereas for Step 0 in C_{a }we use p_{a0}. It should be pointed out that Step 0 in C_{1 }(the LLs) is not shared with any other tool and there is no outgoing buffer in a leaf tool C_{L}. The PN model for the BM linking C_{i }and C_{a }is shown in FIG. 3.
With the PN structure developed, marking M_{0 }is set as follows. To describe the idle state of the system, a special type of token called Vtoken representing a virtual wafer is introduced. As mentioned above, there is a processbound bottleneck tool in the system. Hence, in the steady state, if there is a wafer being processed in every PM_{ij }with j≠0, the system reaches its maximal throughput. Let χ denote the index set of nonleaf tools N_{K}=χ∪Ψ with χ∩Ψ=Ø. Then, M_{0 }is set as follows. For C_{i}, i∈N_{K}, set M_{0}(p_{ij})=1 for j≠1 with a Vtoken, M_{0}(p_{ij})=0, j=1, and M_{0}(p_{10})=n; M_{0}(q_{ij})=M_{0}(z_{ij})=M_{0}(d_{ij})=0 for any j; and M_{0}(r_{i})=1. It is assumed that the token in p_{i(b[i,a]) }enables u_{a0}, where a∈DI(C_{i}).
It is easy to show that the obtained PN is deadlockprone. To make it deadlockfree, let Ω_{n}=N_{n}∪{0}, a control policy on y_{ij}'s is defined as follows.
Definition 1: At marking M, y_{ij}, i∈N_{K }and j∈Ω_{n[i]−1}, is said to be controlenabled if M(p_{i(j+1)})=0; y_{1(n[i]) }is controlenabled if M(p_{1(n[i])})=1; and y_{i(n[i])}, i∈N_{K}\{1}, is controlenabled if M(p_{i0})=0.
With Definition 1, the PN for an individual tool is shown to be deadlockfree [Wu et al., 2008a]. Thereafter, it is assumed that the PN is controlled by the policy given in Definition 1.
In the PN model for a BM shared by C_{i }and C_{a }shown in FIG. 3, p_{i(b[i,a]) }(p_{a0}) has two output transitions u_{i(b[i,a]) }and u_{a0}, leading to a conflict. A token entering p_{i(b[i,a]) }by firing t_{i(b[i,a]) }in C_{i }should enable u_{a0 }in C_{a}, while a token entering p_{a0 }by firing t_{a0 }in C_{a }should enable u_{i(b[i,a]) }in C_{i}. Colors are introduced to make the model conflictfree as follows.
Definition 2: Define the unique color of transition t_{i }as C(t_{i})={c_{i}}.
By Definition 2, the colors for u_{i(b[i,a]) }and u_{a0 }are c_{i(b[i,a]) }and c_{a0}, respectively. Then, the color for a token in p_{i(b[i,a]) }or p_{a0 }is defined as follows.
Definition 3: For i∈χ, a∈DI(C_{i}), a token entering p_{i(b[i,a]) }by firing t_{i(b[i,a]) }in C_{i }has color c_{a0}, while a token entering p_{a0 }by firing t_{a0 }in C_{a }has color c_{i(b[i,a])}.
It is easy to check that, by Definitions 2 and 3, the model is conflictfree. The obtained model can also describe the behavior of initial and final transient processes as explained as follows. At M_{0}, y_{i0 }is enabled and fires leading to M_{1}(q_{i0})=1. By starting from M_{1}, transition u_{10 }fires and W_{1 }representing the first wafer is unloaded from p_{10}. In this way, every time when u_{10 }fires, a token for a real wafer is delivered into p_{11}. With the transition enabling and firing rules, the model evolves to reach a marking M such that every Vtoken is removed from the model and is replaced by a token for a real wafer, or a steady state is reached. The evolution from M_{0 }to M presents the initial transient process. Similarly, when the system needs to stop working, every time when u_{10 }fires, a Vtoken is delivered into p_{11}, the model can evolve back to marking M_{0}, which describes the final transient process.
A.4. Modeling Activity Time
To describe the temporal aspect, time is associated with both transitions and places. It follows from Kim et al. [2003] and Lee and Lee [2006] that the time for the robot to move from one step to another is a constant, and so is the time for the robot to load/unload a wafer into/from a PM. The symbols and time durations for places and transitions are listed in TABLE 1.
B. Properties Of Scheduling A KCluster Tool
This section recalls the properties of scheduling an individual tool in [Zhu et al., 2013]. For a processdominant Ktreecluster tool, since a backward strategy is optimal for each individual tool, with the PN model shown in FIG. 2, R_{i}'s cycle time is given by [Wu et al., 2008]
ψ_{i}=2(n[i]+1)(λ_{i}+μ_{i})+Σ_{j=0}^{n[i]}ω_{ij}=ψ_{i1}+ψ_{i2}, i∈N_{K}, (1)
where ψ_{i1}=2(n[i]+1)(λ_{i}+μ_{i}) is R_{i}'s task time and is a constant, and ψ_{i2}=Σ_{j=0}^{n[i]}ω_{ij }is the robot waiting time in a cycle.
With robot waiting as an event, the time taken for completing a wafer at Step j in C_{i}, i∈N_{K}, is given by [Wu et al., 2008]
ξ_{ij}=α_{ij}+4λ_{i}+3μ_{i}+ω_{i(j−1)}, i∈N_{K }and j∈N_{n[i]}, (2)
and
ξ_{i0}=4λ_{i}+3μ_{i}+ω_{i(n[i])}, i∈N_{K}. (3)
Note that, since a BM has no processing function, we have α_{i0}=α_{i(b[i,a])}=0, a∈DI(C_{i}). With α_{ij}, λ_{i}, and μ_{i }being constants and ω_{ij}'s being variable, if ω_{ij }is set to be zero, the shortest time taken for completing a wafer at Step j in C_{i }is
η_{ij}=α_{ij}+4λ_{i}+3μ_{i}, i∈N_{K }and j∈Ω_{n[i]}. (4)
A cluster tool may be scheduled such that a wafer stays in PM_{ij }for some time after its completion, or τ_{ij}≥α_{ij}, where τ_{ij }is the wafer sojourn time in PM_{ij}. For Step j∈{0, b[i,a]}, a∈DI(C_{i}), or a BM, the wafer unloaded from PS_{ij }by the fth firing of u_{ij }is not the one that is loaded into PS_{ij }by the fth firing of t_{ij}. However, for scheduling purpose, we concern only the time needed for completing the tasks in accessing a BM but not if they are the same wafer. Hence, the virtual wafer sojourn time for Step j∈{0, b[i, a]}, a∈DI(C_{i}), is introduced as follows. Let υ_{1 }and υ_{2 }be the end time point of the kth firing of t_{ij }and the start time point of the kth firing of u_{ij}, respectively. The virtual wafer sojourn time is defined as τ_{ij}=υ_{2}−υ_{1}. In this way, for all steps in C_{i}, τ_{ij }has the same meaning. Then, by replacing α_{ij }with τ_{ij }in (2) and (3), the cycle time at Step j in C_{i }is given by
θ_{ij}=τ_{ij}+4λ_{i}+3μ_{i}+ω_{i(j−1)}, i∈N_{K }and j∈N_{n[i]}, (5)
and
θ_{i0}=τ_{i0}+4λ_{i}+3μ_{i}+ω_{i(n[i])}, i∈N_{K}. (6)
Let Π_{i}=max{η_{i0}, η_{i1}, . . . , η_{i(n[i])}, ψ_{i1}}. If Π_{i}=ψ_{i1}, C_{i }is transportbound, otherwise it is processbound. The manufacturing process in C_{i }is a serial one and C_{i }should be scheduled such that
Θ_{i}=θ_{i0}=θ_{i1}= . . . =θ_{i(n[i]) }and τ_{ij}≥α_{ij}, i∈N_{K }and j∈Ω_{n[i]} (7)
where Θ_{i }is the cycle time of C_{i}. To find a feasible schedule, Θ_{i}≥Π_{i }must hold. Given Θ_{i }for C_{i}, R_{i }should be scheduled such that ψ_{i}=Θ_{i}. Thus, ψ_{i2}=Θ_{i}−ψ_{i1 }is the R_{i}'s waiting time in a cycle, or the schedule is a function of R_{i}'s waiting time. This implies that a onewafer cyclic schedule for a multicluster tool is determined by the robots' waiting time. The key here is how to determine the minimal Θ_{i}'s.
Let Θ denote the cycle time of a Ktreecluster tool and Θ_{i }the cycle time of C_{i}, i∈N_{K}. From [Zhu et al., 2013b], it can easily show that, to obtain a onewafer cycle schedule for a Ktreecluster tool, Θ_{1}=Θ_{2}= . . . =Θ_{K}=Θ should hold. Let C_{h}, 1≤h≤K, be the bottleneck tool in a Ktreecluster tool and Π_{h }be its FP. Then, Θ_{1}=Θ_{2}= . . . =Θ_{K}=Θ≥Π_{h }must hold. Hence, to obtain a onewafer cycle schedule for a Ktreecluster tool, every individual tool should have the same cycle time and, at the same time, the multiple robots should be coordinated such that all the individual tools operate in a paced way.
Assume that C_{i}, ∀i∈N_{K}. It is scheduled to have a cycle time Θ. Examine C_{i }and C_{a}, i∉Ψ and a∈DI(C_{i}). If the system is scheduled such that, every time after R_{i }loads a wafer into PS_{i(b[i, a]) }by firing t_{i(b[i, a])}, u_{a0 }fires immediately to unload this wafer by R_{a}, then C_{i }and C_{a }can operate in a paced way. If a Ktreecluster tool is scheduled such that, any pair of C_{i }and C_{a }can operate in such a way, a onewafer cyclic schedule is obtained. We then examine how C_{i }and C_{a}, i∉Ψ and a∈DI(C_{i}), can be scheduled to operate in a paced way. Let ϕ_{i0 }be the start time point for firing u_{i0 }in C_{i}. Between the firings of u_{i0 }and t_{i(b[i, a])}, the following transition firing sequence is executed: σ_{i}=firing u_{i0 }(with timeλ_{i})→x_{i0}(μ_{i})→t_{i1}(λ_{i})→y_{i(n[i])}(μ_{i})→robot waiting in q_{i(n[i])}(ω_{i(n[i])})→u_{i(n[i])}(λ_{i})→x_{i(n[i])}(μ_{i})→t_{i0}(λ_{i})→ . . . →y_{i(b[i, a]−1)}(μ_{i})→robot waiting in q_{i(b[i, a]−1)}(ω_{i(b[i, a]−1)})→u_{i(b[i, a]−1)}(λ_{i})→x_{i(b[i, a]−1)}(μ_{i})→t_{i(b[i, a])}(λ_{i}). Given a schedule for C_{i }by setting ω_{ij}'s, the time taken by σ_{i }is Δ_{i}={(n[i]+1)−(b[i, a]−2)}(2λ_{i}+2μ_{i})−μ_{i}+Σ_{j=b[i,a]−1}^{n[i]}ω_{ij}, if b[i, a]>1; and Δ_{i}=2λ_{i}+μ_{i}, if b[i, a]=1. Then, u_{a0 }starts to fire at ϕ_{a0}=ϕ_{i0}+Δ_{i}, i∉Ψ. In other words, to make C_{i }and C_{a }operate in a paced way with a cycle time Θ, u_{a0 }should fire Δ_{i }time units later than the firing of u_{i0}.
With the PN model, the above requirement can be implemented by properly scheduling C_{i }and C_{a }as follows. At M_{0 }that is set as above discussed, u_{10 }fires and W_{1 }representing the first real wafer released into the system is unloaded from p_{10}. Then, for an m∈DI(C_{1}), transition firing sequence σ_{1}=firing u_{10}(λ_{1})→x_{10}(μ_{1})→t_{11}(λ_{1})→y_{1(n[1])}(μ_{1})→robot waiting in q_{1(n[1])}(ω_{1(n[1])})→u_{1(n[i])}(λ_{1})→x_{1(n[1])}(μ_{1})→t_{10}(λ_{1})→ . . . →y_{1(b[1, m]−1)}(μ_{1})→robot waiting in q_{1(b[1, m]−1)}(ω_{1(b[1, m]−1)})→u_{1(b[1, m]−1)}(λ_{1})→x_{1(b[1, m]−1)}(μ_{1})→t_{1(b[1, m])}(λ_{1}) is executed in C_{1}. By firing t_{11}, W_{1 }is loaded into PS_{11}. After firing t_{1(b[1,m])}, u_{m0 }is enabled and fires. The time taken by σ_{1 }is Δ_{1}={(n[1]+1)−(b[1, m]−2)}(2λ_{1}+2μ_{1})−μ_{1}+Σ_{j=b[1,m]−1}^{n[1]}ω_{ij }such that ϕ_{m0}=ϕ_{10}+Δ_{1}. Then, in C_{1}, t_{1(b[1, m]) }fires again after a cycle. Meanwhile, in C_{m}, a cycle is also completed. Since the cycle time is Θ for both C_{1 }and C_{m}, u_{m0 }fires again just after t_{1(b[1, m]) }fires. During this cycle, W_{2 }is released into the system.
By starting from the firing of u_{m0}, transition firing sequence σ_{m}=u_{m0}(λ_{m})→x_{m0}(μ_{m})→t_{m1}(λ_{m})→y_{m(n[m])}(μ_{m})→robot waiting in q_{m(n[m])}(ω_{m(n[m])})→u_{m(n[m])}(λ_{m})→x_{m(n[m])}(μ_{m})→t_{m0}(λ_{m})→ . . . →y_{m(b[m, d]−1)}(μ_{m})→robot waiting in q_{m(b[m, d]−1)}(ω_{m(b[m, d]−1)})→u_{m(b[m, d]−1)}(λ_{m})→x_{m(b[m, d]−1)}(μ_{m})→t_{m(b[m, d])}(λ_{m}) is executed in C_{m}, d∈DI(C_{m}). After firing t_{m(b[m, d])}, u_{d0 }is enabled and fires. The time taken by σ_{m }is Δ_{m }such that ϕ_{d0}=ϕ_{m0}+Δ_{m}. This process can be performed for every pair of C_{m }and C_{d}, d∈DI(C_{m}), such that every tool in the system acts in a paced way. Notice that, after each cycle in C_{1}, a Vtoken is removed from the system. When all Vtokens are removed, the steady state is reached and the system operates according to the backward onewafer cycle schedule.
Notice that, to perform the above process for C_{m }and C_{d}, d∈DI(C_{m}), it requires that: 1) when R_{m }arrives at p_{m(b[m, d]) }for firing u_{m(b[m, d]) }(t_{m(b[m, d])}), there is a token in p_{m(b[m,d]) }(p_{m(b[m, d]) }is emptied); and 2) when R_{d }arrives at p_{d0 }for firing u_{d0 }(t_{d0}), there is a token in p_{d0 }(p_{d0 }is emptied). To make these requirements satisfied, we have the following theorem.
Theorem 1: Given Θ≥Π_{h }as cycle time for a processdominant Ktreecluster tool, a onewafer cyclic schedule exists if and only if, for any pair of C_{i }and C_{a}, a∈DI(C_{i}), the following conditions are satisfied by determining ω_{ij}'s and ω_{af}'s:
θ_{ij}=θ_{af}=Θ, j∈Ω_{n[i]} and f∈Ω_{n[a]}, (8)
τ_{i(b[i, a])}≥4λ_{a}+3μ_{a}+ω_{a(n[a])} (9)
and
τ_{a0}≥4λ_{i}+3μ_{i}+ω_{i(b[i, a]−1)}. (10)
The proof of Theorem 1 is similar to that in [Zhu et al., 2013b] and omitted. By Theorem 1, to find a onewafer cyclic schedule, the key is to determine Θ such that (8)(10) are satisfied by setting ω_{ij}'s and ω_{af}'s. This issue is discussed next.
C. OneWafer Cyclic Scheduling
C.1. Scheduling of a Clustertoolchain
By viewing an individual tool as a vertex, the topology of a Ktreecluster tool is a tree (directed graph) [Cormen et al., 2001]. Let χ(i, j) denote the index set of the tools on the path from C_{i }to C_{j}, including i and j, and χ(i, j) be its cardinality. The length of the path from C_{i }to C_{j }is defined as the number of arcs connecting two adjacent tools on a path and is denoted by Len(C_{i}, C_{j})=χ_{(i, j)}−1. If there is a path from C_{i }to C_{j }and Len(C_{1}, C_{i})<Len(C_{1}, C_{j}), C_{i }is an upstream tool of C_{j }and C_{j }is a downstream one of C_{i}. Let ODeg(C_{i}) denote the number of downstream tools immediately adjacent to C_{i}. C_{i }is called a fork tool if ODeg(C_{i})≥2. For example, in the 5treecluster tool shown in FIG. 1, Len(C_{1}, C_{5})=3, ODeg(C_{1})=2, and ODeg(C_{3})=ODeg(C_{4})=1.
A multicluster tool with serial topology can be seen as a clustertoolchain (CTC). Then, a Ktreecluster tool can also be seen to be formed by a number of CTCs. A CTC that starts from C_{f }and ends at C_{l }is denoted as CTC[f, l]. Note that a CTC can be formed by a single tool and in this case we have f=l. Let UI(C_{i}) denote the index of the immediate upstream tool of C_{i}. Since C_{1 }has no upstream tool, we set UI(C_{1})=0. Then, we divide a Ktreecluster tool into a number of CTCs such that, for a CTC[f, l], we have ODeg(C_{j})≥2, j=UI(C_{f}) and f≠1; either ODeg(C_{l})≥2 or ODeg(C_{l})=0; and ODeg(C_{l})=1, i∈χ_{(i, j)}, i≠f, and i≠l. For a Ktreecluster tool, the individual tools can be labeled such that the tools on each CTC[f, l] are labeled with consecutive numbers in an increasing order from f to l. That is, the immediate upstream and downstream tools of C_{i }are C_{i−1 }and C_{i+1}, respectively. For example, the 5treecluster tool shown in FIG. 1 has three CTCs: {C_{2}}, {C_{3}, C_{4}, C_{5}}, and {C_{1}}. Algorithm 2 is presented later to find such CTCs. Before presenting the method for scheduling a Ktreecluster tool, we discuss how to schedule the CTCs first.
Given CTC[f, l], there is only one BM shared by C_{i }and C_{i+1}, i∈N_{[f, l−1]={f, f+}1, . . . , l−1}. Hence, for the simplicity of presentation, for a CTC, we can use PS_{i(b[i]) }for the BM in C_{i }instead of PS_{i(b[i,i+1])}. Let φ_{i(b[i])}=4λ_{i}+3μ_{i}+ω_{i(b[i]−1) }and φ_{i0}=4λ_{i}+3μ_{i}+ω_{i(n[i])}. Examining the conditions given in Theorem 1, one can find that, to schedule CTC[f, l] from C_{l }to C_{f }such that these conditions are satisfied, one needs to set the robots' waiting time such that: 1) ω_{l(n[l]) }is as small as possible; and 2) ω_{i(n[i]) }and ω_{i(b[i]−1)}, i∈N_{[f, l−1]}, are as small as possible. Given cycle time Θ≥Π_{h}, this can be implemented as follows: (1) set ω_{ij}=min{Θ−(4λ_{l}+3μ_{l}+α_{l(j+1)}), Θ−2(n[l]+1)(λ_{l}+μ_{l})−Σ_{m∈Ω}_{j}_{\{j}}ω_{lm}}; j∈Ω_{n[l]−1}; (2) ω_{l(n[l])}=Θ−2(n[l]+1)(λ_{l}+μ_{l})−Σ_{m=0}^{n[l]−1}ω_{lm}; (3) τ_{l0}=Θ=φ_{l0}; and (4) set ω_{ij}'s from i=l−1 to f according to
ω_{i(b[i]−1)}=min{τ_{(i+1)0}−(4λ_{i}+3μ_{i}), Θ−2(n[i]+1)(λ_{i}+μ_{i})}, (11)
ω_{ij}=min{Θ−(4λ_{i}+3μ_{i}+α_{i(j+1)}), Θ_{0}−2(n[i]+1)(λ_{i}+μ_{i})−Σ_{m∈Ω}_{j}_{\{j}}ω_{im}} for j∈Ω_{n[i]−1}\{b[i]−1, n[i]}, (12)
ω_{i(n[i])}=Θ−2(n[i]+1)(λ_{i}+μ_{i})−Σ_{m=0}^{n[i]−1}ω_{im} (13)
and
τ_{i0}=Θ−φ_{i0}. (14)
If ∀i∈N_{[f, l−1]}, ω_{i(b[i]−1)}≥0, the conditions given in Theorem 1 are satisfied. That is, given Θ≥Π_{h}, a onewafer cyclic schedule is found for CTC[f, l] by setting the ω_{ij}'s. However, i∈N_{[f, l−1]}, ω_{i(b[i]−1)}<0 may happen. Since Θ−2(n[i]+1)(λ_{i}+μ_{i})≥0 always holds. ω_{i(b[i]−1)}<0 implies that τ_{(i+1)0}−(4λ_{i}+3μ_{i})<0, leading to τ_{(i+1)0}<(4λ_{i}+3μ_{i}), i.e., the conditions in Theorem 1 are violated. Thus, the above procedure can be used to not only schedule a CTC if a feasible onewafer schedule exists for the given cycle time Θ, it also can be used to check the existence of a onewafer cyclic schedule for CTC[f, l] and this procedure is called CTCCheck.
Note that, in the above procedure, for i∈N_{[f, l−1]}, ψ_{i2 }is assigned ω_{ij}'s, j∈Ω_{n[i]−1}} as much as possible. In this way, ω_{i(n[i]) }and φ_{i0}=4λ_{i}+3μ_{i}+ω_{i(n[i]) }are minimized.
C.2. Minimal Cycle Time of a CTC
Given Θ≥Π_{h }for CTC[f, l], if ω_{i(b[i]−1)}<0, i∈N_{[f, l−1]}, happens by using CTCCheck, one cannot find a onewafer schedule with cycle time Θ. However, a onewafer cyclic schedule still exists and such a schedule can be found by increasing Θ. The key is how to determine the minimal cycle time Θ and this issue is discussed as follows.
For CTC[f, l] and given Θ, τ_{(k+1)0}<(4λ_{k}+3μ_{k}), k∈N_{[f, l−1]}, we assume that τ_{(i+1)0}≥(4λ_{i}+3μ_{i}), i∈N_{[k+1, l−1]}, that is, the conditions given in Theorem 1 are satisfied for C_{i}, ∀i∈N_{[k+1, l−1]}, but not satisfied for C_{k}. Since 4λ_{k}+3μ_{k }is a constant, to make τ_{(k+1)0}≥(4λ_{k}+3μ_{k}) satisfied, the only way is to increase τ_{(k+1)0}. Since τ_{(k+1)0}=Θ−(4λ_{k+1}+3μ_{k+1}+ω_{(k+1)(n[k+1])}) and (4λ_{k+1}+3μ_{k+1}) is a constant, to increase τ_{(k+1)0}, one needs to increase Θ and reduce ω_{(k+1)(n[k+1])}. By examining the CTCCheck procedure, one can find that, by increasing Θ, one can assign more part of ψ_{(k+1)2 }into ω_{(k+1)j}, j∈Ω_{n[k+1]−1}\{n[k+1]}, such that ω_{(k+1)(n[k+1]) }is reduced. In this way, τ_{(k+1)0 }can be increased by increasing Θ and reducing ω_{(k+1)(n[k+1]) }simultaneously.
By increasing Θ, to obtain a onewafer cyclic schedule, the cycle time for any C_{i }in a Ktreecluster tool should be increased as well such that every tool has the same cycle time. Hence, by increasing Θ for C_{i}, i∈N_{[k+2, l]}, ω_{i(n[i]) }is reduced. Then, by the CTCCheck procedure, this leads to the decrease of ω_{(i−1)(n[i−1])}. Finally, the increase of Θ for C_{i}, i∈N_{[k+2, l−1]}, can result in the decrease of ω_{(k+1)(n[k+1])}. This implies that, with the increase of Θ, ω_{(k+1)(n[k+1]) }can be reduced by scheduling C_{k+1 }and its downstream tools. However, given Θ, if CTC[f, l] is scheduled by the CTCCheck procedure such that ω_{i(n[i])}=0, i∈N_{[k+2, l]}, the increase of Θ for C_{i }and its downstream tools has no effect on ω_{(k+1)(n[k+1])}, since ω_{i(n[i]) }cannot be reduced any more. Thus, the effect of scheduling downstream tools on ω_{(k+1)(n[k+1]) }should be taken into account in finding the minimal cycle time.
Note that C_{l }is either a leaf or a fork. If it is a fork, it has multiple outgoing BMs. This means that CTC[f, l] has multiple downstream CTCs. As above discussed, with the increase of Θ, scheduling tool C_{i }in a downstream CTC of CTC[f, l] can result in the reduction of ω_{(k+1)(n[k+1])}. Also, given Θ, if a schedule for tool C_{i }in a downstream CTC is obtained by the CTCCheck procedure such that ω_{i(n[i])}=0, then, with the increase of Θ, scheduling C_{i }and its downstream tools has no effect on ω_{(k+1)(n[k+1])}.
With the above discussion, we present how to find the minimal cycle time and schedule the system as follows. Given Θ, for CTC[f, l], every time if ω_{k(b[k]−1)}<0, k∈N_{[f, l−1]} is returned by the CTCCheck procedure, the cycle time is increased by Δ, i.e. Θ←Θ+Δ, such that τ_{(k+1)0}=(4λ_{k}+3μ_{k}). The key is how to determine Δ. To do so, define D[i]={PM_{ij}j∈Ω_{n[i]−1}\{b[i]−1, n[i]}} be the set of steps in C_{i }and B[i]=D[i], and B*[i]=B[i] if i≠l, and B*[l]=n[l]−1.
Given Θ, for CTC[f, l], when ω_{k(b[k]−1)}<0, k∈N_{[f, l−1]}, is returned by the CTCCheck procedure, for every C_{i}, i∈N_{[k, l]}, or in the downstream CTCs of CTC[f, l], the robot waiting time is set by the CTCCheck procedure. To find Δ, for C_{i}, i∈N_{[k, l]}, or in the downstream CTCs of CTC[f, l], let A_{ij}=ω_{ij }and Λ_{ij}=τ_{ij}, j∈Ω_{n[i]}, and Φ=4λ_{k}+3μ_{k}−Λ_{(k+1)0}=4λ_{k}+3μ_{k}−(Θ−(4λ_{k+1}+3μ_{k+1}+ω_{(k+1)(n[k+1])}))=4λ_{k}+3μ_{k}+4λ_{k+1}+3μ_{k+1}+ω_{(k+1)(n[k+1])}−Θ.
To take the effect of tools in the downstream CTCs of CTC[f, l] into account, we use DsI(C_{i}), i∉Ψ, to denote the index set of all the downstream tools of C_{i }and LeafDsI(C_{i}), the index set of leaf tools in DsI(C_{i}). Further, define E(k)={g∈∪χ_{(k, m)}m∈LeafDsI(C_{k}), ω_{j(n[j])}>0, j∈∪χ_{(h, g) }and h=DI(C_{k}), and ω_{(g+1)(n[g+1])}=0, g∉LeafDsI(C_{k})}. Further, let Y(k)={∪χ_{(h, s)}s∈E(k) and h=DI(C_{k})}. Then, Δ is determined as follows. For g∈Y(k), let δ_{g}=ω_{g(n[g])}/Σ_{j∈Y(g)}B*[j], δ_{k}=Φ/(1+Σ_{j∈Y(k)}B*[j]), and Q(k)={a∈∪χ_{(k, d)}d∈E(k)}. Then, let Δ=min_{h∈Q(k)}δ_{h }and there are two cases.
Case 1: If Δ=δ_{k}, let Θ←Θ+Δ. For ∀i∈DsI(C_{a}) and ∀a∈E(k), set ω_{i0}=A_{i0}+Δ, τ_{i0}=Λ_{i0}+Δ, and τ_{i(m−1)}=Λ_{i(m−1)}+Δ with m∈BI(C_{i}), when C_{i }is not a leaf tool. For ∀i∈Y(k)\E(k), ω_{ij}=A_{ij}+Δ, j∈Ω_{n[i]}\{{j−1j∈BI(C_{i})}∪{n[i]}}, ω_{i(b[m, d]−1)}=A_{i(b[m, d]−1)}+Δ×Σ_{j∈{∪χ}_{(d,a)}_{a∈E(i)}}B*[j]+Δ, m∈BI(C_{i}) and d=DI(C_{i}); ω_{i(n[i])}=A_{i(n[i])}−Δ×Σ_{j∈{∪χ}_{(i,a)}_{a∈E(i)}}B*[j]; and τ_{i0}=Λ_{i0}+Δ+Δ×Σ_{j∈{∪χ}_{(i,a)}_{a∈E(i)}}B*[j]. Then, with the increased Θ and the reset ω_{ij}'s, it is easy to verify that Conditions (9)(10) are satisfied for i∈DsI(C_{k}).
Case 2: If Δ≠δ_{k}, let Δ=δ_{g}=min_{h∈Q(k)}δ_{h}, Θ←Θ+Δ. Then, for ∀s∈E(k) and ∀i∈DsI(C_{s}), ω_{i0}=A_{i0}+Δ, τ_{i0}=Λ_{i0}+Δ, and τ_{i(m−1)}=Λ_{i(m−1)}+Δ, m∈BI(C_{i}), when C_{i }is not a leaf tool. For ∀i∈Y(k), ω_{ij}=A_{ij}+Δ, j∈Ω_{n[i]}\{{j−1j∈BI(C_{i})}∪{n[i]}}, ω_{i(m−1)}=A_{i(m−1)}+Δ×Σ_{j∈∪Y(i)}B*[j]+Δ, m∈BI(C_{i}); ω_{i(n[i])}=A_{i(n[i])}−Δ×Σ_{j∈{∪χ}_{(i,a)}_{a∈E(i)}}B*[j]; and τ_{i0}=Λ_{i0}+Δ+Δ×Σ_{j∈{∪χ}_{(i,a)}_{a∈E(i)}}B*[j]. By doing so, it follows from (5)(6) that Conditions (9)(10) are satisfied for i∈DsI(C_{k}). Due to δ_{k}>Δ=δ_{g}, we may have τ_{(k+1)0}<(4λ_{k}+3μ_{k}) and A_{g(n[g])}=0, g∈∪χ_{(k+1, a)}, a∈E(k). In this case, let Θ←Θ+Δ. Then, repeat the above procedure for χ_{(k+1, g−1) }until Case 1 occurs such that Δ=δ_{k }or A_{(k+1)(n[k+1])}=0.
Finally the cycle time is increased by Δ such that τ_{(k+1)0}=(4λ_{k}+3μ_{k}) and Conditions (9)(10) for any pair of C_{i }and C_{i+1}, i∈N_{[f, l]}, are satisfied. In addition, since τ_{(k+1)0}=(4λ_{k}+3μ_{k}), a cycle time increase that is less than Δ must result in τ_{(k+1)0}<(4λ_{k}+3μ_{k}). For a CTC without downstream CTCs, a method is presented to find the minimal cycle time and its optimal onewafer cyclic schedule in [Zhu et al., 2013b]. Since such method is somehow similar to the one disclosed herein, we do not go into too much detail and please refer to [Zhu et al., 2013b] for detail.
In the above development, each individual tool is scheduled such that, for any C_{i}, ω_{i(n[i]) }is minimized. Thus, it follows from Θ_{1}=Θ_{2}= . . . =Θ_{K}=Θ that φ_{i0}, i∈N_{[f, l]}, in CTC[f,l] is minimized. The above development is summarized as Algorithm 1, where inputs φ and Θ≥Π_{h }represent the index set of the individual cluster tools in a CTC and the given cycle time, respectively. Assume that all α_{ij}, λ_{i}, μ_{i }of the Kcluster tool are known constants to Algorithm 1. Its output Θ is the CTC's minimal cycle time.
C.3. Scheduling KTreeCluster Tool
As above discussed, a Ktreecluster tool is composed of a number of CTCs, to obtain the minimal cycle time of the Ktreecluster tool, it needs to minimize φ_{i0}=4λ_{i}+3μ_{i}+ω_{i(n[i]) }for every C_{i }in each CTC, or minimize ω_{i(n[i])}. This is done as follows. Let LCTC be the set of CTC[f, l]s with C_{l }being a leaf tool of the Ktreecluster tool and assume that LCTC=g. Given Θ=Π_{h}, the lower bound of cycle time for a Ktreecluster tool, as the initial cycle time, each CTC in the LCTC is scheduled by using Algorithm 1. Assume that the minimal cycle time obtained for these g CTCs are Θ_{1}, . . . , Θ_{g}, respectively. Then, given Θ=max{Θ_{1}, . . . , Θ_{g}} as the cycle time, for any C_{i }in any CTC that is in LCTC, ω_{ij}'s are set by the CTCCheck procedure. After that, given Θ=max{Θ_{1}, . . . , Θ_{g}} as initial cycle time, we schedule the CTC∉LCTC that is not scheduled and whose downstream CTCs are all in LCTC. By repeating such a process, one can find a onewafer cyclic schedule for the entire Ktreecluster tool by minimizing φ_{i0}=4λ_{i}+3μ_{i}+ω_{i(n[i]) }for every individual tool C_{i}. If finally the obtained minimal cycle time is Θ=Π_{h}, the lower bound of cycle time is reached by a onewafer cyclic schedule. We present Algorithm 2 as follows to implement above sketchy procedure.
By Algorithm 2, the CTCs in a Ktreecluster tool are identified and they are scheduled by calling Algorithm 1 to find the minimal cycle time and set the robots' waiting time. This is done from the leaves to the root in a backward way as above discussed. Also, by Algorithm 2, if Θ=Π_{h }is returned, it implies that τ_{(i+1)0}<(4λ_{i}+3μ_{i}), ∀i∈N_{K}, does not occur and a onewafer cyclic schedule with the lower bound of cycle time is obtained. Therefore, Algorithm 2 can be used to decide whether the Ktreecluster tool can be scheduled to reach the lower bound of cycle time. Thus, we have Theorem 2 immediately.
Theorem 2: For a processdominant Ktreecluster tool, there is a onewafer cyclic schedule such that its cycle time is the lower bound Π_{h }if and only if, by Algorithm 2, Θ=Π_{h }is returned.
Moreover, by the proposed method, if Θ>Π_{h }is returned, the obtained onewafer cyclic schedule is optimal as stated by the following theorem.
Theorem 3: For a processdominant Ktreecluster tool, by Algorithm 2, if Θ>Π_{h }is returned, the obtained onewafer cyclic schedule is optimal in terms of cycle time.
Proof. By applying Algorithm 2 to a Ktreecluster tool, every time if τ_{(i+1)0}<(4λ_{i}+3μ_{i}), i∈N_{K}, occurs, the cycle time Θ is increased by Δ as Θ←Θ+Δ such that τ_{(i+1)0}=(4λ_{i}+3μ_{i}). Hence, by Algorithm 2, finally a onewafer cyclic schedule is obtained with cycle time Θ>Π_{h}, this implies that there is at least an i∈N_{K }such that τ_{(i+1)0}=(4λ_{i}+3μ_{i}). In this case, any decrease of Θ would result in τ_{(i+1)0}=(4λ_{i}+3μ_{i}), leading to the violation of Conditions (9)(10). Thus, Θ>Π_{h }obtained is the minimal cycle time.
Note that, for a processdominant Ktreecluster tool addressed in this work, each individual tool is scheduled by using a backward scheduling strategy. This implies that a backward scheduling strategy is optimal for such a Ktreecluster tool if the proposed method is applied.
D. Illustrative Examples
In this section, we use two examples to show how to apply the proposed method and its effectiveness. In the examples, the time is in seconds and is omitted for simplicity.
Example 1
It is from [Chan et al., 2011b]. As shown in FIG. 4, it is a 3treecluster tool composed of three singlearm cluster tools, where PS_{10 }is the LLs, PS_{20 }and PS_{30 }are incoming buffers for C_{2 }and C_{3}, and, PS_{12 }and PS_{13 }are outgoing buffers for C_{1}. The activity time is as follows: for C_{1}, (α_{10}, α_{11}, α_{12}, α_{13}, α_{14}; λ_{1}, μ_{1})=(0, 10, 0, 0, 10; 5, 2); for C_{2}, (α_{20}, α_{21}, α_{22}, α_{23}, α_{24}; λ_{2}, μ_{2})=(0, 70, 70, 58, 5; 3, 1); and for C_{3}, (α_{30}, α_{31}, α_{32}, α_{33}, α_{34}; λ_{3}, μ_{3})=(0, 5, 58, 70, 70; 3, 1). The wafer processing route is LL→PS_{11}→PS_{12 }(PS_{20})→PS_{21}→PS_{22}→PS_{23}→PS_{24}→PS_{20 }(PS_{12})→PS_{13 }(PS_{30})→PS_{31}→PS_{32}→PS_{33}→PS_{34}→PS_{30 }(PS_{13})→PS_{14}→LL. It contains three CTCs: CTC[2, 2], CTC[3, 3], and CTC[1, 1]. For this example, a multiwafer cyclic schedule is obtained with cycle time 102.8 in [Chan et al., 2011b].
By η_{ij}=α_{ij}+4λ_{i}+3μ_{i}, ψ_{i1}=2(n[i]+1)(λ_{i}+μ_{i}), and Π_{i}=max{η_{i0}, η_{i1}, . . . , η_{i(n[i])}, ψ_{i1}}, for C_{1}, η_{10}=α_{10}+4λ_{1}+3μ_{1}=0+4×5+3×2=26, η_{11}=36, η_{12}=26, η_{13}=26, η_{14}=36, and ψ_{11}=2(n[1]+1)(μ_{1}+λ_{1})=2×(4+1)×(5+2)=70. We have Π_{1}=70 and C_{1 }is transportbound. For C_{2}, we have that η_{20}=15, η_{21}=85, η_{22}=85, η_{23}=73, η_{24}=20, and ψ_{21}=40. Thus we have Π_{2}=85 and C_{2 }is processbound. For C_{3}, we have that η_{30}=15, η_{31}=20, η_{32}=73, η_{33}=85, η_{34}=85, and ψ_{31}=40. Then we have Π_{3}=85 and C_{3 }is processbound. Since Π_{2}=Π_{3}>Π_{1}, and C_{2 }and C_{3 }are processbound, the 3treecluster is processdominant.
With the lower bound of cycle time being Π_{h}=Π_{2}=Π_{3}=85, set Θ=Π_{h}=85 as initial cycle time, we have ψ_{12}=Θ−ψ_{11}=15, ψ_{22}=Θ−ψ_{21}=40, and ψ_{32}=Θ−ψ_{21}=40. By Algorithm 2 that calls Algorithm 1, ω_{ij}'s are set as ω_{20}=ω_{21}=0, ω_{22}=12, ω_{23}=33, ω_{24}=0, ω_{30}=45, ω_{31}=ω_{32}=ω_{33}=ω_{34}=0, ω_{10}=ω_{11}=ω_{12}=ω_{13}=0 and ω_{14}=15 such that Θ=Π_{h}=85 is returned. Hence, a onewafer cyclic schedule with the lower bound of cycle time Θ=85 is obtained, which verifies Theorem 2.
With this topology of this example, by changing the activity time, four other cases are generated and studied in [Chan et al., 2011b] by using the method proposed there. For each of these cases, a multiwafer cyclic schedule is obtained. These cases are also studied by the proposed method and a onewafer cyclic schedule is obtained for each of the cases with the cycle time being less than that obtained in [Chan et al., 2011b].
Example 2
It is a 5treecluster tool composed of five singlearm cluster tools as shown in FIG. 1, where PS_{10 }is the LLs, PS_{20}, PS_{30}, PS_{40}, and PS_{50 }are incoming buffers for C_{2}, C_{3}, C_{4}, and C_{5}, PS_{12 }and PS_{13 }are outgoing buffers for C_{1}, and PS_{32 }and PS_{42 }are outgoing buffers for C_{3 }and C_{4}. The activity time is as: for C_{1}, (α_{10}, α_{11}, α_{12}, α_{13}, α_{14}; λ_{1}, μ_{1})=(0, 10, 0, 0, 10; 5, 2); for C_{2}, (α_{20}, α_{21}, α_{22}, α_{23}, α_{24}; λ_{2}, μ_{2})=(0, 70, 70, 58, 5; 3, 1); for C_{3}, (α_{30}, α_{31}, α_{32}, α_{33}, α_{34}; λ_{3}, μ_{3})=(0, 34, 0, 31, 4; 8, 1); for C_{4}, (α_{40}, α_{41}, α_{42}, α_{43}, α_{44}; λ_{4}, μ_{4})=(0, 100, 0, 100, 98; 1, 1); and for C_{5}, (α_{50}, α_{51}, α_{52}, α_{53}, α_{54}; λ_{5}, μ_{5})=(0, 100, 100, 100, 100; 1, 1). The wafer processing route is given in Section II. It contains three CTCs: CTC[3, 5], CTC[2, 2], and CTC[1, 1].
By η_{ij}=α_{ij}+4λ_{i}+3μ_{i}, ψ_{i1}=2(n[i]+1)(λ_{i}+μ_{i}), and Π_{i}=max{η_{i0}, η_{i1}, . . . , η_{i(n[i])}, ψ_{i1}}, for C_{1}, η_{10}=α_{10}+4λ_{1}+3μ_{1}=0+4×5+3×2=26, η_{11}=36, η_{12}=26, η_{13}=26, η_{14}=36, and ψ_{11}=70. We have Π_{1}=70 and C_{1 }is transportbound. For C_{2}, we have that η_{20}=15, η_{21}=85, η_{22}=85, η_{23}=73, η_{24}=20, and ψ_{21}=40. Then we have Π_{2}=85 and C_{2 }is processbound. For C_{3}, we have that η_{30}=35, η_{31}=69s, η_{32}=35, η_{33}=66, η_{34}=39, and ψ_{31}=90. Thus we have Π_{3}=90 and C_{3 }is transportbound. For C_{4}, we get η_{40}=7s, η_{41}=107, η_{42}=7s, η_{43}=107, η_{44}=105s, and ψ_{41}=20. Therefore, we have Π_{4}=107 and C_{4 }is processbound. For C_{5}, it is found that η_{50}=7s, η_{51}=107, η_{52}=107, η_{53}=107, η_{54}=107, and ψ_{51}=20. Hence we have Π_{5}=107 and C_{5 }is processbound. Since Π_{4}=Π_{5}≥Π_{i}, i∈N_{3}, and C_{4 }and C_{5 }are processbound, the 5treecluster is processdominant.
With the lower bound of cycle time being Π_{4}=Π_{5}=107, set Θ=107 as initial cycle time. By ψ_{i2}=Θ−ψ_{i1}, we have ψ_{12}=37, ψ_{22}=67, ψ_{32}=17, ψ_{42}=87, and ψ_{52}=87. By applying Algorithm 2 to CTC[3, 5], the cycle time is increased as Θ←Θ+Δ←Θ+((4λ_{3}+3μ_{3})−τ_{40})/(1+B*[4]+B*[5])=107+(35−21)/(1+3+3)=107+2=109. Then, Θ=109 is set for scheduling CTC[2, 2] and CTC[1, 1]. Then, given Θ=109, by applying Algorithm 2 to CTC[2, 2] and CTC[1, 1] sequentially, the cycle time Θ=109 is returned and ω_{ij}'s are set as: ω_{30}=19, ω_{31}=ω_{32}=ω_{33}=ω_{34}=0, ω_{40}=2, ω_{41}=14, ω_{42}=2, ω_{43}=4, ω_{44}=67, ω_{50}=ω_{51}=ω_{52}=ω_{53}=2, ω_{54}=81, ω_{10}=39, ω_{11}=ω_{12}=ω_{13}=ω_{14}=0, ω_{20}=24, ω_{21}=22, ω_{22}=23, ω_{23}=0, and ω_{24}=0. Hence, an optimal onewafer cyclic schedule with cycle time Θ=109 is obtained.
E. The Present Invention
The present invention is developed based on the theoretical development in Sections AC above.
An aspect of the present invention is to provide a computerimplemented method for scheduling a treelike multicluster tool to generate a onewafer cyclic schedule. The multicluster tool comprises K singlecluster tools C_{i}'s. The multicluster tool is decomposable into a plurality of CTCs each having a serial topology.
Exemplarily, the method makes use of the finding given by Theorem 1. In particular, the method comprises determining values of ω_{ij}, i=1, 2, . . . , K, and j=0, 1, . . . , n[i], such that (8)(10) are satisfied for any pair of C_{i }and C_{a}, in which i, a∈N_{K}, C_{a }being an immediate downstream tool of C_{i}.
In determining the aforesaid values of ω_{ij}, preferably a CTCCheck algorithm for computing candidate values of ω_{ij }under a constraint on Θ. The computation of the candidate ω_{ij }values is performed for at least one individual CTC. The CTCCheck algorithm for CTC[f, l] is configured to compute the candidate ω_{ij }values such that ω_{i(n[i]) }is minimized for each value of i selected from N_{[f, l−1]}. In one embodiment, the CTCCheck algorithm as used in the disclosed method is the one given by Section C.1.
Based on the CTCCheck algorithm, the values of ω_{ij}, i=1, 2, . . . , K, and j=0, 1, . . . , n[i], are determined as follows according to one embodiment of the present invention. First, the candidate values of ω_{ij }for the singlecluster tools in an individual CTC are determined by performing the CTCCheck algorithm under the constraint that Θ is equal to a lower bound of cycle time of the multicluster tool. This lower bound is a FP of a bottleneck tool among the K singlecluster tools, and is given by Π_{h}. If the candidate ω_{ij }values for the individual CTC are nonnegative, then the candidate ω_{ij }values are set as the determined values of ω_{ij }for the individual CTC. If at least one of the candidate ω_{ij }values for the individual CTC is negative, a minimum cycle time for the individual CTC is first determined and then the values of ω_{ij }for the individual CTC are determined by performing the CTCCheck algorithm under a revised constraint that Θ is the determined minimum cycle time for the individual CTC.
More particularly, it is preferable and advantageous that the values of ω_{ij}, i=1, 2, . . . , K, and j=0, 1, . . . , n[i], are determined according to the procedure given in Section C.3, where the procedure is embodied in Algorithms 1 and 2 detailed above. A summary of this procedure is given as follows. First identify an LCTC set consisting of first individual CTCs each having a leaf tool therein. It follows that one or more second individual CTCs not in the LCTC set are also identified. For each of the first individual CTCs, a minimum cycle time is determined, followed by determining the values of ω_{ij }by performing the CTCCheck algorithm under the constraint that Θ is equal to the determined minimum cycle time. For each second individual CTC, candidate values of ω_{ij }for each singlecluster tool therein are determined by performing the CTCCheck algorithm under an initial constraint that Θ is equal to a maximum value of the minimum cycle times already determined for the first individual CTCs. If the candidate ω_{ij }values for the second individual CTC are nonnegative, then the candidate ω_{ij }values are set as the determined values of ω_{ij }for the second individual CTC. If, on the other hand, at least one of the candidate ω_{ij }values for the second individual CTC is negative, then the following twostep procedure is performed. First, determine a minimum cycle time for the second individual CTC. Second, determine the values of ω_{ij }for the second individual CTC by performing the CTCCheck algorithm under a revised constraint that Θ is equal to the determined minimum cycle time for the second individual CTC.
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 particular, the method disclosed herein can be implemented in a treelike multicluster cluster tool if the multicluster tool includes one or more processors. The one or more processors are configured to execute a process of generating a onewafer cyclic schedule according to one of the embodiments of the disclosed method.
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.
Great research starts with great data.
Use the most comprehensive innovation intelligence platform to maximise ROI on research.
More Patents & Intellectual Property
 Optimally scheduling of closedown process for singlearm cluster tools with wafer residency time constraints
 Enterprise Patent & IP Solutions
 Improve R&D Innovation
 Intellectual Property (IP) Tools
 IP & Patent Strategies
 Market Intelligence for Innovation
 IP Data API
 Chemical Structure Search
 DNA Sequence Search
 Free Intellectual Property Courses
 IP & Patent Glossary