Optimal Scheduling for Automated Wetetch Stations with One Robot in Semiconductor Manufacturing via Constraint Answer Set Programming

1. Introduction

Both real-time data generated at the shop-floor level and data derived from interconnected internet applications represent a high volume (many terabytes daily). In addition, these data have a rapid rate of change and come from a broad range of sources, meaning that some data would be structured and, others would be unstructured. Although industrial production is a well-controlled process, the enormous amount of daily generated data makes it difficult to make decisions based on unstructured data. In addition, big data are characterized by a high volume, high velocity, and/or high variety of information assets that require new forms of processing to enable enhanced decision-making, insight discovery, and process optimization. Therefore, many industries are looking for semantic solutions in production process modeling. The advantage of the semantic approach is that data structuring to abstract entities is easier for humans to digest, guaranteeing correctness and accuracy in decision making. Semantic data and reasoning are required, especially because intelligent behavior is expected [1,2]. To fill the gap in semantic data, many authors are proposing a methodology based on ontologies and reasoning for modeling a smart factory to provide self-organization, self-learning, and self-adaptation as well as the use of formal languages and mature reasoning that contributes to the fulfillment of Industry 4.0 [3].

Following that order of ideas, this study explores the applicability of methodologies and inference engines based on non-monotonic logic for solving scheduling and optimization problems in manufacturing systems. Because of this research, we report a successful manufacturing application to a scheduling optimization problem for automated wet-etch stations (AWS) of a semiconductor manufacturing system (SMS). This application includes a robot for lot transportation between the baths of the AWS-SMS. Crama and Van de Klundert defined in their seminal research that a robotic flow shop such as the AWS is equivalent to a cluster tool, and both belong to the class of NP-complete problems [4].

The problem is solved using a hybrid approach based on Answer Set Programming (ASP), and Constraint Programming (CP) [6,7,8,9]. This hybrid approach is known as constraint answer set programming (CASP). ASP is a declarative language for knowledge representation and reasoning (KRR), and its theoretical fundamentals are based on non-monotonic reasoning (NMR). ASP has been used to solve combinatorial knowledge-based problems in many different areas. Among the most outstanding applications are the decision-making system of a spacecraft [10], planning for the generation of equipment in a shipyard [11], phylogenetic systems [12], autonomous vehicles in Car Assembly [13], and re-scheduling for an operating room [14].

Unfortunately, classical ASP results are inconvenient for applications with large domains, such as most scheduling problems. The ASP limitation stems from the solving process, which is divided into two stages: grounding and solving. In the grounding stage, all variables are substituted by constants of their respective domains. However, the grounding stage for large domains constitutes a bottleneck in the ASP solving process, because it can take an extremely long amount of time, or worse yet, turn the problem into an untreatable one. Therefore, CASP results in a more advantageous approach to the solution of the problem, because CASP integrates ASP with constraint processing. Moreover, CASP was designed to model and solve constraints over large and even infinite domains through constraint solver systems specifically designed for that purpose [15]. Some of these solvers are clingcon [16] and EZCSP [17].

In this application, the scheduler was encoded in CASP, and the solutions were obtained using the solver clingcon 2.0.3 [18]. At this point, it is important to clarify that, even though the original objective was to test the solution with data from a real company, this was not possible given the confidentiality politics of this type of business. Consequently, the alternative was to use a set of artificial data. For these purposes, the artificially created and published data by Bhushan and Karimi was selected [36].

The contribution of this study is twofold. First, we report the successful application of a novel methodology and technology to solve a real problem occurring in a high technology industry with an expensive process. Second, we show how a hybrid approach based on the CASP results is more adequate to treat problems with large domains, such as most scheduling problems in the industry. From the viewpoint of semiconductor manufacturing practice, the proposed solution in this paper provides an efficient way to obtain an optimized schedule for an AWS driven by a robot.

The proposed method has proven to be efficient and robust after several experiments in which it has been tested with different configurations and input data.

The rest of this paper is organized as follows. Section 2 is devoted to a literature review both related to the main topic of this research, Automated Wet Scheduling, and the literature regarding the methodologies applied to the solution of the actual research problem. Section 3 is dedicated to establishing the research motivation and formal description of the AWS problem. Section 4 shows the results of the experiments and compares and discusses these results with those obtained by other authors using other methodologies. Some concluding remarks complete the paper in Section 5.

2. Literature Review

Scheduling semiconductor manufacturing operations is a complicated problem because of various constraints such as sequence-dependent setup times, alternative machines, reentrancy, and complex product flows. In addition, SMS has two more important characteristics: a) the use of multi-clusters in the production process and, b) the inherent dynamism of its manufacturing due to its highly stochastic environment, where the occurrence of random events such as machine failures, arrival of new urgent jobs, and modification of a job during execution time is common.

Even though extensive scientific literature exists about typical problems occurring in an SMS, the purpose of this study is not to perform an extensive and detailed analysis of all literature in existence about it. Instead, a brief review of representative scheduling problems in SMS is done, and then we focus our interest on reviewing the state of the art regarding the topic of Automated Wet Etch Scheduling Problem.

2.1. Automated Wet-Etch Scheduling Problem

A recent paper on this topic is that by Ahn et al., who solved a scheduling and optimization problem related to chip semiconductor selection, known as the die-attach process. This process was formulated as a typical pick-and-place (PAP) problem. PAP is a well-known NP-hard problem that basically consists of finding the shortest path to pick the good dies and place them in the strip. The problem’s solution was approached with a Q-learning method using two agents to find the shortest path [20].

