Optimal Scheduling of Material Handling Devices in a PCB Production Line: Problem Formulation and a Polynomial Algorithm

Abstract

Modern automated production lines usually use one or multiple computer-controlled robots or hoists for material handling between workstations. A typical application of such lines is an automated electroplating line for processing printed circuit boards (PCBs). In these systems, cyclic production policy is widely used due to large lot size and simplicity of implementation. This paper addresses cyclic scheduling of a multihoist electroplating line with constant processing times. The objective is to minimize the cycle time, or equivalently to maximize the production throughput, for a given number of hoists. We propose a mathematical model and a polynomial algorithm for this scheduling problem. Computational results on randomly generated instances are reported.

1. Introduction

Modern automated production lines usually use one or multiple computer-controlled robots or hoists for material handling between workstations. A typical example is an automated electroplating line for processing printed circuit boards (PCBs). Such a production line usually consists of a loading station, a sequence of chemical tanks, an unloading station, and a crew of identical programmable hoists, as shown in Figure 1. Parts to be processed enter the system from the loading station, and then are processed successively through tanks, and finally leave the system from the unloading station. Each tank contains chemicals required for a specific electroplating step in the processing of parts such as acid cleaning, acid activating, copper plating, rinsing, and so on. Each tank can process only one part at a time. The processing time in a tank may be a given constant or allowed to vary within a given window. Due to specific characteristics of chemical treatment, as soon as the processing operation of a part is completed in a tank, it must be immediately removed from that tank and transported to the next one without any delay. Otherwise, defective parts may be produced due to oxidization and contamination. In an automated electroplating line, the movements of parts between the tanks are performed by a crew of computer-controlled hoists on a single track. By optimizing the sequence and start times of the hoist moves, we can optimize the throughput of the line. This problem is commonly known as the hoist scheduling problem in the literature [1–9].

Figure 1 

An automated multihoist electroplating line for processing PCBs.

Due to large lot size in electroplating operations, the production is often organized in a cyclic manner, and only one part type is processed repeatedly in the line in a production period. In such a cyclic production system, the hoists are programed to perform a fixed sequence of moves repeatedly. Each repetition of the sequence is called a cycle. The duration of a cycle is called the cycle time or the cycle length. Normally, one raw part enters and one finished part leaves the line within a cycle. The throughput rate is the inverse of the cycle time. Therefore, minimizing the cycle time is equivalent to maximizing the throughput of a production line.

This paper addresses cyclic scheduling of a multihoist electroplating line with constant processing times, that is, the processing times of a part in tanks are constants. This type of scheduling problem arises typically from high-precision electroplating systems, in which the quality of treatment of a part mainly depends on its processing times in tanks. In literature, some studies (e.g., [1, 3–5, 7, 8, 10–12]) deal with the scheduling problem with time windows, that is, the processing time of parts in each tank must fall into a given time window. This problem is NP-hard both for the single-hoist case and for the multihoist case. Hence, the researchers proposed heuristics or branch-and-bound algorithms for the single-hoist or multihoist scheduling problem with time windows. It should be noted that the polynomial algorithm developed in this paper for the problem with constant processing times can be served as a heuristic for the problem with time windows.

For the scheduling problem with constant processing times, Agnetis [13] developed polynomial algorithms for lines with two or three tanks and a single hoist for material handling. The same problem for any given number of tanks was shown to be solvable in polynomial time by Levner et al. [14]. Che and Chu [6] extended Levner’s work and developed an efficient algorithm for single-hoist electroplating lines with multifunctional and/or duplicate tanks. As the number of tanks increases, material handling between the tanks often becomes bottlenecks. To eliminate such bottlenecks and increase the throughput, it is a common practice to use more than one hoist in an electroplating line with more than 10 tanks. Karzanov and Livshits [15] appear to be the first authors to study the cyclic multihoist scheduling problem. They studied the system with parallel tracks (i.e., hoists travel along their respective tracks) and proposed an 𝑂(𝑁³) algorithm to find the minimal number of hoists for a given cycle time, where N is the number of tanks in a production line. Kats and Levner [16] extended their results and found that the problem of minimizing the number of hoists for all possible cycle times can be solved in 𝑂(𝑁⁵) time. Kats and Levner [17] also developed an 𝑂(𝑁³log𝑁) algorithm for the multihoist scheduling problem for a given hoist assignment.

In the above studies, the researchers assumed that the hoists travel along their respective parallel tracks and, therefore, the collision avoidance among the hoists was not addressed. However, almost all practical electroplating lines have only one available track. This paper addresses the single-track, multihoist scheduling problem with constant processing times. When the hoists travel along a common track, the problem is much more complicated than that with parallel tracks. With parallel tracks, it is not required to address collision avoidance constraints among the hoists and the problem can be reduced to either an assignment problem or a simple variant of a single-hoist problem if the hoist assignment is given. However, for electroplating lines with a single track, we must address the collision avoidance constraints among the hoists either on the track or on the tanks. As will be shown in this paper, the solution of the problem with a single track differs from that for parallel tracks. Liu and Jiang [18] proposed an efficient algorithm for the single-track, two-hoist scheduling problem with constant processing times. In this paper, we develop a mathematical model and a corresponding polynomial algorithm for the single-track, multihoist scheduling problem with constant processing times.

2. Problem formulation

Consider an electroplating line consisting of a loading station 𝑀₀,𝑁 chemical tanks, 𝑀₁,𝑀₂,…,𝑀_𝑁, and an unloading station 𝑀_𝑁+1. The stations or tanks are arranged in a row from left to right in the following order: 𝑀₀,𝑀₁,…,𝑀_𝑁,𝑀_𝑁+1, as shown in Figure 2. A single type of parts is to be processed in the line. The part flow can be described as follows. After a part is removed from 𝑀₀, it is processed successively through tanks 𝑀₁,𝑀₂,…,𝑀_𝑁 and finally leaves the system from 𝑀_𝑁+1. Each tank can process at most one part at a time and the processing time in 𝑀_𝑖 is a given constant 𝑡_𝑖. There are K identical hoists on a single track, which are responsible for transporting parts between the tanks. Without loss of generality, we assume that the hoists are numbered, from left to right, from 0 to 𝐾−1, as shown in Figure 2. For simplicity, the hoist movement of transporting a part from 𝑀_𝑖 to 𝑀_𝑖+1 is called move𝑖,0≤𝑖≤𝑁. Each move i consists of three simple hoist operations: (1) lift up a part from 𝑀_𝑖; (2) transport the part to 𝑀_𝑖+1; and (3) lower the part onto 𝑀_𝑖+1. The time required for the hoists to perform move 𝑖,𝑖=0,1,…,𝑁, is 𝜃_𝑖, where lifting up a part from 𝑀_𝑖,𝑖=0,1,…,𝑁, and lowering a part onto 𝑀_𝑖,𝑖=1,2,…,𝑁+1, take 𝑣_𝑖 and 𝜇_𝑖, respectively. The hoist movement without transporting any part is called a void move. The time for the hoists to perform a void move from 𝑀_𝑖 to 𝑀_𝑗,𝑖,𝑗=0,1,…,𝑁+1, is 𝑑_𝑖,𝑗.𝑑_𝑖,𝑗's satisfy the triangular inequality. Finally, let constant δ be the allowable minimum distance among the hoists on the track in order to avoid collision, that is, if the distance between two hoists is less than δ, then a collision happens between them. For simplicity of notation, δ is measured in time in the remainder, which is equal to the allowable minimum distance divided by the travel speed of the hoists.

Figure 2 

Part flow through an electroplating line with N chemical tanks and K hoists.

The hoists are programed to perform a fixed sequence of moves repeatedly. The sequence of moves performed by the hoists during a cycle is called a cyclicschedule. Our objective is to find a cyclic hoist schedule such that the cycle time T is minimized. A cyclic hoist schedule consists of the set of moves performed by each hoist and their respective starting times relative to the start of the cycle. To define a hoist schedule, let 𝑌_𝑖 be the starting time of move i relative to the start of a cycle, 𝑖=0,1,…,𝑁, and 𝑟_𝑖 be the index of the hoist to perform move i (i.e., move i is performed by hoist 𝑟_𝑖), 𝑟_𝑖∈{0,1,…,𝐾−1},𝑖=0,1,…,𝑁. Thus, a cyclic schedule can be uniquely defined by (𝑇,{𝑟_𝑖,𝑖=0,1,…,𝑁},{𝑌_𝑖,𝑖=0,1,…,𝑁}).