Another typical problem in semiconductor manufacturing is the use of multi-cluster tools as wafer fabrication equipment. Zhu et al. analyzed the scheduling of these tools [21]. They focused their research on scheduling the close-down process subject to wafer residency constraints. Generally, such processes are caused by wafer lot switches as well as preventive and emergency maintenance. The nature of these processes is dynamic and noncyclic. These researchers proposed a linear program to determine the robot waiting time before unloading the wafers. In their study, they considered a single-arm process for two cluster tools and found that whenever there is always a feasible schedule for the steady state, it is possible to obtain an optimal solution for the close-down process.

Meanwhile, a typical characteristic of semiconductor production is reentry. There is not much research about scheduling problems considering this complexity, but Li & Ma’s study not only addressed a re-entrant job shop scheduling problem, but also integrated preventive maintenance planning into the scheduling [22]. This optimization problem was solved using a hybrid particle swarm optimization algorithm. They used simulation experiments to evaluate the proposed model. The results of the experiment showed that their model works better than other independent decision models because they obtained a maximum completion time that is smaller than that of the nonintegrative models.

An example of dynamic scheduling in an SMS can be attributed to Ma et al. [23]. This study shows the development of a composite dispatching rule based on heuristic rules. The composite rule is obtained by exploring various states of a production line, such as machine status and queue size. Dynamic scheduling was obtained using the support vector regression (SVR) approach. SVR obtains dynamic scheduling knowledge from optimized scheduling samples. Then, it dynamically obtains and uses a composite dispatching rule to optimize production performance.

Regarding surveys about cases of study in SMS, we can refer to Fuchigami & Rangel [24]. Other interesting papers about surveys, challenges, and future directions of SMSs can be found in the papers by Mönch et al.; García-Mata et al.; Dequeant et al.; and Khakifirooz et. al. [25,26,27,28].

Now, we describe the wafer-etching process and analyze the literature on the AWS problem. The most intensive capital of a modern SMS is wafer production, which consists of four phases and is also a key part of the production process. Wafer fabrication is performed by applying successive layers of silicone or gallium arsenide and circuit patterns of metal and wafer material. To complete the wafer fabrication, each layer requires a similar set of unit processes, such as deposition, photolithography, development, ion implantation, diffusion, oxidation, and etching. The scheduling problem for an AWS and a transfer robot is related to two research areas: The first one focuses on the scheduling optimization problem for the transfer robot. The robot handles lot transferring through the machines. A generalization of this problem is known as the Hoist Scheduling Problem (HSP), and it is one of the most studied problems in Automated Manufacturing Systems (AMSs) because it represents a common problem arising in many automated systems in the industry [29]. HSPs are commonly found in automated electroplating lines, and numerous studies have been published about it. For example, Feng et al. solved the Dynamic Hoist Scheduling Problem (DHSP) for multi-capacity reentrant machines with a single hoist [30]. This problem was approached with a method based on mixed integer programming (MIP). Meanwhile Yan et. al. solved a similar problem for re-entrant workstations, but their optimization objective was dual, specifically reducing the cycle time and material handling cost simultaneously [31]. To solve the optimization problem, the authors proposed a hybrid discrete differential evolution (DDE) algorithm.

The second area involved in this research is precisely the AWS scheduling problem itself. However, since this process requires at least one robot for lot transference, most research includes robot scheduling in the solution. This optimization problem has been solved by numerous methods that can be grouped into two categories: (a) specific algorithms and, (b) generic methods. The first category has the disadvantage that the solutions have been designed with very specific characteristics in mind and consequently do not apply to different variants of the problem. As a result, specific algorithms are inconvenient for application in changing situations. The second category includes methods of operational research (OR) and artificial intelligence (AI). Some popular OR methods include integer, linear and dynamic programming (IP, LP, DP), computer simulation, PERT/CPM, queuing theory, inventory models, and game theory. One of the most popular OR methods for solving scheduling problems is mixed integer linear programming (MILP). Initial attempts to obtain an optimized solution to the AWS scheduling problem can be traced back to Bhushan and Karimi, who used the MILP method. They reported a near-optimum two-step strategy capable of solving moderately sized problems with a ranking of four baths and 14 jobs [19]. Karimi et al. improved the solution by redefining an integer variable as a binary variable [32]. Other authors reporting an optimized solution to the AWS problem with the exact MILP method are Aguirre et al., who presented three methods for modeling and solving this problem [33]. In this case, the solution included multiple robots. For smaller-sized cases, the authors developed a schedule that, simultaneously generates job-bath assignments and schedules the transfer operations for the robot. Meanwhile, for medium-sized problems, a sequential method was proposed, where production activities were first scheduled, followed by robot operations for lot transference. In addition, they presented some ideas for solving the problem with multiple robots.

The most popular AI methods used for the AWS scheduling problem are of three classes: a) meta-heuristics, such as genetic algorithms, particle swarm optimization, evolutionary algorithms, ant colony optimization, Tabu Search (TS), and Simulated Annealing (SA); b) statistics: Monte Carlo methods and neural networks in different variants; and c) rule-based methods: CP, ASP, and CASP [34].

Among the research reporting approaches based on AI methods to solve the AWS scheduling problem, one can read the paper by Geiger et al., which was one of the first cases to include a robot for lot transferences [35]. The metaheuristic TS with two heuristics was jointly used to minimize the makespan C_max: The profile fitting (PF) heuristic and the Nawaz-Enscore-Ham (NEH) heuristic. The authors reported that better results were achieved using NEH-TS. Later, Bhushan and Karimi proposed a solution based on TS and SA combined with a new specific algorithm for the same problem [36].

Meanwhile, Rotondo et al. proposed an optimization model for sequencing batches of wafers outside a wet-etch tool and scheduling of tool internal handler moves [37]. Unlike other authors, these studies address an application of a real manufacturing plant where the wet-etch tools’ internal mechanisms are not easy to modify because they are established by the tool vendor. Because of these limitations, they analyze batch sequencing and scheduling as separate problems. The sequencing module combines an exact optimization approach based, on an efficient permutation concept and a heuristic optimization approach based on GA.

However, only a few researchers have reported optimized solutions to the AWS scheduling problem using a combinatorial approach. One of them is due to Zeballos et al. who reported a successful solution with CP combined with different research strategies [38]. These authors reported experimental results with up to three robots, obtaining better results than those obtained by the MILP methodology combined with the Guided Variable Domain Reduction (GVDR) strategy. Similarly, Novas and Henning reported another successful solution for the same problem using the CP methodology, but they generalized the problem by implementing an innovative rolling horizon methodology that considers empty robot movements [39]. According to Novas and Henning, robot unload times must be considered because they greatly affect the resultant schedule. Most recently, Hegyháti et al. reported an optimal solution to an AWS scheduling problem with one and two robots using a different combinatorial approach [40]. Specifically, they used an S-graph framework to schedule a multipurpose batch, proposing an extension to this framework to solve the AWS scheduling problem. The authors cited in the last paragraph ultimately tested the implementation with different numbers of baths, jobs, and one and two robots. The maximum number of baths and jobs were 6 and 4, respectively. Although the solution was tested with one and two robots, satisfactory results were obtained with only one robot because the second robot negatively affects the processing time.

2.2. ASP and CASP

ASP is a totally declarative language that is oriented to solve applications on Artificial Intelligence. The most relevant feature of ASP is its capability to perform default reasoning or common-sense reasoning. ASP has also been designed to solve difficult combinatorial problems. ASP programs are not algorithms that describe how to solve a problem; a program is just a formal description of the problem. The solution is completely found by the solver.

ASP is derived from one of the most modern and successful semantic solutions, which implements the stable model semantic (SME) is due to Gelfond and Lifschitz [5]. There exists another semantic solution similar to the SME characteristics known as well-founded semantics (WFS) by Van Gelder et al. [41]. Both semantics are based on the idea of the acceptance of multiple minimal models (answer sets) for a description of the program’s meaning, unlike classical logic, in which a single model is accepted. These semantics are based on several types of non-monotonic logic, such as default logic, epistemic logic, and circumscription logic. One of the most relevant features of semantics SME and WFS is the ability to design logical programs with the rule “denial by default”, also called Negation as Failure (NAF) or Negation by Default. The presence of NAF provides natural support to commonsense reasoning because it allows expressing exceptions, restrictions, and making intelligent deductions in the presence of incomplete knowledge. Another important point to consider is that nowadays, there are several inference machines for ASP. The oldest one is smodels, but the most recent ones, such as clasp, have incorporated techniques from SAT and CSP technologies.

Answer set programs are defined by V=(P, D), where P is a set of predicates and D is a set of facts or domain of the problem. Predicates in P have an arity ≥ 0.

A problem can be encoded as a set of facts, rules and, constraints that describes the (candidate) solutions. An ASP program is a collection of rules of the form

$$a_o\leftarrow b_1,b_2, \cdots b_n, not b_m, {not b}_{m+1}\cdots {not b}_{m+k}$$

where each $a_i$ and each $b_i$ are atoms, and n, m, k ≥ 0. The left- and right-hand side of the clause are called the head and body, respectively. The head of a rule is a positive literal, and its body comprises literals (a literal is an atom a or its negation, denoted by not a). A rule without body is a fact. A rule without head is a constraint. In addition, the rules can be positive (n > 0); negative (m > 0), or both (n > 0 and m > 0). The symbol not represent default negation, also known as negation as failure. A program is a set of safe rules. If P is a ground, positive program, a unique answer set is defined as the smallest set of literals constructed from the atoms occurring in program P. The last definition can be extended to any ground program P containing negation by considering the reduct of P w.r.t. a set of atoms X obtained by the Gelfond-Lifshitz’s operator [5] is given by

$$P^X=\left\{H\right(r)\leftarrow B^{+}(r) | r\in P, X\cap B^{-}\left(r\right)=\varnothing \}$$

In some ASP systems, such as clingo, language extensions such as choice rules, conditional choice rules, and aggregates are supported. Choice rules have the form: $l \{{ a}_1;\cdots ;{ a}_n;\cdots ; not { a}_{n+1};\cdots ; not { a}_o\} u\leftarrow b_1,{\cdots b}_k, not b_{k+1},\cdots , {not b}_m.$Conditional rules are written as $l \{ L_o : L_1, \cdots , L_n\} u$. For both rules, l and u ≥ 0, and specify the lower and upper bounds, respectively; for the conditional rule $L_i(0\le i\le n)$. Meanwhile, syntaxis aggregates have the form α {w₁ : a₁, . . . , w_m : a_m, w_m+1 : ¬a_m+1, . . . , w_n : ¬a_n} ≺ k. Where a represents a function mapping multisets Z to Z ∪ {+∞, −∞}; ≺ stands for the relation between Z ∪ {+∞, −∞} and Z; $k\in Z$; $a_i$ are atoms, and $w_i$ are integers. Aggregates were designed to provide a general way to obtain a single value from a collection of input values. There are some aggregates, in this solution are used the count and minimum aggregates.