Figure 3 illustrates a cyclic schedule for an electroplating line with three chemical tanks (not including the loading station 𝑀₀ and the unloading station 𝑀₄) and two hoists for material handling. Three complete cycles are illustrated in Figure 3. Without loss of generality, we assume that 𝑌₀=0, that is, move 0 happens at the start of a cycle which also implies that a part is introduced into the system at the start of a cycle. Note that if 𝑌₀>0, we can change the origin of the time axis such that 𝑌₀=0. From Figure 3, we see that parts are introduced into the system at time instant 0,𝑇,2𝑇,…. Each hoist performs a fixed sequence of moves cyclically. For this example, we have 𝑟₀=0,𝑟₁=1,𝑟₂=0,𝑟₃=1, that is, hoist 0 performs moves 0 and 2 cyclically, while hoist 1 executes moves 1 and 3 repeatedly. From Figure 3, a cyclic schedule is uniquely defined by (𝑇,{𝑟_𝑖,𝑖=0,1,…,𝑁},{𝑌_𝑖,𝑖=0,1,…,𝑁}).

Figure 3 

A cyclic schedule with three tanks and two hoists.

Our objective is to find a cyclic hoist schedule denoted by (𝑇,{𝑟_𝑖,𝑖=0,1,…,𝑁},{𝑌_𝑖,𝑖=0,1,…,𝑁}) such that the cycle time T is minimized. A cyclic schedule (𝑇,{𝑟_𝑖,𝑖=0,1,…,𝑁},{𝑌_𝑖,𝑖=0,1,…,𝑁}) is feasible if and only if it satisfies the following four families of constraints:

(i)processing time constraints. The parts’ processing time in 𝑀_𝑖 is exactly 𝑡_𝑖,𝑖=1,2,…,𝑁;(ii)tank capacity constraints. Each tank can process at most one part at a time;(iii)hoist availability constraints. There is no conflict in the use of the same hoist between any pair of moves executed by that hoist, since any hoist cannot perform two moves at the same time;(iv)collision-free constraints. The hoists travel on a single track and no collisions happen during a cycle.

As mentioned above, at the start of each cycle, a part is introduced into the system from the loading station. This means that the parts are introduced into the line at time instant 0,𝑇,2𝑇,…, as shown in Figure 3. For the sake of simplicity, the part introduced into the system at time 𝑛𝑇(𝑛≥0) is called part n. With this definition, move i of part n represents the hoist movement of transporting part n from 𝑀_𝑖 to 𝑀_𝑖+1. Let 𝑍_𝑗 be the completion time of the jth processing operation of part 0, which is also the starting time of move j of part 0. From Figure 3, 𝑍_𝑗 can be calculated by using the following formula: 𝑍_𝑗=^𝑗_𝑖=1(𝜃_𝑖−1+𝑡_𝑖),𝑗=1,2,…,𝑁, (2.1) with 𝑍₀=0. By definition, 𝑍_𝑗+𝑛𝑇 is the completion time of the jth processing operation of part n and also the starting time of move j of part n, for any 0≤𝑗≤𝑁, for any 𝑛≥0. In steady state, the starting time of move j within [0,𝑇) (i.e., relative to the start of a cycle) is given by 𝑌_𝑗=𝑍_𝑗mod𝑇,𝑗=0,1,…,𝑁. (2.2) Figure 3 illustrates the above relationship between 𝑌_𝑗 and 𝑍_𝑗.

In the following, we formulate our problem using the notion of prohibited intervals of the cycle time, which was first introduced by Levner et al. [14] into the cyclic scheduling of no-wait systems. Note that the part processing time requirements are implicitly taken into account by using (2.1) and (2.2) to compute the starting times of the moves, as soon as T is known.

2.1. Formulation of the tank capacity constraints

The tank capacity constraints require that the processing of any two successive parts on the same tank cannot be overlapped, since each tank can process one part at a time. Furthermore, by taking into account the times required for lifting up a part from a tank and lowering a part onto a tank, we must have 𝑇≥𝑡_𝑗+𝜇_𝑗+𝜈_𝑗,∀1≤𝑗≤𝑁. (2.3) This relation leads to 𝑇≥𝛽=max_{1≤𝑗≤𝑁}(𝑡_𝑗+𝜇_𝑗+𝜈_𝑗). (2.4)

2.2. Formulation of the hoist availability constraints

The hoist availability constraints require that there is no conflict in the use of the same hoist between any pair of moves executed by that hoist. This implies that there must be sufficient time interval between the start of any two moves performed by the same hoist, since any hoist cannot perform two moves at the same time. This means that, for any pair of moves (𝑗,𝑖),𝑗=0,…,𝑁−1,𝑖=𝑗+1,…,𝑁, if move i and move j are performed by the same hoist (i.e., 𝑟_𝑖=𝑟_𝑗), then move i of any part must be executed either sufficiently before or sufficiently after move j of any part. Due to the cyclic nature of the problem, it is sufficient to consider the hoist availability constraints for move i of part 0 and move j of part n (for any 𝑛≥1) if move i and move j are performed by the same hoist. Therefore, for any pair of moves (𝑗,𝑖),𝑗=0,1,…,𝑁−1,𝑖=𝑗+1,…,𝑁, such that 𝑟_𝑖=𝑟_𝑗, move i of part 0 must be done either sufficiently before or sufficiently after move j of part n, for any 𝑛=1,2,….

Appendix A shows that when part n enters the system, for any 𝑛≥𝑛^∗+1, where 𝑛^∗=min(𝑁+𝐾,⌈(𝑍_𝑁+𝜃_𝑁)/𝛽⌉)−1, part 0 must have left the system. Hence, there is no more conflict in the use of the hoist between part 0 and part n when 𝑛≥𝑛^∗+1. So, we need to consider only those 𝑛's such that 𝑛=1,2,…,𝑛^∗. In fact, 𝑛^∗ is the upper bound on the number of parts simultaneously processed in a production line.

Figure 4(a) shows the case when move i of part 0 happens after move j of part n, while Figure 4(b) shows the case when move i of part 0 is done before move j of part n. By definition, move i of part 0 starts at 𝑍_𝑗 and ends at 𝑍_𝑖+𝜃_𝑖, and move j of part n starts at 𝑍_𝑗+𝑛𝑇 and ends at 𝑍_𝑗+𝑛𝑇+𝜃_𝑗, as shown in Figures4(a) and 4(b). It follows from Figure 4(a) that 𝑍_𝑖≥𝑍_𝑗+𝑛𝑇+𝜃_𝑗+𝑑_𝑗+1,𝑖, (2.5) where 𝑑_𝑗+1,𝑖 is the time for the hoist to travel, upon completion of move j of part n, from 𝑀_𝑗+1 to 𝑀_𝑖 to perform move i of part 0. Similarly, it follows from Figure 4(b) that 𝑍_𝑗+𝑛𝑇≥𝑍_𝑖+𝜃_𝑖+𝑑_𝑖+1,𝑗, (2.6) where 𝑑_𝑖+1,𝑗 is the time for the hoist to travel, upon completion of move i of part 0, from 𝑀_𝑖+1 to 𝑀_𝑗 to perform move j of part n.

(a)

(b)

Figure 4 

(a) Hoist availability constraint when move i succeeds move 𝑗(𝑟𝑖=𝑟𝑗). (b) Hoist availability constraint when move i precedes move 𝑗(𝑟𝑖=𝑟𝑗).

To simplify the notation, define 𝑓_𝑖𝑗≡𝑍_𝑖−𝑍_𝑗+𝜃_𝑖+𝑑_𝑖+1,𝑗. According to (2.5) and (2.6), in any case, we must have either𝑛𝑇≤𝑍_𝑖−𝑍_𝑗−𝜃_𝑗−𝑑_𝑗+1,𝑖=−𝑓_𝑗,𝑖,or𝑛𝑇≤𝑍_𝑖−𝑍_𝑗+𝜃_𝑖+𝑑_𝑖+1,𝑗=𝑓_𝑖,𝑗,∀1≤𝑛≤𝑛^∗,∀0≤𝑗≤𝑁−1,𝑗+1≤𝑖≤𝑁suchthat𝑟_𝑖=𝑟_𝑗. (2.7)Equations (2.7) are equivalent to 𝑛𝑇∉(−𝑓_𝑗,𝑖,𝑓_𝑖,𝑗),∀1≤𝑛≤𝑛^∗,∀0≤𝑗≤𝑁−1,𝑗+1≤𝑖≤𝑁suchthat𝑟_𝑖=𝑟_𝑗. (2.8)