Furthermore, non-monotonic logic and ASP are very active and dynamic area, where language extensions and better techniques for the development of the solvers are constantly being proposed [16,42,43].

Meanwhile, there is currently a trend toward solving difficult problems through hybrid approaches, combining algorithms and systems from different AI subfields. The Satisfiability Modulo Theories (SMT) are, a well-known example [44,45,46]. The objective of SMT is to satisfy the logical formulas of one or more different theories. Unfortunately, SMT problems belong to a very high complexity class; hence, it is impossible to build an inference machine that can arbitrarily solve any SMT problem.

CASP is a recent and promising research area that integrates ASP and CP methodologies; it follows the SMT solving approach and combines the clasp ASP solver with the gecode CP. Additionally, CASP supports the modeling language gringo, which is the ASP grounder [8,16,47]. CASP improved the capacity of ASP to deal with large domains that occur in many practical problems such as scheduling and planning. For such domains, the grounding process is so time consuming that it turns the problem into an untreatable one. However, CASP uses a different mechanism to model constraints over large domains based on non-Boolean constraints from the CP area, combining a simple modeling language with a high [7,8].

3. Materials and Methods

3.1. Production Model

SMSs are among the largest and most hi-tech industries in the world. This type of factory is a very capital-intensive business. The SMS process comprises four phases: wafer fabrication, wafer probe, assembly, and testing. One of the most complex operations is wet etching, which is usually performed in a set of AWSs, and it is also the most intensive capital of the production process. The production processes are very complex and require up to 700 single processing steps and up to 3 months to produce. Typically, the production process comprises dozens of process flows, each of which requires more than 100 machines [25]. Many production models co-exist in an SMS, such as job-shop, flow-shop, and parallel machines. It is also necessary to deal with processes that can require batching or serial production, sequence-dependent setup times, tight due dates, no-wait operations, reworking of a part of wafers, and even more complex developments [48].

The AWS manufacturing process is carried out in batches and consists of the following processes and operations:

a) The wafer is covered with a thin uniform layer of silicon oxide (SiO₂) or gallium arsenide (GaAs).

b) Portions of the wafer are selected and marked to form the circuit configuration (photolithography or photo-masking).

c) Etching is applied; it is a key step in the manufacturing of the wafer. This process is performed by one or more highly automated stations:

d) At these stations, excess film of SiO₂ or AsGa is eliminated in a series of chemical and deionizing baths.

e) The batches of AWS wafers are all of the same type and come from previous processing.

f) The lots are subject to processing in chemical and water baths arranged alternatively.

g) The batches are transferred by one or more robots between the baths. In the study case of this research, only one robot is considered for material transfer. Lot transference is performed by a robot on the order of milliseconds and can be different for each pair of baths.

h) The chemical baths follow a zero-wait storage policy and can never be used as temporal buffering (Zero Wait/No Intermediate Storage, ZW/NIS) because chemical overexposure can damage the wafers.

i) The water baths are used for storage (LS).

j) The processing time for each lot depends on the lot and bath.

k) In each bath, one lot can only be processed at a time.

l) It is assumed that the baths and the robot are never out of order.

This study reports a solution to the AWS scheduling problem using one robot. Once the schedule is obtained, an optimized solution is searched with the minimum makespan as the objective function. According to the production process, all jobs are processed sequentially on all baths, always starting at the first machine and, ending at the last one. The jobs are uninterruptible.

3.2. Problem Definition

ASP is a language with many remarkable characteristics that make it suitable for solving a myriad of complex problems. However, there is one characteristic that distinguishes it: the ability to represent problems at an abstraction level, which is similar to a mathematical definition. Consequently, in this section, the problem encoding closely follows a formal definition of the problem.

Since the AWS production process must fulfill strict constraints, known as ZW and Local Storage (LS) policies, modeling the AWS problem can be generalized to a serial flow-shop

Multiproduct process with mixed intermediate storage policies (MIS). Figure 1 shows a schematic representation of a linear AWS with one robot.

3.3. Notations and Nomenclature

Indexes

j - lot;

b – bath;

r – robot.

s – start time

c – completion time

Sets

J - set of lots or job wafers with j∈ J = {1, . . . , |J|-1}.

T - set of discrete time slots t∈ T = {0, . . . , |T|-1}. Where T is the scheduling period.

B - set of k renewable resources (k is the pre-established number of units of a resource that is available for each period of the planning horizon T). In this case, B is the set of baths and each b ∈ B. The arrangement of the baths is alternating, starting with a chemical bath, followed by a water bath, where B = {B_ch, B_w }; B_ch = {B₁, B₃, B₅,..., B_K-1}; B_w = {B₂, B₄, B₆,..., B_K}; B_ch∩ B_w = ∅; B_ch ∪ B_w = B.

R - is the set of robots for job’s transference among baths r∈ R = {1, . . . , |R|-1}. . In this solution, only one robot was used.

Each job j has several properties:

The processing of job j in bath b are uninterruptible.

Usually, the processing times of each job j and, each bath are different. The job’s duration $d_{j,b}$ identifies the time of residence of job j in bath b.

A solution contains the following assignments for each job j and, each bath b

-

$t_{j,b}^s \in T$ the scheduled start time slot for j processing in bath b

-

$t_{j,b}^c \in T$ the scheduled completion time for j processing in bath b

-

$b_j\in B$ the bath assigned to job j

-

$t_{r,j,b_{m,b_n}}^s \in T$he scheduled start time slot for robot r transfer the job j from bath $b_i$ to bath $b_j$

-

$r_{j,b_{m,b_n}}^c \in T$ the scheduled completion time slot for robot r finishes the job transfer from bath $b_m$ to bath $b_n$

-

$D_{d }\in T$ the deadline for finishing processing all the jobs.

3.4. Constraints and Function Definitions

A formal description of this problem relapses in a series of constraints that will be discussed later. First, a formal definition of a job is developed as follows: A job j is a pair <machines, dur>, where machines is a set of baths in which the jobs are processed, and dur is the processing time required to finish each job in each bath. J is the set of jobs, and it is defined by the pair <Λ, ORDER>, where Λ is the set of jobs and ORDER is a directed acyclic graph resulting from the Λ elements. Intuitively, ORDER describes the order in which the jobs must be processed. Each arch ${<j}_i,j_{i+1}>$ indicates that the processing of job $j_i$ must precede the processing of job $j_{i+1}$. Given that the problem being solved is a flow shop problem, the jobs must be sequentially processed, and consequently, the processing of job ji must be finished before job ji+1 begins its processing. The constraints considered in the problem modeling are described in the next definitions.

Definition 3.4.1. 

The interval between the start and completion of a job, must match the job’s duration for each bath.

$${\forall }_{j\in J}, {\forall }_{b\in B} : t_{j,b}^c-t_{j,c}^s=p_{j,b}$$

Definition 3.4.2. 

The interval between the start and completion of a robot’s job transference, must match the established robot’s duration transference among baths.

$${\forall }_{r\in R}, {\forall }_{b\in B} : t_{r,b_m,b_n}^c-t_{r,b_m,b_n}^s=d_{j,b}$$

Definition 3.4.3. 

Some job must start in the first bath at time one.

$${\exists !}_{j\in J} : {(t}_{j,b}^s=1) \wedge (b=1)$$

Definition 3.4.4. 

To detect overlap among different jobs in the same bath.

$${\forall }_{j_u, j_v\in J},{\forall }_{r\in R}:\left(j_u\ne j_v\right)$$

$$\wedge (t_{j_u,b_m}^s {\le t}_{j_v,b_m}^s) \wedge (t_{j_u,b_m}^s+p_{j_u,b_m}+{ t}_{r,b_m,b_n}^s) {>t}_{j_v,b_m}^s$$

Definition 3.4.5. 

It is necessary to detect if some job starts processing in the next bath before than finishes it finishes its processing in the actual bath and if the batch has also been completely transferred to the next bath.

$${\forall }_{j\in J}, {\forall }_{b\in B} : {{(b}_n=b}_m+1)\wedge (t_{j,b_n}^s<t_{j,b_m+}^s p_{j, b_m}+d_{j,b})$$

Definition 3.4.6. 

It is also necessary to detect situations in which there is overlap of the same job in continuous baths.

$${\forall }_{j\in J},{\forall }_{b\in B},{\forall }_{r\in R}:\left(b_n=b_m+1\right)\wedge$$

$$(t_{j,b_m}^s {\le t}_{j,b_n}^s)\wedge (t_{j,b_m}^s+p_{j,b_m}+{ t}_{r,b_m,b_n}^s) t_{j,b_n}^s$$

Definition 3.4.7. 

To fulfill the constraint that jobs finishing in a chemical bath (chemical baths are odd), must immediately be transferred by the robot onto the next bath. In other cases, this solution must be deleted.

$${\forall }_{j\in J}, {\forall }_{b\in B} : {(b}_n=b_m+1)$$

$$\wedge {(b}_m\backslash 2>0)\wedge ({ t}_{r,b_n }^s \ne { t}_{j,b_m}^s+p_{j, b_m}+d_{j,b})$$

Definition 3.4.8. 

This constraint deals with the case where a job processing in a chemical bath does not start its processing in the next bath immediately after finishing its processing in the chemical bath and finishes its transfer to the next water bath.

$${\forall }_{j\in J}, {\forall }_{b\in B},{\forall }_{r\in R} :$$

$${(b}_n=b_m+1)\wedge {(b}_m\backslash 2>0)\wedge ({ t}_{r,j,b_m }^s \ne { t}_{j,b_m}^s+p_{j, b_m} )$$

Definition 3.4.9. 

There are two rules to detect when a robot is out of phase to perform the transference: one of them is to detect an out of phase in the chemical baths, and the second is to detect an out of phase for water baths. Here, we define the first one, which applies to robot transfer from a chemical bath to a water bath.

$${\forall }_{j\in J}, {\forall }_{b\in B} : {(b}_n=b_m+1)\wedge {(b}_m\backslash 2>0)\wedge$$

$$({ t}_{r,b_m }^s \ne { t}_{j,b_m}^s +p_{j, b_m})$$

Definition 3.4.10. 

The second rule detects when the robot is out of phase, going from a water bath to a chemical bath.