Example 2.1. An electroplating line consists of three tanks, that is, 𝑁=3. There are two hoists available in the system, that is, 𝐾=2. The processing times are as follows: 𝑡₁=16,𝑡₂=8,𝑡₃=14. For all0≤𝑖<𝑗≤4, the time for a void move from 𝑀_𝑖 to 𝑀_𝑗 is obtained by using 𝑑_𝑖,𝑗=𝑑_𝑗,𝑖=∑^𝑗−1_𝑘=𝑖𝑑_𝑘,𝑘+1 with 𝑑_0,1=𝑑_3,4=4,𝑑_1,2=𝑑_2,3=2. For all0≤𝑖≤4,𝜇_𝑖=0.5,𝑣_𝑖=0.5. The times required for executing moves: 𝜃₀=𝜃₃=6,𝜃₁=𝜃₂=4. We set δ = 1. For this example, according to (2.1), we have 𝑍₀=0,𝑍₁=22,𝑍₂=34,𝑍₃=52. By definition, 𝛽=max_{1≤𝑗≤𝑁}(𝑡_𝑗+𝜇_𝑗+𝑣_𝑗)=17,𝑛^∗=min(3+2,⌈(𝑍₃+𝜃₃)/𝛽⌉)−1=3,𝑓_1,0=32,𝑓_2,0=46,𝑓_3,0=70,𝑓_2,1=20,𝑓_3,1=44,𝑓_3,2=30,𝑓_0,1=−16,𝑓_0,2=−26,𝑓_0,3=−42,𝑓_1,2=−8,𝑓_1,3=−24,𝑓_2,3=−14.

2.3. Formulation of the collision-free constraints

In this subsection, we formulate the collision-free constraints among the hoists. This is accomplished by considering possible collisions in the execution of moves. For any two moves i and j executed by different hoists, if their execution requires that the hoists use a common zone of the track, then either move i must sufficiently precede move j or move j must sufficiently precede move i. Otherwise, possible collisions between the hoists may happen, since they use a common zone of the track at the same time. In the remainder of the paper, for any two moves i and j, without loss of generality, we assume that 𝑖>𝑗. Three cases should be considered.

Case 1. 𝑟_𝑖>𝑟_𝑗 and 𝑖>𝑗+1, see Figure 5(a). In this case, in view of the part flow shown in Figure 2, no collisions will happen between the two hoists during their execution of moves i and j.

(a)

(b)

(c)

Figure 5 

(a) No collisions in the execution of two moves (𝑟𝑖>𝑟𝑗,𝑖>𝑗+1). (b) Execution of two moves requires using a boundary tank 𝑀𝑖(𝑟𝑖>𝑟𝑗,𝑖=𝑗+1). (c) Execution of two moves requires using an overlapping zone of the track from 𝑀𝑗 to 𝑀𝑖+1(𝑟𝑖<𝑟𝑗,𝑖>𝑗).

Case 2. 𝑟_𝑖>𝑟_𝑗 and 𝑖=𝑗+1, see Figure 5(b). In this case, hoist 𝑟_𝑗 and hoist 𝑟_𝑖 may collide at 𝑀_𝑖, onto which a part is lowered by hoist 𝑟_𝑗 and from which another part is lifted up by hoist 𝑟_𝑖.

Case 3. 𝑟_𝑖<𝑟_𝑗, see Figure 5(c). In this case, hoists 𝑟_𝑖 and 𝑟_𝑗 will use an overlapping zone of the track from 𝑀_𝑗 to 𝑀_𝑖+1 in order to execute moves i and j, and collisions may happen between them when passing through this overlapping zone.

From this analysis, when there are multiple hoists on a single track, collisions may happen among hoists not only when they use an overlapping zone of the track, but also when using the same tank, from which a part is lifted up by one hoist and onto which another part is lower down by another hoist. Such a tank is called a boundary tank in this paper. In the following, we will first address Case 3 and then consider Case 2.

2.3.1. Execution of two moves requires using an overlapping zone of the track

By Case 3 (see Figure 5(c), hoists 𝑟_𝑖 and 𝑟_𝑗 will use an overlapping zone of the track from 𝑀_𝑗 to 𝑀_𝑖+1 in order to execute moves i and j, and collisions may happen between them. In order to avoid collision between hoists 𝑟_𝑖 and 𝑟_𝑗 such that 𝑟_𝑖<𝑟_𝑗, they cannot use this overlapping zone at the same time. There must be sufficient time interval between them in using this overlapping zone. This means that, for any pair of moves (𝑗,𝑖),𝑗=0,1,…,𝑁−1,𝑖=𝑗+1,…,𝑁, such that 𝑟_𝑖<𝑟_𝑗, move i of part 0 must be done either sufficiently before or sufficiently after move j of part n, for any 𝑛=1,2,…,𝑛^∗.

Figure 6(a) shows the case when move i of part 0 is done after move j of part n, that is, 𝑍_𝑖>𝑍_𝑗+𝑛𝑇. In order to avoid collision, after hoist 𝑟_𝑗 finishes move j of part n, it should arrive at 𝑀_𝑖 before hoist 𝑟_𝑖 and should move to a higher position than 𝑀_𝑖 (i.e., move to a position nearer to the unloading station than 𝑀_𝑖), as shown in Figure 6(a). Note that the earliest time at which hoist 𝑟_𝑗 arrives at 𝑀_𝑖 is 𝑍_𝑗+𝑛𝑇+𝜃_𝑗+𝑑_𝑗+1,𝑖, and the latest time at which hoist 𝑟_𝑖 arrives at 𝑀_𝑖 is 𝑍_𝑖, and the allowable minimum distance among the hoists is δ. Hence, as shown in Figure 6(a), the following constraint must be satisfied: 𝑍_𝑖≥𝑍_𝑗+𝑛𝑇+𝜃_𝑗+𝑑_𝑗+1,𝑖+(𝑟_𝑗−𝑟_𝑖)𝛿. (2.9) Similarly, as shown in Figure 6(b), if move i of part 0 is done before move j of part n, that is, 𝑍_𝑖<𝑍_𝑗+𝑛𝑇, we must have 𝑍_𝑗+𝑛𝑇≥𝑍_𝑖+𝜃_𝑖+𝑑_𝑖+1,𝑗+(𝑟_𝑗−𝑟_𝑖)𝛿. (2.10) From (2.9) and (2.10), we have either𝑛𝑇≤𝑍_𝑖−𝑍_𝑗−𝜃_𝑗−𝑑_𝑗+1,𝑖−(𝑟_𝑗−𝑟_𝑖)𝛿=−𝑓_𝑗,𝑖−(𝑟_𝑗−𝑟_𝑖)𝛿,or𝑛𝑇≥𝑍_𝑖−𝑍_𝑗+𝜃_𝑖+𝑑_𝑖+1,𝑗+(𝑟_𝑗−𝑟_𝑖)𝛿=𝑓_𝑖,𝑗+(𝑟_𝑗−𝑟_𝑖)𝛿,∀1≤𝑛≤𝑛^∗,∀0≤𝑗≤𝑁−1,𝑗+1≤𝑖≤𝑁suchthat𝑟_𝑖<𝑟_𝑗. (2.11) The constraints (2.11) can be equivalently written as 𝑛𝑇∉(−𝑓_𝑗,𝑖−(𝑟_𝑗−𝑟_𝑖)𝛿,𝑓_𝑖,𝑗+(𝑟_𝑗−𝑟_𝑖)𝛿),∀1≤𝑛≤𝑛^∗,∀0≤𝑗≤𝑁−1,𝑗+1≤𝑖≤𝑁suchthat𝑟_𝑖<𝑟_𝑗. (2.12)

(a)

(b)

Figure 6 

(a) Collision-free constraint when move i succeeds move 𝑗(𝑟𝑖<𝑟𝑗). (b) Collision-free constraint when move i precedes move 𝑗(𝑟𝑖<𝑟𝑗).

2.3.2. Execution of two moves requires using a boundary tank

By Case 2 (see Figure 5(b)), hoists 𝑟_𝑗 and 𝑟_𝑖 may collide at 𝑀_𝑖, onto which a part is lowered by hoist 𝑟_𝑗 and from which another part is lifted up by hoist 𝑟_𝑖. In order to avoid collision, part m (for any 𝑚≥0) must have been lifted up from 𝑀_𝑖, for any 1≤𝑖≤𝑁, when part 𝑚+1 arrives at 𝑀_𝑖. Note that part m will leave 𝑀_𝑖 at time 𝑍_𝑖+𝑚𝑇+𝜈_𝑖, and part 𝑚+1 will arrive at 𝑀_𝑖 at time 𝑍_𝑖−1+(𝑚+1)𝑇+𝜃_𝑖−1−𝜇_𝑖. knowing that the allowable minimum distance among the hoists is δ, in order to avoid collision between hoists 𝑟_𝑗 and 𝑟_𝑖, we must have 𝑍_𝑖−1+(𝑚+1)𝑇+𝜃_𝑖−1−𝜇_𝑖≥𝑍_𝑖+𝑚𝑇+𝜈_𝑖+(𝑟_𝑖−𝑟_𝑖−1)𝛿,∀1≤𝑖≤𝑁suchthat𝑟_𝑖−1<𝑟_𝑖. (2.13) This relation leads to 𝑇≥𝑡_𝑖+𝜇_𝑖+𝜈_𝑖+(𝑟_𝑖−𝑟_𝑖−1)𝛿,∀1≤𝑖≤𝑁suchthat𝑟_𝑖−1<𝑟_𝑖. (2.14) This relation can be equivalently written as 𝑇∉(−∞,𝑡_𝑖+𝜇_𝑖+𝜈_𝑖+(𝑟_𝑖−𝑟_𝑖−1)𝛿),∀1≤𝑖≤𝑁suchthat𝑟_𝑖−1<𝑟_𝑖, (2.15)

From the above formulation of the problem, we see that the collision-free constraints can be formulated as (2.12) and ((2.15)). It should be emphasized that this formulation of the collision-free constraints is complete, since by Cases 1, 2, and 3 (or Figures5(a), 5(b), and 5(c)) possible combinations of 𝑟_𝑖 and 𝑟_𝑗 are all taken into account for any pair of moves (𝑗,𝑖),𝑗=0,1,…,𝑁−1,𝑖=𝑗+1,…,𝑁. Note that (2.8) and (2.12) can be generalized as 𝑛𝑇∉(−𝑓_𝑗,𝑖−(𝑟_𝑗−𝑟_𝑖)𝛿,𝑓_𝑖,𝑗+(𝑟_𝑗−𝑟_𝑖)𝛿),∀1≤𝑛≤𝑛^∗,∀0≤𝑗≤𝑁−1,𝑗+1≤𝑖≤𝑁suchthat𝑟_𝑖≤𝑟_𝑗. (2.16)

According to (2.4), (2.15)), and (2.16), the multihoist electroplating line scheduling problem considered in this paper can be formulated as the following prohibited intervals for the cycle time T: Minimize𝑇, (2.17) subject to (2.4), (2.15)), and (2.16).

Note that (2.4), (2.15)), and (2.16) can be equivalently written as 𝑇∉𝐐(𝑅)≡(−∞,𝛽)∪{_{1≤𝑖≤𝑁𝑟𝑖𝑖−1<𝑟}(−∞,𝑡_𝑖+𝜇_𝑖+𝜈_𝑖+(𝑟_𝑖−𝑟_𝑖−1)𝛿)}∪{_{0≤𝑗≤𝑁𝑗+1≤𝑖≤𝑁𝑟𝑖𝑗≤𝑟}{(−𝑓_𝑗,𝑖−(𝑟_𝑗−𝑟_𝑖)𝛿,𝑓_𝑖,𝑗+(𝑟_𝑗−𝑟_𝑖)𝛿)∪(−𝑓_𝑗,𝑖−(𝑟_𝑗−𝑟_𝑖)𝛿2,𝑓_𝑖,𝑗+(𝑟_𝑗−𝑟_𝑖)𝛿2)∪⋯∪(−𝑓_𝑗,𝑖−(𝑟_𝑗−𝑟_𝑖)𝛿𝑛^∗,𝑓_𝑖,𝑗+(𝑟_𝑗−𝑟_𝑖)𝛿𝑛^∗)}}, (2.18) where vector 𝑅=(𝑟₀,𝑟₁,…,𝑟_𝑁).𝑅 is called the hoist assignment in the remainder. It can be found from (2.18) that 𝐐(𝑅) is a union of R-parameterized open prohibited intervals for the cycle time T. For a given 𝑅,𝐐(𝑅) is a union of open prohibited intervals for the cycle time T.

In this Section, we formulate our problem as a series of prohibited intervals for the cycle time, that is, 𝐐(𝑅). Each family of the problem constraints (i.e., tank capacity constraints, hoist availability constraints, and collision-free constraints) corresponds to a set of prohibited intervals for T, for example, the hoist availability constraint between a pair of moves (𝑗,𝑖) such that 𝑟_𝑖=𝑟_𝑗 corresponds to a set of prohibited intervals 𝑛𝑇∉(−𝑓_𝑗,𝑖,𝑓_𝑖,𝑗), for 𝑛=1,2,…,𝑛^∗. Due to this property, for a given hoist assignment R, if 𝑇∉𝐐(𝑅), then such a T must be feasible, since, by definition, such a T falls into no prohibited intervals in 𝐐(𝑅), and consequently all problem constraints must be satisfied.

3. Problem analysis

In this Section, we perform a property analysis for the mathematical model we developed in the above Section. Based on this analysis, we will show that the optimal cycle time for the problem is necessarily one of special values of the cycle time. Hence, the optimal cycle time can be found by detecting the feasibility for each one of these special values of the cycle time, and our problem is thus reduced to a feasibility checking problem for a given value of T.

Theorem 3.1. Given a hoist assignment R, the optimal cycle time 𝑇^∗(𝑅)∈𝐀(𝑅), where 𝐀(𝑅)≡{𝛽}∪{𝑥∣𝑥=𝑡_𝑖+𝜇_𝑖+𝜈_𝑖+(𝑟_𝑖−𝑟_𝑖−1)𝛿,𝑥>𝛽,1≤𝑖≤𝑁,𝑟_𝑖−1<𝑟_𝑖}𝑓∪{𝑦∣𝑦=^𝑖,𝑗+(𝑟_𝑗−𝑟_𝑖)𝛿𝑛,𝑦>𝛽,1≤𝑛≤𝑛^∗,0≤𝑗≤𝑁−1,𝑗+1≤𝑖≤𝑁,𝑟_𝑖≤𝑟_𝑗}. (3.1)

Proof. Given a hoist assignment 𝑅,𝐐(𝑅) is a union of open prohibited intervals which are not necessarily disjoint. However, 𝐐(𝑅) can be considered as a union of disjoint prohibited intervals after merging of the intersecting ones. Therefore, 𝐐(𝑅) can be rewritten as 𝐐(𝑅)=(𝑎₁,𝑏₁)∪(𝑎₂,𝑏₂)∪⋯∪(𝑎_𝐻,𝑏_𝐻) (3.2) with −∞=𝑎₁<𝑏₁≤𝑎₂<⋯<𝑏_𝑖−1≤𝑎_𝑖<𝑏_𝑖≤𝑎_𝑖+1<⋯<𝑏_𝐻.

Example 1 (continued)
If 𝑅=(𝑟₀,𝑟₁,𝑟₂,𝑟₃)=(0,1,0,1), that is, move 0 and move 2 are performed by hoist 0 while move 1 and move 3 are executed by hoist 1, according to (2.18), the following relation holds 𝑇∉𝐐(𝑅)=(−∞,𝛽)∪{(−∞,𝑡₁+𝜇₁+𝜈₁+𝛿)∪(−∞,𝑡₃+𝜇₃+𝜈₃+𝛿)}∪{(−𝑓_0,2,𝑓_2,0)∪(−𝑓_0,22,𝑓_2,02)∪(−𝑓_0,23,𝑓_2,03)}∪{(−𝑓_1,2−𝛿,𝑓_2,1+𝛿)∪(−𝑓_1,2−𝛿2,𝑓_2,1+𝛿2)∪(−𝑓_1,2−𝛿3,𝑓_2,1+𝛿3)}∪{(−𝑓_1,3,𝑓_3,1)∪(−𝑓_1,32,𝑓_3,12)∪(−𝑓_1,33,𝑓_3,13)}=(−∞,17)∪{(−∞,18)∪(−∞,16)}∪{(26,46)∪(13,23)∪(8.66,15.33)}∪{(7,21)∪(3.5,10.5)∪(2.33,7)}∪{(24,44)∪(12,22)∪(8,14.66)}. (3.3) After merging of the intersecting prohibited intervals in 𝐐(𝑅), we have 𝑇∉𝐐(𝑅)=(−∞,23)∪(24,46). Hence, 𝑎₁=−∞,𝑏₁=23,𝑎₂=24,𝑏₂=46.

We can easily find that the optimal cycle time 𝑇^∗(𝑅) is necessarily the upper bound of the first open prohibited interval, that is, 𝑏₁, since 𝑏₁ is the smallest cycle time that is not prohibited by 𝐐(𝑅). Note that the upper bound of any disjoint prohibited interval, after merging of the intersecting intervals, is necessarily an upper bound of one of the prohibited intervals before merging of the intersecting intervals. This means that 𝑏₁ is necessarily one of the upper bounds of the prohibited intervals before merging of the intersecting ones. Therefore, it follows from (2.18) that 𝑏₁∈𝐀(𝑅). Thus, we have Theorem 3.1.