$${\forall }_{j\in J}, {\forall }_{b\in B} : {(b}_n=b_m+1)\wedge {(b}_m\backslash 2=0)\wedge ({ t}_{r,b_m }^s<{ t}_{j,b_m}^s +p_{j, b_m})$$

Definition 3.4.11. 

The next constraint was designed to detect an overlap among the robot transference from a water bath to the next one, and the robot transfer appears to overlap with another robot transfer starting in another bath that is not necessarily continuous.

$${\forall }_{j\in J}, {\forall }_{b\in B}, {\forall }_{r\in R} : {(b}_m\backslash 2>0){\wedge (b}_n\ne b_m+1)\wedge$$

$$\left({ { t}_{j,b_m}^s+p_{j, b_m}=t}_{r,b_m }^s\right)\wedge \left({ t}_{j,b_m}^s+p_{j, b_m}+d_{j,b_m,b_n}={ t}_{j,b_n}^s \right)\wedge$$

$${( t}_{r,b_m}^s \le { t}_{r,b_n}^s ) \wedge {( t}_{r,b_m }^s+d_{j,b_m>}{ t}_{r,b_m }^s >{ t}_{r,b_n}^s)$$

Definition 3.4.12. 

Unlike the previous definition, this constraint was designed to detect an overlap among the robot transfers from a chemical bath to a water bath, and it appears that the robot starts transferring a lot from a different that is not the next one.

$${\forall }_{j\in J}, {\forall }_{b\in B}, {\forall }_{r\in R} : {(b}_m\backslash 2=0){\wedge (b}_n\ne b_m+1)\wedge$$

$$\left({ { t}_{j,b_m}^s+p_{j, b_m}<t}_{r,b_m }^s\right)\wedge \left({ t}_{j,b_m}^s+p_{j, b_m}+d_{j,b_m,b_n}\le { t}_{j,b_n}^s \right)\wedge$$

$${( t}_{r,b_m}^s \le { t}_{r,b_n}^s ) \wedge {( t}_{r,b_m }^s+d_{j,b_m>}{ t}_{r,b_m }^s)$$

Definition 3.4.13. 

Besides the two other cases where it is possible that there exists a third case of overlap in the use of the robot. In this last case, overlap in the use of the robot transfer occurs among different jobs. This constraint is expressed as follows.

$${\forall }_{j\in J}, {\forall }_{b\in B}, {\forall }_{r\in R} : (J_{u }\ne J_{v }) \wedge$$

$${( t}_{r,j_u,b}^s \le { t}_{r,j_v,b}^s ) \wedge {( t}_{r,j_u,b}^s+d_{j_{u}b}>{ t}_{r,j_v,b}^s )$$

Definition 3.4.14. 

Another case related to overlap occurs when the robot starts transferring the lot before its processing in some bath has finished, and besides, there is an overlap among a different transference with the same robot, but from the next bath.

$${\forall }_{j\in J}, {\forall }_{b\in B}, {\forall }_{r\in R} : {(b}_n=b_m+1) \wedge$$

$${({ t}_{j,b_m}^s+p_{j, b_m}\le t}_{r,j,b_m}^s )\wedge ({ t}_{r,j,b_m}^s+d_{{j,b}_m }>{ t}_{j,b_n}^s)$$

Definition 3.4.15. 

This constraint was designed to detect jobs that will finish after the deadline.

$${\forall }_{j\in J}, {\forall }_{b\in B}, {\forall }_{r\in R} : ({ t}_{j,b_m}^s+p_{j, b_m}+d_{{j,b}_m }>D_{d })$$

Definition 3.4.16. 

There are cases where the robot starts to transfer the lot before this lot finishes the processing in the actual bath, and there is not enough time for the robot to finish the transfer before the deadline.

$${\forall }_{j\in J}, {\forall }_{b\in B}, {\forall }_{r\in R} : {(b}_n=b_m+1)$$

$$({ t}_{j,b_m}^s+p_{j, b_m}<{{ t}_{r,b_m }^s)\wedge ( { t}_{r,j,b_m}^s+d_{{j,b}_m }>D}_{d })$$

3.5. Encoding the Problem in CASP

As previously stated, the main objective of this research is to explore ASP capabilities to solve large problems, e.g., scheduling problems. Therefore, the first intent was to use plain ASP to encode the problem. The solver chosen was clingo 4.4. However, the set of combinations for these types of problems is extremely large. For example, in scheduling and planning problems, it is necessary to include time variables per time unit and for each variable combination to create the schedule or plan. Consequently, the bottleneck generated during the grounding step was a main obstacle to solving the complete problem, and it was only possible to obtain a partial solution of the problem with four jobs and four baths. Problems with input data beyond this size were untreatable using this approach. The obtained results are not outstanding considering that the problem under study is NP-hard [49]. On the other hand, the approach in CASP solvers is different and considerably reduces the solving time.

The combinatorial nature of the problem and the ASP difficulties during the grounding clearly showed that a different approach was required to solve the problem. The CASP approach was a natural selection to solve this problem because it is an extension of ASP and is capable of efficiently finding an optimal solution. In the next step, the problem is encoded according to the CASP extensions for ASP proposed by [15] and solved with the solver clingcon 2.0.3 [15]. The characteristics of the computer hardware used in the solution are as follows: intel i7 processor, 1.8 Ghz, 6 Gb memory, OS Ubuntu, 64 bits. For the problem in this study, it is assumed that the AWS is disposed linearly and has a single robot for batch transference (see Figure 1).