Corollary 3.2. For any hoist assignment R, 𝐀(𝑅)⊂𝐀_𝑇 always holds where 𝐀_𝑇≡{𝛽}∪{𝑥∣𝑥=𝑡_𝑖+𝜇_𝑖+𝜈_𝑖𝑓+𝑘𝛿,𝑥>𝛽,1≤𝑖≤𝑁,1≤𝑘≤𝐾−1}∪{𝑦∣𝑦=^𝑖,𝑗+𝑘𝛿𝑛,𝑦>𝛽,0≤𝑗≤𝑁−1,𝑗+1≤𝑖≤𝑁,0≤𝑘≤𝐾−1,1≤𝑛≤𝑛^∗}. (3.4)

The correctness of Corollary 3.2 is straightforward, since we have (𝑟_𝑖−𝑟_𝑖−1)∈{1,2,…,𝐾−1} for any 1≤𝑖≤𝑁 such that 𝑟_𝑖−1<𝑟_𝑖, and (𝑟_𝑗−𝑟_𝑖)∈{0,1,…,𝐾−1} for any 0≤𝑗≤𝑁−1,𝑗+1≤𝑖≤𝑁 such that 𝑟_𝑖≤𝑟_𝑗.

By Theorem 3.1 and Corollary 3.2, we have the following corollary.

Corollary 3.3. The optimal cycle time 𝑇^∗ for the problem 𝑇^∗∈𝐀_𝑇.

By Corollary 3.3, the optimal cycle time 𝑇^∗ can be found by detecting the feasibility for each value of the cycle time in 𝐀_𝑇 in increasing order until the first feasible cycle time is found, which is the optimal cycle time for the problem. Our problem is thus reduced to the feasibility checking problem for a given value of T.

Example 1 (continued)
The set𝐀_𝑇 = {17, 18, 21, 22, 22.5, 23, 23.5, 30, 31, 32, 33, 35, 35.5, 44, 45, 46, 47, 70, 71}. Th optimal cycle time for the problem can be found by checking the feasibility of these values of the cycle time in increasing order.

4. Feasibility checking for a given value of T

As mentioned in Section 2, for a given hoist assignment R, if 𝑇∉𝐐(𝑅), then such a T must be feasible. Hence, given a value of T, say 𝑇₀,𝑇₀ must be feasible if there exists a hoist assignment R such that 𝑇₀∉𝐐(𝑅). Such an R is accordingly called a feasible hoist assignment for 𝑇₀. Thus, to check feasibility for 𝑇₀, we only need to check whether there exists a feasible hoist assignment R for 𝑇₀. If so, then 𝑇₀ is feasible. Our basic idea is to first derive sufficient and necessary constraints that R must satisfy in order that 𝑇₀∉𝐐(𝑅). By solving the derived constraints for R, we then detect the feasibility for 𝑇₀ and obtain a feasible hoist assignment R if 𝑇₀ is feasible.

Theorem 4.1. For a given cycle time 𝑇₀, in order that 𝑇₀∉𝐐(𝑅), a sufficient and necessary condition is that R satisfies the following constraints: 𝑟_𝑖−𝑟_𝑖−1≤𝑘−1,𝑖𝑓𝑇₀∈(−∞,𝑡_𝑖+𝜇_𝑖+𝜈_𝑖𝑟+𝑘𝛿),∀1≤𝑘≤𝐾−1,∀1≤𝑖≤𝑁,_𝑗−𝑟_𝑖≤𝑘−1,𝑖𝑓(𝑠^𝑘_𝑖,𝑗−1)𝑇₀∈(−𝑓_𝑗,𝑖−𝑘𝛿,𝑓_𝑖,𝑗𝑟+𝑘𝛿),∀0≤𝑗≤𝑁−1,𝑗+1≤𝑖≤𝑁,0≤𝑘≤𝐾−1,_𝑖−𝑟₀𝑟≥0,∀1≤𝑖≤𝑁,_𝑖−𝑟₀≤𝐾−1,∀1≤𝑖≤𝑁, (4.1)(4.2)(4.3)(4.4) where 𝑠^𝑘_𝑖,𝑗=⌈(𝑓_𝑖,𝑗+𝑘𝛿)/𝑇₀⌉, where ⌈𝑥⌉ is the smallest integer greater than or equal to x.

Proof. Note that 𝑇₀∉𝐐(𝑅) is equivalent to (2.4), (2.15), and (2.16) hold for 𝑇₀. Constraint (2.4)) means that if 𝑇₀<𝛽, then 𝑇₀ must be infeasible and no further feasibility checking is needed. Hence, in the remainder, without loss of generality, we assume that 𝑇₀≥𝛽. With this assumption, (2.4)) is always satisfied. In the following, we will first derive the sufficient and necessary constraints that R must satisfy in order that ((2.15)) holds for 𝑇₀(Part A), and then we will derive the sufficient and necessary constraints that R must satisfy in order that (2.16) holds for 𝑇₀(Part B).

Part A. The sufficiency and necessity of (4.1) in order that ((2.15)) holds for 𝑇₀.

We first derive the necessary constraints that R must satisfy in order that ((2.15)) holds for 𝑇₀. Since 1≤𝑟_𝑖−𝑟_𝑖−1≤𝐾−1 for any 1≤𝑖≤𝑁 such that 𝑟_𝑖−1<𝑟_𝑖, in order that ((2.15)) holds for 𝑇₀, the following relation must hold 𝑟_𝑖−𝑟_𝑖−1<𝑘,if𝑇₀∈(−∞,𝑡_𝑖+𝜇_𝑖+𝜈_𝑖+𝑘𝛿),∀1≤𝑘≤𝐾−1,∀1≤𝑗≤𝑁. (4.5) The correctness of (4.5) is clear, since if (4.5) was not satisfied, then we have 𝑇₀∈(−∞,𝑡_𝑖+𝜇_𝑖+𝜈_𝑖+𝑘𝛿) and 𝑟_𝑖−𝑟_𝑖−1≥𝑘, for some 1≤𝑘≤𝐾−1 and 1≤𝑖≤𝑁, and consequently ((2.15)) will be violated for 𝑇₀. Since 𝑟_𝑖 takes only integer, (4.5) is equivalent to (4.1). Hence, in order that ((2.15)) holds for 𝑇₀,𝑅 must satisfy (4.1).

We now prove the sufficiency of (4.1) in order that ((2.15)) holds for 𝑇₀. Assume that ((2.15)) does NOT hold for 𝑇₀ when (4.1) holds. We will show that this assumption will lead to contradictory facts and thus is incorrect. By assumption, since ((2.15)) does NOT hold for 𝑇₀, there must exists an i such that 𝑟_𝑖−1<𝑟_𝑖 and 𝑇₀∈(−∞,𝑡_𝑖+𝜇_𝑖+𝜈_𝑖+(𝑟_𝑖−𝑟_𝑖−1)𝛿). By letting𝑚=𝑟_𝑖−𝑟_𝑖−1, we have 𝑇₀∈(−∞,𝑡_𝑖+𝜇_𝑖+𝜈_𝑖+𝑚𝛿) for this specified i. Since, by assumption, (4.1) holds and 𝑇₀∈(−∞,𝑡_𝑖+𝜇_𝑖+𝜈_𝑖+𝑚𝛿), according to (4.1), we must have 𝑟_𝑖−𝑟_𝑖−1≤𝑚−1. This is in contradiction with the fact that 𝑚=𝑟_𝑖−𝑟_𝑖−1. This means that the assumption that ((2.15)) does NOT hold for 𝑇₀ when (4.1) holds is incorrect. We, thus, prove the sufficiency of (4.1) in order that ((2.15)) holds for 𝑇₀.

Part B. The sufficiency and necessity of (4.2) in order that (2.16) holds for 𝑇₀.

We first derive the necessary constraints that R must satisfy in order that (2.16) holds for 𝑇₀. Since 0≤𝑟_𝑗−𝑟_𝑖≤𝐾−1, for any 0≤𝑗≤𝑁−1,𝑗+1≤𝑖≤𝑁 such that 𝑟_𝑖≤𝑟_𝑗, in order that (2.16) holds for 𝑇₀, the following relation must hold 𝑟_𝑗−𝑟_𝑖<𝑘,ifthereexistsan𝑛,1≤𝑛≤𝑛^∗suchthat𝑛𝑇₀∈(−𝑓_𝑗,𝑖−𝑘𝛿,𝑓_𝑖,𝑗+𝑘𝛿)∀0≤𝑗≤𝑁−1,𝑗+1≤𝑖≤𝑁,0≤𝑘≤𝐾−1. (4.6)