The processing times required for each job and each bath are defined for the next predicate using the following three parameters:

duration(j, b, pjb)

where j represents a job and is an integer with values in the range (1..n); b represents a bath and its range goes from (1..k); and $p_{j,b}$ represents the processing times for job j in bath b. Note that the robot transfer times between the baths correspond to the predicate

tRobot(r, k, mb,b+1),

where r represents the robot. In this case, only one robot was used; b represents a bath index in the range (1..k); mb,b+1 represents the transfer time from bath b to bath b+1.

The number of jobs, baths, and robots is given by the constants j, b, and r, respectively. The value ranges for each one are:

monospace>bath(1..b). numBaths(b).

(3.5.1)

job(1..j). numJobs(j).

(3.5.2)

The time values were defined as global variables, with the constant deadline representing the time limit to finish all jobs.

$domain(1..deadline).

(3.5.3)

The problem was encoded conforming to the known methodology GENERATE, DEFINE and TEST. The GENERATE section is composed of two rules. One rule is used to create all combinations of the job, bath, and duration. The second rule in this section is used to generate the combinations including the jobs, baths and processing times for the robot. It is important to clarify that in the next rules, P and P′ are variables related to jobs; M and M′ are variables related to baths; D and D′ are variables containing the job processing duration; and Tr and Tr′ are variables about the robot transference time for a given bath.

1{moveBatch(P,M,Tr) }1:- job(P), bath(M), tRobot(R,M,Tr).

(3.5.4)

1{do(P,M,D) }1:- job(M), bath(M), duration(P,M,D).

(3.5.5)

The combinations for the predicates moveBatch and do were transformed into global constraints using the operator distinct of clingcon as follows:

$distinct{iniJob(P,M) : do(P,M,D)}.

(3.5.6)

$distinct{beginRobot(P,M) : moveBatch(P,M,Tr)}.

(3.5.7)

In the DEFINE section, the problem constraint rules were implemented. The implementation in CASP of selected constraints defined in Section 3.4, are next showed.

Rule 3.5.8 implements Definition 3.4.3. This rule is needed to ensure that in any solution, there exists one job initiating in the first bath at the first instance.

$count[iniJob(P,M) $==1 : do(P,M,D) : M==1] $==1.

(3.5.8)

To ensure the strict sequential processing of jobs in consecutive baths (Definition 3.4.2), this constraint is implemented in rule 3.5.9. In this rule, the sequences do(P,M, D) and do(P,M′,D′) represent the assignment of job P to different baths M and M′, and the processing of job P in bath M precedes the processing of job P in bath M′. Also, M′ must be the bath that follows immediately after M.

badSeq(P,M,D,M′,D′):- do(P,M,D), do(P,M′,D′), moveBatch(P,M′,Tr), M’==M+1, iniJob(P,M′) $<

(iniJob(P,M) $+ D $+ Tr).

(3.5.9)

A possible job overlap is of two types: a) jobs P and P′, where P ≠ P′ overlap in the same bath, and; b) the same job P is assigned to two different and sequential baths, M and M′, in overlapping times. The first case corresponds to Definition 3.4.4, and the second case corresponds to the definition in 3.4.6. The implementations appear in rules 3.5.10 and 3.5.11, respectively:

overlapBJ(P,M,D,Tr,P′,D′):- tRobot(R,M,Tr), do(P,M,D), do(P′,M,D′), P != P′, iniJob(P,M) $<= iniJob(P′,M)

$and iniJob(P,M) $+ D $+ Tr $> iniJob(P′,M).

(3.5.10)

overlapJB(P,M,D,Tr,M′,D′):- moveBatch(P,M,Tr), do(P,M,D), do(J,M′,D′), M′==M+1,

iniJob(P,M) $<= iniJob(P,M’)

$and iniJob(P,M) $+ D $+ Tr $> iniJob(P,M′).

(3.5.11)

The implementation of the NZW’s policy, expressed in Definition 3.4.8, consists of the following: as soon as a job P finishes processing in a chemical bath M, it must be transferred to the next bath M′, which is a water bath. If the transfer is not performed immediately, the wafer could suffer damages. This policy is implemented in rule 3.5.12:

chemicalNZWrobot(P,M,D,Tr):- do(P,M,D), do(P,M’,D’), moveBatch(P,M,Tr), M\2>0, M’==M+1,

beginRobot(P,M) $!= (iniJob(P,M) $+ D).

(3.5.12)

In the TEST section, the heads of the previously implemented constraint rules in the DEFINE section are written as constraints in ASP language. The constraint syntaxis in ASP are written as rules without heads, and semantically mean that Answer Sets o Solutions where constraints are true, must be deleted of the solutions set to guarantee that constraints are fulfilled and the solution is correct. In this section, only the constraint rules related to the rules (3.5.9 to 3.5.12) are shown.

:- badSeq(P,M,D,M′,D′).

(3.5.13)

:- overlapJB(P,M,D,Tr,M′,D′).

(3.5.14)

:- overlapBJ(P,M,D,Tr,P′,D′).

(3.5.15)

:- chemicalNZWrobot(P,M,D,Tr).

(3.5.16)

Finally, makespan minimization is performed with the operator min:

$minimize{iniJob(P,Nb) $+ D $+ Tr : do(P,Nb,D)

: numBaths(Nb) : moveBatch(P,M,Tr)}.