The correctness of (4.6) is clear, since if (4.6) was not satisfied, then we have 𝑛𝑇₀∈(−𝑓_𝑗,𝑖−𝑘𝛿,𝑓_𝑖,𝑗+𝑘𝛿) and 𝑟_𝑗−𝑟_𝑖≥𝑘, for some 1≤𝑛≤𝑛^∗,0≤𝑘≤𝐾−1,0≤𝑗≤𝑁−1,𝑗+1≤𝑖≤𝑁, and consequently (2.16) will be violated for 𝑇₀. As shown in Appendix B, checking whether there exists an 𝑛,1≤𝑛≤𝑛^∗ such that 𝑛𝑇₀∈(−𝑓_𝑗,𝑖−𝑘𝛿,𝑓_𝑖,𝑗+𝑘𝛿),forall0≤𝑗≤𝑁−1,𝑗+1≤𝑖≤𝑁,0≤𝑘≤𝐾−1 is equivalent to checking whether (𝑠^𝑘_𝑖,𝑗−1)𝑇₀∈(−𝑓_𝑗,𝑖−𝑘𝛿,𝑓_𝑖,𝑗+𝑘𝛿), where 𝑠^𝑘_𝑖,𝑗=⌈(𝑓_𝑖,𝑗+𝑘𝛿)/𝑇₀⌉. As a result, (4.6) can be equivalently expressed as 𝑟_𝑗−𝑟_𝑖<𝑘,if(𝑠^𝑘_𝑖,𝑗−1)𝑇₀∈(−𝑓_𝑗,𝑖−𝑘𝛿,𝑓_𝑖,𝑗+𝑘𝛿),∀0≤𝑗≤𝑁−1,𝑗+1≤𝑖≤𝑁,0≤𝑘≤𝐾−1. (4.7) Since 𝑟_𝑗 and 𝑟_𝑖 take only integers, (4.7) is equivalent to (4.2). Hence, in order that (2.16) holds for 𝑇₀,𝑅 must satisfy (4.2).

We now prove the sufficiency of (4.2) in order that (2.16) holds for 𝑇₀. Similarly, assume that (2.16) does NOT hold for 𝑇₀ when (4.2) holds. We will also show that this assumption will lead to contradictory facts and thus is incorrect. By assumption, since (2.16) does NOT hold for 𝑇₀, we must have 𝑛𝑇₀∈(−𝑓_𝑗,𝑖−(𝑟_𝑗−𝑟_𝑖)𝛿,𝑓_𝑖,𝑗+(𝑟_𝑗−𝑟_𝑖)𝛿) for some 1≤𝑛≤𝑛^∗,0≤𝑗≤𝑁−1,𝑗+1≤𝑖≤𝑁, such that 𝑟_𝑖≤𝑟_𝑗. By letting𝑚=𝑟_𝑗−𝑟_𝑖, we have 𝑛𝑇₀∈(−𝑓_𝑗,𝑖−𝑚𝛿,𝑓_𝑖,𝑗+𝑚𝛿) for the specified 𝑛,𝑖,and j. Since, by assumption, (4.2) holds and 𝑛𝑇₀∈(−𝑓_𝑗,𝑖−𝑚𝛿,𝑓_𝑖,𝑗+𝑚𝛿) for the specified 𝑛,𝑖,and j, according to (4.2), we must have 𝑟_𝑗−𝑟_𝑖≤𝑚−1. This is in contradiction with the fact that 𝑚=𝑟_𝑗−𝑟_𝑖. This means that the assumption that (2.16) does NOT hold for 𝑇₀ when (4.2) holds is incorrect. We, thus, prove the sufficiency of (4.2) in order that (2.16) holds for 𝑇₀.

Since there are K hoists in the production line, we must have 0≤𝑟_𝑖≤𝐾−1,∀0≤𝑖≤𝑁. (4.8) With the line configuration in Figure 2, it is easy to find that move 0 must be performed by hoist 0 in order to avoid collision among the hoists. Thus, without loss of generality, we assume that 𝑟₀=0. With this assumption, constraints (4.8) can be equivalently written as (4.3) and (4.4).

To sum up, in order that 𝑇₀∉𝐐(𝑅), a sufficient and necessary condition is that R satisfies the constraints (4.1)–(4.4).

Example 1 (continued)
We illustrate the feasibility checking for 𝑇₀=23. According to (4.1)–(4.4), in order that 𝑇₀∉𝐐(𝑅), a sufficient and necessary condition is that R satisfies the following constraints:𝑟₀−𝑟₁𝑟≤−1,₀−𝑟₂𝑟≤0,₀−𝑟₃𝑟≤−1,₂−𝑟₃𝑟≤−1,_𝑖−𝑟₀≤1,∀1≤𝑖≤3. (4.9)(4.10)(4.11)(4.12)(4.13)
We illustrate how to derive (4.12). By definition, we derive 𝑠⁰_3,2=2,𝑠¹_3,2=2. Hence, (𝑠⁰_3,2−1)𝑇₀=23∈(−𝑓_2,3,𝑓_3,2)=(14,30);(𝑠¹_3,2−1)𝑇₀=23∈(−𝑓_2,3−𝛿,𝑓_3,2+𝛿)=(13,31). This leads to 𝑟₂−𝑟₃≤−1 and 𝑟₂−𝑟₃≤0 according to (4.2). The latter relation is redundant. We, thus, derive (4.12). The other constraints can be derived in a similar way. Note that the constraints 𝑟_𝑖−𝑟₀≥0, for all1≤𝑖≤3, are redundant with the consideration of (4.9)–(4.11) and thus were not shown here.
By Theorem 4.1, (4.1)–(4.4) are the sufficient and necessary constraints that R must satisfy in order that 𝑇₀∉𝐐(𝑅). Note that each constraint in (4.1)–(4.4) can be equivalently written in the form of 𝑟_𝑗−𝑟_𝑖≥𝑐_𝑖𝑗, where 𝑐_𝑖𝑗 is an integer, 0≤𝑖,𝑗≤𝑁. Due to this special structure, solving (4.1)–(4.4) can be transformed into a longest-path problem in a directed graph, as will be described in detail. In a directed graph 𝐺(𝑉,𝐸), where V and E are, respectively, the set of vertices and the set of arcs, a weight 𝑤(𝑒) is associated with each arc 𝑒∈𝐸. Let ℎ(𝑒) and 𝑡(𝑒) be, respectively, the head and the tail of arc 𝑒∈𝐸 (i.e., arc e goes from vertex 𝑡(𝑒) to vertex ℎ(𝑒)). Let 𝜋_𝜈 denote the potential of vertex 𝜈∈𝑉. Thus, each arc e represents a constraint 𝜋_ℎ(𝑒)−𝜋_𝑡(𝑒)≥𝑤(𝑒).
The directed graph constructed from (4.1)–(4.4) contains 𝑁+1 vertices, 0,1,…,𝑁,the potentials of which are, respectively, 𝑟₀,𝑟₁,…,𝑟_𝑁. Each constraint in the form of 𝑟_𝑗−𝑟_𝑖≥𝑐_𝑖,𝑗,0≤𝑖,𝑗≤𝑁 from (4.1)–(4.4) is represented by an arc from vertex i to vertex j with weight 𝑐_𝑖,𝑗. Thus, the set of constraints in (4.1)–(4.4) can be represented as 𝑟_𝑗−𝑟_𝑖≥𝑐_𝑖,𝑗,∀(𝑖,𝑗)∈𝐸. (4.14) With the constructed directed graph, a hoist assignment R satisfies (4.1)–(4.4) if and only if all the arcs in graph 𝐺(𝑉,𝐸) satisfy (4.14). Let C be a directed cycle (circuit) on graph 𝐺(𝑉,𝐸), then by (4.14)_{∀(𝑖,𝑗)∈𝐶}(𝑟_𝑗−𝑟_𝑖)≥_{∀(𝑖,𝑗)∈𝐶}𝑐_𝑖,𝑗. (4.15) Since ∑_{∀(𝑖,𝑗)∈𝐶}(𝑟_𝑗−𝑟_𝑖)=0, we have _{∀(𝑖,𝑗)∈𝐶}𝑐_𝑖,𝑗≤0. (4.16) Thus, if there are positive circuits in the associated directed graph, then (4.1)–(4.4) are said to be infeasible in sense that they cannot lead to any feasible hoist assignment. On the other hand, if there is no positive circuit in the directed graph, then (4.1)–(4.4) are said to be feasible or self-consistent and a feasible hoist assignment can be derived from them. The following theorem gives how to derive a feasible hoist assignment R if (4.1)–(4.4) are feasible or self-consistent and its complexity.

Theorem 4.2. For a given cycle time 𝑇₀, if there is no positive circuit in the directed graph constructed from (4.1)–(4.4), then a feasible hoist assignment R must exist and it can be obtained in 𝑂(𝑁³) in the worst case.

Proof. Let 𝑙_𝑖 be the length of the longest path from vertex 0 to vertex i on graph 𝐺(𝑉,𝐸) satisfying 𝑙_𝑘+‖𝑃_𝑘,𝑖‖≤𝑙_𝑖,0≤𝑖,𝑘≤𝑁,𝑘≠𝑖, (4.17) where 𝑃_𝑘,𝑖denotes the longest path from vertex k to vertex i. By definition, 𝑙₀=0. It is easy to see that 𝑅=(𝑟₀,𝑟₁,…,𝑟_𝑁)=(𝑙₀,𝑙₁,…,𝑙_𝑁) satisfies (4.14), which also implies that such an R satisfies (4.1)–(4.4). By Theorem 4.1, such an R is a feasible hoist assignment for 𝑇₀. Thus, solving (4.1)–(4.4) and consequently checking the feasibility for 𝑇₀ can be transformed into solving a longest path problem for the corresponding directed graph, which can be solved in 𝑂(|𝑉‖𝐸|), where |𝑉| and |𝐸| are, respectively, the number of vertices and the number of arcs in the directed graph. For this problem, we have |𝑉|=𝑁+1,|𝐸|≤(𝑁+1)(𝑁+2)/2. Hence, we have Theorem 4.2.

Example 1 (continued)
The directed graph corresponding to (4.9)–(4.13) is shown in Figure 7. By solving the longest path problem for this graph, we obtain 𝑙₀=0,𝑙₁=1,𝑙₂=0,𝑙₃=1. We, thus, find a feasible hoist assignment 𝑅=(𝑟₀,𝑟₁,𝑟₂,𝑟₃)=(0,1,0,1) for 𝑇₀=23. This implies that 𝑇₀=23 is feasible. It can be shown that the values of the cycle time less than 𝑇₀=23 in 𝐀_𝑇 are all infeasible. Therefore, 𝑇₀=23 is the optimal cycle time for the problem. From (2.2), we have 𝑌₀=0,𝑌₁=22,𝑌₂=11,𝑌₃=6. The optimal cyclic schedule for 𝑇₀=23 is shown in Figure 3. We see from Figure 3 that hoists 0 and 1 use the overlapping zone from 𝑀₁ to 𝑀₃. We also see that there is sufficient time interval between them in entering into the overlapping zone. Hence, possible collisions between them are avoided.

Figure 7 

The directed graph corresponding to (4.9)–(4.13).

5. Algorithm and complexity analysis

The process to solve the hoist scheduling problem considered in this paper can be summarized as follows.

Step 1. Calculate the completion time 𝑍_𝑗, for all 𝑗=0,1,…,𝑁, according to (2.1).

Step 2. Calculate 𝑓_𝑖,𝑗 for all 0≤𝑗≤𝑁−1,𝑗+1≤𝑖≤𝑁, and 𝛽.

Step 3. Construct set 𝐀_𝑇.

Step 4. Sort all the values of the cycle time in 𝐀_𝑇 in increasing order. Check the feasibility for each given value of T, say 𝑇₀, in 𝐀_𝑇 in increasing order as follows.

Step. Calculate 𝑠^𝑘_𝑖,𝑗, for all 0≤𝑗≤𝑁−1,𝑗+1≤𝑖≤𝑁,0≤𝑘≤𝐾−1.

Step. Using (4.1)–(4.4) to derive the sufficient and necessary constraints that R must satisfy in order that 𝑇₀∉𝐐(𝑅).

Step. Construct the directed graph and solve the corresponding longest path problem. If 𝑇₀ is feasible, obtain the corresponding R, and go to Step 5. Otherwise, go to Step 4.1 to check the feasibility for the next value of the cycle time in 𝐀_𝑇.

Step 5. Compute the move starting times for the optimal cycle time by using (2.2).

Theorem 5.1. The multihoist scheduling problem with constant processing times is solvable in 𝑂(𝑁⁶𝐾) time in the worst case.

Proof. Steps 1 and 2, respectively, require 𝑂(𝑁) and 𝑂(𝑁²)times. By the definition of 𝐀_𝑇, the total number of the values of the cycle time in 𝐀_𝑇 is 𝑂(𝑁²𝐾𝑛^∗). Hence, Step 3 can be implemented in 𝑂(𝑁²𝐾𝑛^∗) time. In Step 4, sorting all the values of the cycle time in 𝐀_𝑇 in increasing order requires 𝑂(𝑁²𝐾𝑛^∗(log𝑁+log𝐾+log𝑛^∗)) time.
For each given 𝑇₀, Step 4.1 can be done in 𝑂(𝑁²𝐾) time. Step 4.2 can be implemented in 𝑂(𝑁²𝐾). By Theorem 4.2, Step 4.3 can be implemented in 𝑂(𝑁³) in the worst case. Without loss of generality, we assume that each hoist in the line must perform at least one move and each move can be performed by one and only one hoist. With this assumption, there are at most (𝑁+1) hoists really used for material handling in a production line with N processing tanks. Hence, we assume that 𝐾≤(𝑁+1). Thus, for each given 𝑇₀, Steps 4.1–4.3 can be done in 𝑂(𝑁³). It is known that the total number of the values of the cycle time in 𝐀_𝑇 is 𝑂(𝑁²𝐾𝑛^∗). To sum up, the algorithm runs in 𝑂(𝑁⁵𝐾𝑛^∗) time.
Note that 𝑛^∗=min(𝑁+𝐾,⌈(𝑍_𝑁+𝜃_𝑁)/𝛽⌉)−1. This leads to 𝑛^∗≤(𝑁+𝐾)≤2𝑁+1. Therefore, the algorithm runs in 𝑂(𝑁⁶𝐾) time in the worst case.

6. Computational results

The proposed algorithm was encoded in C++. In this section, we first use an example to verify the correctness of the proposed algorithm. Randomly generated instances are then used to further evaluate the performance of the algorithm. The computational experiment was done on a PC with a Pentium IV 3.0 GHz processor.

The example has 20 processing tanks numbered from 1 to 20, stations 0 and 21 being the loading station and the unloading station, respectively. The processing times for tanks 1 to 20 are 160, 180, 90, 150, 200, 190, 290, 170, 290, 230, 240, 86, 180, 300, 240, 180, 310, 200, 170, and 70, respectively. For any i such that 0≤𝑖≤𝑁, the time for a void move from 𝑀_𝑖 to 𝑀_𝑖+1, that is, 𝑑_𝑖,𝑖+1=3. The other void move times are obtained accordingly with 𝑑_𝑖,𝑗=𝑑_𝑗,𝑖=∑^𝑗−1_𝑘=𝑖𝑑_𝑘,𝑘+1, where 0≤𝑖<𝑗≤𝑁+1. The move times 𝜃_𝑖=𝑑_𝑖,𝑖+1+20, where 𝜈_𝑖=𝜇_𝑖=10 for any 0≤𝑖≤𝑁.

Note that the problem with constant processing times, as addressed in this study, can be considered as a special case of the problem with time windows, that is, zero-width time window. Hence, we can also solve the example using the branch-and-bound algorithm proposed in [5]. Table 1 gives the computational results for the example using the proposed algorithm and the branch-and-bound algorithm in [5]. In Table 1, the columns with 𝑇^∗ provide with the optimal multihoist cycle times for the example, while the columns with CPU represent their corresponding computation times (measured in seconds).

Table 1 

Optimal multihoist cycle times for the example.

It can be observed from Table 1 that the optimal multihoist cycle times obtained with the proposed polynomial algorithm are the same as those obtained with the branch-and-bound algorithm in [5]. However, our polynomial algorithm significantly outperforms the branch-and-algorithm regarding computation times. This is due to the fact that the algorithm developed in this study exploits specific properties to the problem with constant processing times. The optimal 4-hoist schedule for the example is shown in Figure 8.

Figure 8 

Optimal 4-hoist schedule for the example.

In addition, randomly generated instances were used to evaluate the performance of the proposed algorithm. The test instances were generated as follows using integer uniform distributions. For any i such that 0≤𝑖≤𝑁, the time for a void move from 𝑀_𝑖 to 𝑀_𝑖+1, that is, 𝑑_𝑖,𝑖+1, was randomly generated on [2, 5]. The other void move times are obtained accordingly with 𝑑_𝑖,𝑗=𝑑_𝑗,𝑖=∑^𝑗−1_𝑘=𝑖𝑑_𝑘,𝑘+1, where 0≤𝑖<𝑗≤𝑁+1. The move times 𝜃_𝑖 is set to 𝜃_𝑖=𝑑_𝑖,𝑖+1+20, where 𝜈_𝑖=𝜇_𝑖=10 for any i such that 0≤𝑖≤𝑁. The processing times 𝑡_𝑖 were generated on [30, 300]. We fix the value of N = 20, 30, 40, and 50. For each N = 20, 30, 40, and 50, 100 test instances were generated. We consider five values of K : 1, 2, 3, 4, and 5, and 2000(=4×100×5) test problems were solved.