(3.5.17)

Although there are many study cases in the scientific literature related to scheduling problems in SMSs, only a few have focused directly on the AWS problem. Various approaches have been attempted; however, no evidence has been found that the solution to the problem has been addressed using theories and techniques based on non-monotonic logic.

4. Results

4.1. Input Data

One main obstacle to the experiments was access to the database of a real company. After performing an unsuccessful search for real data, a series of data was used that were artificially created and published by Bhushan and Karimi [36]. These data have also been used by other researchers such as Zeballos et al. [34].

In this research, the solution of the AWS scheduling problem with one robot was first intended in plain ASP; experimental results showed no solutions for more than four baths and four jobs. This unsuccessful experiment can be explained by the known grounding’s bottleneck of ASP. Consequently, it was necessary to analyze and solve the problem using a hybrid approach. Specifically, the ASP extension for CP selected was the one developed for solver clingcon 2.0.3. This clingcon version uses the generic CP solver gecode 3.7.1 for the grounding step and clingo 3.0.4 for the solving step.

However, the direct use of these data was not possible in either ASP or CASP, because they have values that belong to the set of real numbers and ASP and CASP work exclusively with integers. To eliminate fractional values, the job processing and robot transfer times were multiplied by 10. After the problem was solved, the obtained solution values were divided by ten to compare our results with those of Zeballos et al. [34].

4.2. Design of the Experiment

For comparative purposes, this experiment was presented in a manner similar to that of Zeballos et al. [34], with only minor differences. The problem was solved on a computer with an Intel processor, Core i5.3337 CPU@1.80 Ghz X4; memory 5.6 Gi.

The problems identified in Table 4 with the numberings P1 to P6 and P9 were solved using the data shown in Table 1. Problem P7 was solved using the data in Table 2. For all cases transfer times of the robot are shown in Table 3. The results of this experiment are presented in Table 5.

4.3. Discussion of the Results

Analyzing the results of the experiments shown in Table 5, through the CASP approach, results show that this approach is more suitable for solving problems with a huge number of combinations than plain ASP. With CASP, both the first and optimal solutions were found. However, with ASP, it was not possible to solve problems with more than four jobs and four baths.

Although ASP is a paradigm that has been successfully used for the solution of many complex problems involving incomplete reasoning, th experimental results obtained in this research show that ASP alone is inadequate for the solution of combinatorial optimization problems that involve a huge search space, as is the case for the AWS problem. This flaw in ASP results from the bottleneck that occurs during the grounding stage. To precisely overcome this disadvantage, some extensions such as CASP have been developed; CASP has a mechanism to enable modeling restrictions on huge domains, where these are processed in a different way than is typically done in ASP, thereby greatly reducing the grounding time.

To assess the quality of the obtained schedules, we compared the results obtained in this investigation with those obtained by other authors for the same AWS scheduling problem. In particular, Table 6 shows a comparison of our results obtained with the CASP/clingcon approach versus two other studies, which are as follows: a) the results published by Zeballos et al. [34] with the CP+GVDR method, and; b) the results published by Bhushan and Karimi [19] who used a MILP approach. The scheduling results, both for the baths and for the robot, are also graphically shown in Figure 2.

Now, examining the results shown in Table 6, it can be observed that the minimum makespan obtained with CASP is very similar to the results obtained with CP+GVDR, but the latter was slightly better for problems P1, P2, P5, and P9, and CASP obtained a smaller makespan value for problems P3, P6, and P7. In terms of computing time for the first solution, the best results were obtained from CASP, for all cases. Finally, the approach CASP is clearly superior for all cases in terms of time performance compared with MILP and CP + GVDR. Moreover, it is possible to observe that the times used to obtain an optimal solution with CASP are smaller than those with MILP and CP + GVDR by up to two orders of magnitude in most cases. These results confirm the practical effectiveness of the CASP approach in solving complex scheduling problems with huge domains.

Scheduling results shown in graphic 5 let us infer that the resultant schedule is rigth because it fulfill the constraints established during the modeling step, such as the zero-wait storage policy for chemical baths; each bath processes only one lot at a time and there are not overlap among the limited resources in this problem, that is, the baths and robot; the jobs are processed sequentially in each bath, fulfilling the flow-shop model corresponding to the problem description, and; the scheduling robot is adjusted to transfer each lot from one bath to another according to the constraints established for this problem and following the processing transfer times of Table 3.

5. Conclusions

In this paper, we have presented a solution approach for the AWS scheduling problem in SMSs with one robot using CASP. These results indicate that one hybrid paradigm based on ASP and CP is well placed for the solution of complex problems with huge domains, where the search space grows exponentially in relation to the input. The exploration of new approaches to solve scheduling problems is justified because they have taken a central place in multiple industries and businesses. In addtion, the increasing diversity in markets and products demands better plans and more adjusted schedules.

Another additional advantage to using CASP instead of other different paradigms is the possibility of easily extending the model and its implementation, taking advantage of the non-monotonic characteristics of the ASP. Therefore, unexpected events, such as machine breakdowns or the arrival of urgent orders, can be included and rescheduling can be solved with this same approach.

The paradigm selected for solving this problem also facilitates the integration of the task scheduler into a general planner. In this way, both the planner and the scheduler can be fed with information coming from other manufacturing levels, such as sales, warehouse, chain of suppliers, or any other information related to the production process.