Table 2 reports the average reduction in optimal cycle times (or equivalently improvement on the throughput) achieved by the multihoist schedules with respect to the single-hoist schedules, calculated by the optimal single-hoist cycle time divided by the optimal multihoist cycle time. We see from Table 2 that the reduction in optimal cycle times achieved by the multihoist schedules is very significant, ranging from 2.08 to 9.37.

Table 2 

Average reduction in cycle times by using multihoist for test instances.

Table 3 gives the average computation times in CPU seconds for test instances. It can be seen from Table 3 that the algorithm developed in this study is very efficient. Note that practical electroplating lines generally have 10 to 20 processing tanks and 1 to 3 hoists. For this size of problems, the computation times are within 80 milliseconds. For the 20-tank and 30-tank instances with 1 to 5 hoists, our algorithm found optimal cycle times generally within one second. Even for the very large problem with 50 tanks and 5 hoists, the proposed algorithm can obtain the optimal solution within 25 seconds.

Table 3 

Average computation times for test instances (s).

A further examination of Table 3 reveals that the computation times increase with the number of tanks and hoists, as the algorithm runs in 𝑂(𝑁⁶𝐾) time in the worst case according to its complexity estimation, but the computation times increase not so rapidly with the number of tanks as the complexity of the algorithm indicates. This may be due to the fact that the complexity analysis is a worst-case estimation and sometimes may be far from the reality. To find the optimal cycle time, the values of the cycle time in 𝐀_𝑇 are checked in increasing order until a feasible one is found. In the complexity estimation, the number of values of the cycle time to be checked is estimated at 𝑂(𝑁³𝐾) in the worst case. This estimation is too pessimistic. In fact, only a small part of the values of the cycle time in 𝐀_𝑇needs to be checked before the optimal cycle time is found, and more importantly, the total number of values of the cycle time in 𝐀_𝑇 is significantly less than its theoretical estimation 𝑂(𝑁³𝐾) (less than 10% for most of the instances), since most values of 𝑥 and 𝑦 in 𝐀_𝑇 are less than 𝛽 and the values of 𝑥 and/or 𝑦 may take the same value.

7. Conclusion

This paper proposed a polynomial algorithm for the no-wait cyclic multihoist scheduling problem in an electroplating line. Computational results on randomly generated instances have shown that the algorithm is very efficient. The algorithm developed in this study can be served as a subroutine or a heuristic in solving the problem with time windows.

An important extension of this study is to develop efficient heuristic for the hoist scheduling problem with time windows, which is an NP-hard problem, using the algorithm developed in this study as a subroutine. To achieve this extension, we should take the processing times, which must be within given time windows, as decision variables of our problem. If all processing times are fixed, then the corresponding problem can be solved using the proposed algorithm. Thus, the key to solving the problem with time windows is to design efficient search strategy to find an optimal combination of fixed processing times within given time windows. This is our ongoing work.

Appendices

A. Upper bound on the number of parts simultaneously processed in a production line

It is known that part 0 arrives at the unloading station 𝑀_𝑁+1 at time 𝑍_𝑁+𝜃_𝑁 and part n is introduced into the system at time nT. In order that when part n enters the system, part 0 has already left the system, it is sufficient that 𝑛𝑇≥𝑍_𝑁+𝜃_𝑁. (A.1) It follows from (2.4) that ⌈(𝑍_𝑁+𝜃_𝑁)/𝛽⌉𝑇≥⌈𝑍_𝑁+𝜃_𝑁⌉≥𝑍_𝑁+𝜃_𝑁. (A.2) This means that (A.1) must hold for 𝑛≥⌈(𝑍_𝑁+𝜃_𝑁)/𝛽⌉.

On the other hand, since the K hoists have to perform all the moves within a cycle, we must also have 𝑇≥^𝑁_𝑖=0𝜃_𝑖/𝐾. (A.3) It follows from (2.4) and (A.3) that (𝑁+𝐾)𝑇≥𝑁𝛽+^𝑁_𝑖=0𝜃_𝑖≥^𝑁_𝑖=1𝑡_𝑖+^𝑁_𝑖=0𝜃_𝑖=𝑍_𝑁+𝜃_𝑁. (A.4) Hence, (A.1) must hold for n ≥(N + K).

To sum up, when part n enters the system, for any 𝑛≥𝑛^∗+1, where 𝑛^∗=min(𝑁+𝐾,⌈(𝑍_𝑁+𝜃_𝑁)/𝛽⌉)−1, part 0 must have left the system; 𝑛^∗ can be understood as the upper bound on the number of parts simultaneously processed in a production line.

B. Equivalence of (4.6) and (4.7)

In constraints (4.6), for all0≤𝑗≤𝑁−1,𝑗+1≤𝑖≤𝑁,0≤𝑘≤𝐾−1, we must check whether there exists an 𝑛,1≤𝑛≤𝑛^∗, such that 𝑛𝑇₀∈(−𝑓_𝑗,𝑖−𝑘𝛿,𝑓_𝑖,𝑗+𝑘𝛿). This requires that 𝑛𝑇₀∈(−𝑓_𝑗,𝑖−𝑘𝛿,𝑓_𝑖,𝑗+𝑘𝛿) be checked from n = 1 to 𝑛^∗. Hence, 𝑛𝑇₀∈(−𝑓_𝑗,𝑖−𝑘𝛿,𝑓_𝑖,𝑗+𝑘𝛿) will be checked for at most 𝑛^∗ times. In fact, this is not necessary.

By definition, 𝑠^𝑘_𝑖,𝑗=⌈(𝑓_𝑖,𝑗+𝑘𝛿)/𝑇₀⌉, where ⌈𝑥⌉ is the smallest integer greater than or equal to x. This implies that 𝑠^𝑘_𝑖,𝑗 is smallest integer such that 𝑠^𝑘_𝑖,𝑗𝑇₀≥𝑓_𝑖,𝑗+𝑘𝛿. Hence, for any 𝑠^𝑘_𝑖,𝑗≤𝑛≤𝑛^∗, we always have 𝑛𝑇₀≥𝑓_𝑖,𝑗+𝑘𝛿, that is, 𝑛𝑇₀∉(−𝑓_𝑗,𝑖−𝑘𝛿,𝑓_𝑖,𝑗+𝑘𝛿) for any 𝑠^𝑘_𝑖,𝑗≤𝑛≤𝑛^∗. On the other hand, since 𝑠^𝑘_𝑖,𝑗 is the smallest integer n such that 𝑛𝑇₀≥𝑓_𝑖,𝑗+𝑘𝛿, we must have (𝑠^𝑘_𝑖,𝑗−1)𝑇₀<𝑓_𝑖,𝑗+𝑘𝛿. Hence, we check whether (𝑠^𝑘_𝑖,𝑗−1)𝑇₀≤−𝑓_𝑗,𝑖−𝑘𝛿.

Case 1. if (𝑠^𝑘_𝑖,𝑗−1)𝑇₀≤−𝑓_𝑗,𝑖−𝑘𝛿, then for any 1≤𝑛<𝑠^𝑘_𝑖,𝑗−1, we also have 𝑛𝑇₀≤−𝑓_𝑗,𝑖−𝑘𝛿. As a result, in this case, we have 𝑛𝑇₀∉(−𝑓_𝑗,𝑖−𝑘𝛿,𝑓_𝑖,𝑗+𝑘𝛿) for any 1≤𝑛≤𝑛^∗.

Case 2. if (𝑠^𝑘_𝑖,𝑗−1)𝑇₀>−𝑓_𝑗,𝑖−𝑘𝛿, we find an 𝑛=𝑠^𝑘_𝑖,𝑗−1 such that 𝑛𝑇₀∈(−𝑓_𝑗,𝑖−𝑘𝛿,𝑓_𝑖,𝑗+𝑘𝛿).

From this analysis, for all0≤𝑗≤𝑁−1,𝑗+1≤𝑖≤𝑁,0≤𝑘≤𝐾−1, checking whether there exists an 𝑛,1≤𝑛≤𝑛^∗, such that 𝑛𝑇₀∈(−𝑓_𝑗,𝑖−𝑘𝛿,𝑓_𝑖,𝑗+𝑘𝛿) is equivalent to checking whether (𝑠^𝑘_𝑖,𝑗−1)𝑇₀∈(−𝑓_𝑗,𝑖−𝑘𝛿,𝑓_𝑖,𝑗+𝑘𝛿).

Acknowledgments

This work was partially supported by the National Natural Science Foundation of China, under Grant no. 50605052 and the Program for New Century Excellent Talents in Universities of Ministry of Education, China, under Grant no. NCET-06-0875.