A bounding scheme for deriving the minimal cycle time of a single-transporter N-stage process with time-window constraints

130 European Journal of Operational Research 78 (1994) 130-140 North-Holland

Theory and Methodology

A bounding scheme for deriving the minimal cycle time of a single-transporter N-stage process with time-window constraints

R o n a l d A r m s t r o n g , L e i L e i a n d S h a n h o n g G u

Graduate School of Management, Rutgers University, Newark, NJ 07102, USA

Received August 1991; revised May 1992

Abstract: Many multi-stage processes employ programmed transporters to move jobs between stages and impose time windows on the starting times of the material handling operations. The operations are typically cyclic and, in each cycle, a given set of operations must be performed. The problem is to determine the sequence and the timing of the operations so that the cycle time is minimized, while the time windows and the transporter traveling time constraints are satisfied. This paper introduces a new sequence-dependent parameter, called the minimal time span, that gives a tight lower bound on the cycle time for a candidate schedule. A search procedure based on this parameter is proposed. This procedure requires only simple calculations (addition and subtraction) at each non-leaf node. Computational experience is reported. With all the benchmark problems, the number of nodes visited during the resulting search process is no more than the number of linear programming problems solved in previous studies reported in the literature. With all the randomly generated test problems, the lower bound achieved by the proposed procedure is close to that achieved by the linear programming based approach. We also show that, if a condition regarding the processing time constraints is satisfied, the use of this minimal time span parameter leads to a direct solution to the associated linear programming problem for a candidate schedule.

Keywords: Cyclic scheduling of transporters; Material handling; Time windows; Branch-and-bound procedure; The minimal time span

1. Introduct ion

Many automated multi-stage processing lines employ computer programmed transporters to move jobs between stages and impose time windows on the starting times of the material handling operations. A typical example is a nickel plating line used in the production of printed circuit boards. This line consists of a sequence of chemical baths, each contains the chemicals for a specific treatment s tep/s tage. A job (i.e., a fixture of printed circuit boards), once it is loaded into the plating line, must be continuously processed in each of the baths one after another until it is sent to the output buffer. To control the

Correspondence to: Prof. L. Lei, Graduate School of Management, Rutgers University, University Heights, 92 New Street, Newark, NJ 07102-1895, USA.

0377-2217/94/$07.00 © 1994 - Elsevier Science B.V. All rights reserved SSDI 0377-2217(92)00015-6

R. Armstrong et al. / A single-transporter N-stage process 131

amount of chemicals absorbed by a job, the processing time at each bath must be limited within a given time interval. The transportations of jobs between baths are performed by a material handling hoist ( transporter) which moves according to a fixed cyclic pat tern during the continuous manufacturing process. A feasible operat ion schedule for the t ransporter that minimizes the cycle time, while adhering to the job processing and t ransporter traveling time constraints, is desirable since it would in turn maximize the system throughput rate. Cyclic scheduling problems with similar constraints can also be found in automated manufacturing processes that produce food or chemical products.

In this paper, we study the problem of minimizing the cycle time of a single-transporter N-stage process encountered from the manufacturing environment introduced above. The N-stage process in question (see Figure 1) is represented by S = (S 0, S~, S 2 . . . . , S N, Su+~), where So, SN+ ~, and S i stand for the input buffer, the output buffer, and stage i, 1 < i < N, respectively. Additional assumptions upon which we conduct the study are given as follows:

• Once a job is removed from S 0, it must be then processed at each of the N stages one after another without encountering any intermediate delay.

• Stage S~ can process one job at a time, and the processing time at S~ must be no less than a i and no more than bg time units, where both a i and b i a r e given constants, i -- 1, 2 . . . . . N.

• Transportat ion of jobs between stages is performed by a single t ransporter which carries one job at a time. It takes the t ransporter c~ time units to deliver a job from S k to S k + ~, and C~)k time units to travel (when not carrying any job) from Sj to Sk, 0 < j , k < N + 1.

• The input buffer S o contains an infinite number of identical jobs at time 0. The transportation operations in this N-stage process is cyclic and the cycle repeats during the

continuous manufacturing process. Let mi, 0 <_ i <_ N, denote an operation, or a move, that delivers a job from S i to Si+ ~, and ti be the relative starting time of mi in a cycle. A cyclic schedule determines the sequence of the N + 1 distinct moves: M = (mt0], r a i l ] . . . . , m[u]) and the relative starting times of the moves: T : (ti0], t i l l , . . . , t[N]), where mu] : mj denotes that m i is the i-th move in a cycle, 0 < i , j <_ N, and t[01 < t[~ 1 < • .. < tiny We shall use (M, T) to denote such a schedule. The definition of (M, T) requires exactly one job to be moved from each stage (thus exactly one job enters and one job leaves the system) in a cycle. Without loss of generality, it is assumed that m[01 = m 0 and t[0 ] = 0. The total time required by the t ransporter to complete a repetition of a cyclic schedule is the cycle time, or X(M, T ) : t [ N + l ] , and a given candidate cyclic schedule is feasible if and only if the following sequence-dependent linear programming problem, LP(M), has a feasible solution.

(LP(M)) Minimize X ( M , T ) s.t. (a) The job processing time constraints: Given that mEi I and m[j] a r e two consecutive moves for the

same job, [j] = [i] + 1, O < _ i < N , 0 < j < N :

a[i I _< t[j I - (t[i I + c~i]) <_ b[j I if i < j ,

a[ j I<_X(M , T ) - (t[i]+c~i]) + t[j]<_blj ] if i > j ,

¢1)

(2)

= . . . . = l t ' . , " . l l - I

l From precedi.g To su¢ceeai.~ proo,ss wo~ss

Figure 1. Job flow in a N-stage process without intermediate queues.

132 R. Armstrong et al. / A single-transporter N-stage process

(b) The transporter traueling time constraints: Let m[i ] and m[i + 1] be two consecutive moves ordered by the given M, i = 0, 1 . . . . , N - 1, N. The following condition must then hold:

g , + , j - g,l c ,j + j. (3)

This study is concerned with determining a schedule (M*, T*) so that

X ( M * , T * ) = min{X(M, T) [Vfeasible (M, T)}.

Several studies on the scheduling of material handling transporters have been reported. Phillips and Unger [6] conducted an early work on the problem and proposed a mixed integer programming model to determine the schedule that minimizes the cycle time. Their test problem (with twelve chemical baths) has been used as one of the benchmark problems in follow-up studies. Based on a systematic analysis on the cyclic scheduling problem, Shapiro and Nuttle [8] introduced an improved approach, a branch-and- bound procedure solving linear programming subproblems. This approach can be applied to solve several variations of the single transporter cyclic scheduling problem, for example, those with parallel processing stages or alternative configurations of input/output buffers. More recently, Lei and Wang [3] proposed a branch-and-bound based window-cutting algorithm that derives feasible cyclic schedules by calculating the earliest and the latest starting time (thus a time window) for each move in a candidate schedule. A schedule is feasible if and only if all the moves in that schedule have non-empty time windows. Extending the problem to involve two transporters, Lei and Wang [1] have recently developed a heuristic algorithm which derives a schedule with the minimal common cycle time for the two transporters (hoists). Studies on the scheduling of material handling transporters assuming multiple job types and relaxed transporter traveling time constraints have also been reported in the literature. A well known work of this type is the study by Lieberman and Turksen [4]. They proposed and analyzed a set of algorithms for assigning cranes to jobs so as to minimize the delays in job processing due to crane interference. Matsuo, Shang and Sullivan [5] have recently reported their study on a similar multiple job-type problem with a single crane, and shown that cyclic scheduling provides a near optimal solution.

The general problem of minimizing the cycle time of a single-transporter N-stage process is difficult because the number of candidate schedules grows exponentially as the number of stages (N) increases [2]. Therefore, the efficiency of the bounding rules used in the search process determines, to a great extent, the practical value of a scheduling algorithm. In this paper, we introduce a new sequence-dependent parameter, called the minimal time span, that gives a tight lower bound on the time required to complete any partial sequence of moves in a candidate schedule. This lower bound is calculated based on both the transporter traveling time and the job minimal processing time. It is shown that, if a condition regarding the processing time constraints is satisfied, the use of this minimal time span leads to a direct solution to the associated linear programming problem LP(M). This direct solution achieves the optimal starting times and the cycle time for a candidate sequence of moves in the Phillips and Unger's benchmark problem. A search procedure based on this minimal time span is introduced, and the use of this procedure requires only simple calculations (addition and subtraction) at each non-leaf node during the search process. Computational experience with both the benchmark problems and a set of randomly generated problems is reported. With all the benchmark problems, the number of nodes visited during the resulting search process is no more than the number of linear programming problems solved in previous studies reported in the literature. From our experience with 360 test problems, it is also observed that, the percentage of the infeasible schedules that were directly detected by the proposed search procedure is about 97.8%. In addition, the lower bound on the cycle time achieved by the proposed procedure is close to that achieved by the linear programming based procedure, for all the test problems.

In Section 2, we introduce the minimal time span parameter and the set of resulting checking and bounding rules. In Section 3, a branch-and-bound algorithm that utilizes these rules is discussed, and the computational experience with both benchmark problems and randomly generated test problems is presented. Finally, in Section 4, we discuss two future extensions and conclude the study.

R. Armstrong et a L / A single-transporter N-stage process 133

2. The minimal t ime span of a sequence

A candida te sequence of moves, M = (mr01, m[1], . . . ,m[g]), is feasible if the associa ted L P ( M ) fo rmula t ed in Sect ion 1 has a feasible solution. Let M be such a feasible sequence with start ing t imes T = (t[0], t [ l [ , . . . , t[N]) and a cycle t ime X ( M , T). Let [ M [ M] be the sequence of moves p e r f o r m e d in the first two successive cycles def ined upon M, and

[ M I M ] = (m[0], mr1 ] . . . . . m[Nl, m [ N + l ] , m [ N + 2 ] . . . . . m[2N+l])

where mtk ] = mtk_N_ U with t[~ 1 = X ( M , T) + t[k_N_ U for any N < k < 2 N + 1. The use of [ M I M] facil i tates examining the re la t ionships of the moves crossing successive cycles. For example , with M = ( m 0, m 1, m3, m2, m 4 ) , w e have

[ M l M ] = ( m o , ml , m3, m2, m 4 , mo, ml , m3, m2, m 4 )

\ cycle 1 / \ cycle 2 /

The job in t roduced by mr01 in the first cycle has its m o, m~, and m 2 in cycle 1, and m 3 and m 4 in cycle 2. No te that the total n u m b e r of cycles tha t it takes to comple te a job depends on the sequence. For example , it takes th ree cycles to comple te a job if M = ( m 0, m e, m4, ml , m 3 ) .

A part ia l sequence of [ M i M ] is now def ined as

P[il,[Jl = (m[i], m [ i + l ] , ' " , m[/ l ) , 0 < i < j < 2 N + 1, (4)

where Ptq,[/] is al lowed to be a sequence of successive moves e i ther within a cycle or across two successive cycles. Consider the time interval between the starting times ofm[i ] and m H, t[2] - t[~ I. By (3), it is c lear that

0 ( t [ j ] - - t[ i]) >_ ( t [ j , ] - - t [ i ] ) + C ~ j _ I ] W C [ j _ I ] + I , [ j ] ( 5 )

where quant i ty c~s_ll + c ~ _ q + l , [ j ] gives a lower bound on the t ime interval be tween t[s_ q and t[j 1. Fu r the rmore , if there exists a move in Ptq,H' say mtz 1, with [z] + 1 = [ j] so that mtz I and mtj j are two successive moves for the same job, then we must also have

(t[/1 - tti]) > ( t M - t[il) + Cdz I +a[/ 1 (6)

where c~z ] + a[i I gives a lower bound on the t ime interval be tween t[z ] and t[z]+ 1 = tty]. To summar ize the results in (5) and (6), we now in t roduce a sequence (M)-dependent pa rame te r , Y[i],[j], which es t imates the minimal t ime interval requi red be tween tti j and tN, for any pair of m[i ], mij ] ~ [ M [ M]. P a r a m e t e r Y[q.[J] can be def ined recursively in the following way:

{Input: P[il.tJ] = (mill, m[i+l] . . . . . mE/l), 0 < i < j < 2 N + 1} Y[i],[i] = 0; For k = i + l , i + 2 . . . . . j d o

begin if there exists an in teger z, i < z < k, such that [z] = [k] - 1, then

1 0 Y[i],[~] = max{YH,tz] + (c [ z I + a[k]), Y[i],[k-l] + C~k-1] + C[k-1]+ 1,[k] },

1 0 • else Y[i],[k] Y[il,[k - 11 -t- (C[k _ 11 -t- C[k _ 1]+ 1,[kl ),

end;

(7) (8)

The purpose of in t roducing p a r a m e t e r Y[i],[j] is twofold. First, it can be used to derive the lower bound on the cycle t ime dur ing the search process, while requir ing much less computa t iona l effor t than that requi red by solving l inear p r o g r a m m i n g problems. F r o m the evaluat ion results in Sect ion 3, the bounding results der ived by using this p a r a m e t e r are close to that achieved by solving the l inear p r o g r a m m i n g p rob l ems for all the test p roblems. Second, p a r a m e t e r Y[il,[j] gives the direct op t imal solution to the


associated l inear programming problem, LP(M) , if a condit ion regarding the job processing t ime is satisfied. The pa rame te r Yti],[j] is called the minimal t ime span of s e q u e n c e P[i],[j] th roughout the discussion.

Example 1. Consider a given partial s e q u e n c e P[0],[2] = (m0, m2, m l ) , where [0] = 0, [1] = 2, [2] = 1, a I = 14, a 2 = 5, b 1 = 18, b 2 = 10, c~ = 4, 0 _< k _< 2, and c°,,1 = 2 . [i - j I, 0 _< i , j _< 3. The value of Y[01,[21 is calculated recursively as follows:

Y[0],[0] = 0 ,

Y[0],U] Y[0],[0] + c~0] + 0 = c[0]+~,[1] =Y0,0 + c~ + c°~,2-- 0 + 4 + 2 = 6,

YtoI,I21 = max{ Y[ol,to] + C?o] + atz], Y[ol,tl] + C?l] + c[O]+ 1,[2]}

= max{0 + Co 1 + al , 6 + c~ + C°,l) = max{0 + 4 + 14, 6 + 4 + 4} = 18.

Pa rame te r YH,[J] has the following propert ies .

L e m m a 1. For any given partial sequence PH,[J], 0 < i < j < 2 N + 1, quantity Ytil,U] is a lower bound on t[j] -- t[i ].

Proof . Induct ion is used to show that condit ion Yti],[k] ~ t[k] -- tti] holds for every k, i < k < j . Case k = i: Trivial.

Case k = i + 1: If [k] = [i] + 1, then Y[i],[k] = c~i] + ark] < ttk] - t[i] by (1). If [k] ~ [i] + 1, then YtiJ,t~l = C~i ] + C~]+ 1,[k] < t tk ] -- t[i ] by (3).

Case k =j : (Assume that condit ion Ytil,tkl -< t t~ ] - t[i] holds for every k with i < k < j - 1.) If Ptil,t~j contains such an m[z ] that [z] + 1 = [k] = [j], then by (5), (6) and (7), it follows that

Y[il,[J¢] < max(( t [z I - t [ i ] ) + (C~z] + a[k]), ( t [ k - 1 ] - t[i]) + c~k_ 'l + c[°-1]+ ,,[k]} -< t [ l , ] - t[i],

otherwise, by (8),

1 0 Y[i],[k] = Y[i],tk - 1] -}- C[k -1] + Ctk -1] +l , t k] -~ ( t [g- 1] -- t t i ]) + C~k - 1] + C~k-1] +l , tk] ~ t[k] - tti]

[]

Particularly, by fixing i = 0 and t[0 ] = 0 in the p roof for Lemma 1, Y[0l,[jl < t[j], where quanti ty Y[ol,tj] gives the earliest possible starting t ime of mu], for j = 1, 2 . . . . . N. Fur the rmore , by relaxing the upper bound on the job processing t ime constraints, it can be seen that Y[il,[j] gives the optimal solution to the following relaxed problem:

Y[i],[j] : min(t[j] -- tti])

s . t . ttk+l]--ttk]>_C~kl +C~kl+l,tk+l ] for i < k < j ,

t t k l - - ( t H + C ~ z j ) > _ a t k ] f o r i < z < k < j , w i t h [ z ] + l = [ k ] .

The use of the minimal time span leads to the following bounding and checking rules.

L e m m a 2. I f sequence M is feasible, then for any partial s e q u e n c e P[i],[j] ~ [ M I M ] with [j] = [i] + 1,

Yti],[j] -~< C~i] "[- btj]. (9)

Proof . If M is feasible, then Pti],tj] ~ [M[ M] must be feasible. Given that Pti],tJ] is feasible, the starting times t[j] and t[i ] m u s t satisfy constraint t[j I - t[i ] < c~i ] + b[j] if [ j ] = [i] + 1. Since Y[i],[j] is a lower bound o n t[j] -- t[i], the lemma follows. []


All the candidate sequences that contain P[i].[il+, with Y[il,[i]+I > C(i] + b(~]+~ must be infeasible and should be eliminated from further consideration. To eliminate non-profitable candidate schedules, consider the following:

0 X( M, T) _> Yt0I,[N+ 11 = Y[0],[N] + C~N] + f IN]+ 1,[0]" (10)

That is, the cycle time should not be less than the minimal time interval between the starting times of the m[0]'s in two successive cycles. Furthermore, let M be a candidate sequence and P[q,[il ~ [M [M] be a partial sequence with [j] = [i] - 1. The minimal time span of PIq,H' Y[/],[Jl, gives a lower bound on the time interval between the removal of the first job from stage S[~ ] and that of the second job from stage S[q_ 1. Consequently, Y[il,[i]- x + c~i l- 1 + a[i I gives a lower bound on the minimal time interval between the removal of two successive jobs from stage S[i ]. S i n c e the cycle time of a schedule must be equal to time interval between the starting times of the i-th moves in two consecutive cycles, for all 0 _< i _< N,

X ( M , T) >_ max{Y[il,lj 1+ c~j I + a[i]ll <i_< N, i <j_< 2N, [ j ] = [i1 - 1} (11)

Lemma 3 below summarizes the results given in (10) and (11).

Lemma 3. Candidate schedule (M, T) should be eliminated from further consideration if

Xb~t < max{y[0},[u+ II, Y[ii,lJ] + C~j] + a[il[ 1 _< i _< N, i < j < 2N, [ j ] = [i] - 1}

where Xb~t stands for the shortest cycle time obtained so far during a search process.

(12)

Theorem 1. Consider [ M I M] upon a given sequence M. Let L(M, T) be a lower bound of X (M, T) where

L ( M , T) = max{Y[01.[u +l], Y[i],[i] + c~]] + a[il[1 < i < N, i < j < 2N, [ j ] = [i] - 1} (13)

and

Y[0].[il, 0 < i < N,

t[q = L( M, T) + t[i_ N 1], N < i < 2N + 1.

I f for every pair ofmot,es, m[q,m[i I ~ [M ] M], with [j] = [i] + 1, the condition

min{[ttj ~- (t N + c~) l -aLj ~, b H - [tLj ~- (t~q + c ~ ) ] } >_0

holds, then (i) T = (t[0], t[1 ] . . . . . tiN 1) gives the feasible starting times for moves in M;

(ii) X ( M , T) -- L(M, T) gives a feasible cycle time for M; and (iii) X ( M , T) and T give the optimal solution to LP(M).

(14)

(15)

Proof. A schedule is feasible if it satisfies both the job processing time and the transporter traveling time constraints. Since the starting time of each move in M computed by (14) always ensures that tti ] > t[i_ ,] + @ t] + cl~i-l j+ 1,[i], the transporter traveling time constraints is satisfied. If condition (15) is not violated by T, then job processing time constraints (1) and (2) are also satisfied. Schedule (M, T) is thus feasible to LP(M). Suppose that X ( M , T) is not the minimal feasible cycle time for M, but X °, X ° < X ( M , T), is. By (13), either X ° < Y[0].[N+ q' which violates Lemma 1, or X ° < Y[i],[j] + @] + a~il, with [j] = [i] - 1 for some m[g],mtj ] ~ [M [ M], which violates the minimal processing time constraints. []


E x a m p l e 2. Consider the da ta given in Example 1. We have N = 2, M = (m0, m 2, m 1) and [ M I M ] = ( m 0, m 2, m~, m 0, m e, m~). Accord ing to (13) and (14), the s tar t ing t imes of moves in [ M I M ] and the associa ted cycle t ime are

t[o] = Y[ol,[ol = 0, t[~] = Y[0],[1] = 6, t[2] = t[N] = YI0],[2] = 18,

0 = 1 8 + 4 + 4 = 2 6 , Y[o],[3] = t[N] + C~N] + C[N]+ 1,[0]

= m a x { 2 6 , 8 + 4 + 5 , 8 + 4 + 1 4 } = 2 6 ,

t[31 = 26 + 0 + 26, t[4 ] = 26 + 6 + 32, tt51 = 26 + 18 = 44.

Since t[2 ] - (t[o ] + C~o ]) - a[2 ] = 18 - 4 - 14 = 0, bt4 ] - (tin ] - (ttz I + c~zj)) = 10 - (32 - (18 + 4)) = 0, and condi t ion (15) is satisfied. It follows f rom T h e o r e m 1 that T and L(M, T) give the opt imal solution to L P ( M ) .

E x a m p l e 3 (Phillips and Unge r [6]. Cons ider the following candida te sequence of moves in Phillips and U n g e r ' s b e n c h m a r k p r o b l e m (with N = 12):

M = ( m o , m l o , m 4 , m s , m l l , m l , m12 , m 6 , ?n2, m 7 , m 9 , m 8, m 3 ) .

Using the data in [6], we apply (13) and (14) to compu te the s tar t ing t imes of moves and the cycle t ime. The following results are obta ined:

T = ( t o , r io , t4 , t 5, t l l , t l , t12, t6, t2 , t7, t9 , t8, t 3)

= (0, 41, 74, 129, 166, 1 8 9 , 2 1 8 , 2 7 0 , 3 0 2 , 3 5 2 , 3 7 6 , 4 4 8 , 4 8 3 ) , 0

Y[0],[N+ 1] = tiN] + C~N] + C[N]+ 1,[0] = 483 + 22 + 14 = 519,

L ( M , T ) = max{Y[o],[N+l]; Y{i],[J] + c~] + a[i]] 1 _< i < N , i < j < 2 N , [ j ] = [ i ] - 1}

= Y[2],[12] + c~121 + a[z] = 409 + 22 + 90 = 521.

Since condi t ion (15) is satisfied by T, L(M, T) and T give the opt imal solution to the associated L P ( M ) , by T h e o r e m 1.

3. A branch-and-bound solution procedure and computational experience

The p rocedu re that utilizes the minimal time span to bound the search for the opt imal cyclic schedule is briefly out l ined as follows. Dur ing the search process, a search tree is constructed. The root of the search t ree is fixed with m[0 ] = m 0. Each node on the i-th level denotes a par t icular par t ia l sequence, PEo],Li~ = (m[0], mEq . . . . . m[q) , which is a pe rmu ta t i on of subset {mj I j = 0, 1, 2 . . . . . i} and is ob ta ined by insert ing m i be tween two successive moves o rde red by a given Pt01,tg-aJ" For example, given i = 2, Pt0j,t~-q = (m0, m~), the two candida te par t ia l sequences that we can construct at level 2 are Pt0~,tzl = ( m 0, m 2, m 1) and Ptol.t2j---(m0, ml , m2)" For each part ial sequence, the associa ted min imum t ime span, 0 < i < j < 2k, is calculated by the recursive p rocedure (7)-(8). The rules based on L e m m a s 2 and 3 are then applied. W h e n e v e r a candida te par t ia l sequence is found to be infeasible or not profi table , all the candida te sequences containing tha t par t ia l sequence are e l iminated f rom fur ther considerat ion. Otherwise , the search p roceeds to the (i + 1)-st level on the tree. As the search arrives at the N- th level, a full sequence, M = (m[o ], m[q . . . . ,mtNl), is genera ted . I f the s tar t ing t imes of the moves in that sequence are not de t e rmined by T h e o r e m 1, then a s equence -dependen t l inear p r o g r a m m i n g problem, L P ( M ) , as fo rmula ted in Sect ion 1, is solved for the minimal cycle t ime X ( M , T). I f the result ing cycle t ime, X ( M , T), is found to be less than the shor tes t feasible cycle t ime found so far during the search


process, Xbest (which is initially set to be equal to the flow time), the value of Xbest is replaced by the new cycle time. As the value of Xbest decreases, the bounding effect of Lemma 3 becomes more significant. After all the candidate schedules are examined, the search terminates with the optimal operation schedule (M* , T * ) and the minimal cycle time X(M*, T*).

The criterion used at each level on the search tree for selecting a candidate partial sequence to branch is based on a 'greedy' approach. The partial sequence to be selected first is the one that results in more jobs to be moved in a cycle. Since a sequence with more jobs to be moved in a cycle usually leads to a shorter cycle time, we have observed that the optimal sequence is usually among the first few feasible sequences obtained in the search process.

As mentioned by a referee, information on the unassigned moves may further improve the lower bound on the cycle time. Let Uk be the set of unassigned moves at level i, U/= {mi+ 1, mi+ 2 . . . . . mx}. At level i = 0, a lower bound can be estimated by

max{c)_ l +a,+c)-ac-C°+l,j_l[j = 1 . . . . ,U} (16)

where c)_ 1 + aj + c) + c°+ ~,j_ 1 is the minimum time interval between the removals of two successive jobs from stage Sj, 1 < j _< N. When i > 0, a lower bound on the cycle time incorporating unassigned moves mi,m j ~ U~, is given by the following:

Xl 'ow=X,ow+max(0, ~_. c ; - ~ Ik} (17) m j ~ U i O<_k<_i

where I k stands for the transporter idle time (waiting time) before move mg starts, and Xlow stands for the lower bound derived based on a given partial sequence Pl0],[i]. The result in (17) can be implemented with minimal computational effort.

The proposed branch-and-bound search procedure is outlined in Table 1. To investigate the effectiveness of the proposed minimal time span parameter and the resulting search

procedure, we conducted evaluation studies with both randomly generated problems and benchmark problems. The procedure that derives the bound on the cycle times and checks the infeasibility of candidate partial schedules by solving a linear programming problem at each node is called the LP procedure. The proposed procedure that uses the minimal time span to guide the search is called the MTS procedure. For each randomly generated test problem, the performances of the two procedures are evaluated in terms of the following measures: (a) the total number of nodes visited by the MTS procedure versus that by the LP procedure during the

search process;

Table 1 Outl ine of a b ranch-and-bound solution procedure for the minimal cycle time

{Let k be the current level on the search tree, k = 1, 2 . . . . , N}

Step O. (Initialization) Fix mr01 = 0, tto ] = 0, Pt01,[11 = (m0, m l ) , set Q1 = {P[01.[ll l, Qk = ¢ for k = 2, 3 . . . . . N, X b ~ = Flow time, k = l .

Step 1. If k = 0, then the optimal cycle time = Xbes t ; stop. If Qk = ¢, then set k = k - 1 and go to Step 1, else choose a candidate partial sequence P[0].[~l f rom Q~ and set Qk = Q \ P[ol,[kl"

Step 2. For all these possible insertion posit ions of rnk+ 1 in P[0l,[kl do insert mk+1 into P[ol,[k] to construct a new sequence Pt01,[k+ 1], check the infeasibility and the non-profitabili ty of the newly constructed P[0l,[k + t], if Pl01,[k + 1] does not violate (9) nor (12), then put P[01,[k + 11 into Qk + 1.

Set k = k + 1. If k = N, then go to Step 3, else go to Step 1. Step 3. For every M = Pt01,[N] in QN, if the minimal cycle time X(M, T) cannot be de termined by (13)-(15), then solve the

associated LP(M) . If X(M, T ) < Xbest, then set Xbest = X(M, T). Set k = k - 1 , QN = ¢, and go to Step 1.


Table 2 Performance comparison results with the two approaches (the MTS procedure versus the LP procedure) with O = 0.5

N Average # nodes Average CPU time Average # nodes Average CPU time Average Average visited by the (seconds) to find the visited by the (seconds) to find the R t R 2 LP procedure optimal cycle time MTS procedure optimal cycle time by

by the LP procedure MTS procedure

10 75 7.70 93 0.192 ~ 0.99 0.967 11 99 11.88 114 0.198 ~ 0.99 0.973 12 123 16.82 149 0.282 ~ 0.99 0.973 13 152 25.50 184 0.352 ~ 0.99 0.976 14 192 40.23 239 0.490 ~ 0.99 0.978 15 218 49.66 286 0.597 ~ 0.99 0.987 16 312 94.02 409 0.618 ~ 0.98 0.981 17 363 115.81 413 0.745 ~ 0.98 0.985 18 370 124.10 448 0.798 ~ 0.98 0.985

(b ) the mean deviation of the lower bounds derived by the MTS procedure from the bound derived by the LP procedure;

(c) the percentage of infeasible nodes detected by the MTS procedure; and (d) the CPU time (on a VAX 8550 machine) required by the two procedures to find the optimal cycle time.

A t o t a l o f 360 t e s t p r o b l e m s w i t h p r o b l e m s ize N r a n g i n g f r o m t e n to e i g h t e e n (10 _< N_< 18) w e r e

g e n e r a t e d . P a r a m e t e r s u s e d to g e n e r a t e t h e t e s t i n g p r o b l e m s w e r e c i j = U n i f o r m ( 5 , 20), ai= U n i f o r m ( 3 0 , 100), a n d b i = (1 + O ) " a i, 1 _< i _< N , w h e r e p a r a m e t e r O is a p e r c e n t a g e n u m b e r p r e s e n t i n g

t h e t o l e r a n c e in j o b p r o c e s s i n g t i m e s (i .e. , O = (b i - ai)/ai) . T h e d e s i g n o f t h e s e p a r a m e t e r s was b a s e d

o n t h e m a g n i t u d e o f t h e r e a l d a t a g i v e n in [6].

R e s u l t s p r e s e n t e d in T a b l e 2 a n d T a b l e 3 w e r e c o l l e c t e d f r o m t e s t p r o b l e m s w i t h O = 0.5 a n d a9 = 1.0,

r e s p e c t i v e l y , w h e r e

The number of feasible nodes at which the lower bound on the cycle time by the MTS procedure equals the lower bound obtained by the LP procedure

R I - The total number of feasible nodes visited

The n u m b e r of infeasible sequences de tec ted by the MTS p rocedure

a m o n g those de tec ted by the LP p rocedure R2=

The total number of infeasible sequences detected by the LP procedure "

F o r e a c h N , a t o t a l o f 20 t e s t p r o b l e m s w e r e g e n e r a t e d , a n d t h e v a l u e s o f R t a n d R 2 w e r e t h e n

a v e r a g e d fo r e a c h N. F o r al l t h e t e s t p r o b l e m s e v a l u a t e d in t h i s s tudy , t h e M T S p r o c e d u r e t h a t u s e s t h e

Table 3 Performance comparison results with two approaches (the MTS procedure versus the LP procedure) with O = 1.0

N Average # nodes Average CPU time Average # nodes Average CPU time Average Average visited by the (seconds) to find the visited by the (seconds) to find the R l R 2 LP procedure optimal cycle time MTS procedure optimal cycle time by

by the LP procedure MTS procedure

10 11 12 13 14 15 16 17 18

140 14.70 174 0.215 ~ 0.99 0.975 251 36.77 325 0.320 ~ 0.99 0.979 313 48.35 404 0.367 ~ 0.99 0.978 406 79.09 521 0.532 ~ 0.99 0.983 761 135.42 933 0.846 ~ 0.99 0.989

1094 224.04 1301 1.145 ~ 0.99 0.989 1154 333.24 1403 1.164 ~ 0.98 0.990 2238 490.38 2510 2.550 ~ 0.99 0.995 2728 913.34 3073 2.822 2 0.99 0.994


Table 4 Computational effort required to verify the optimal cycle time with benchmark problems

Benchmark N Optimal 1st feasible # LPs # nodes CPU seconds ~' Problems cycle cycle time solved in visited by

length Literature MTS literature the MTS Literature MTS

Black Oxide 1 11 304.10 322.10 315.10 3985 2399 47.06 7.(/4 Black Oxide 2 11 255.70 268.90 266.70 19873 1857 255.51 1.89 Phillips & Unger 12 521.00 563.00 556.00 2896 1222 38.40 0.82 Zinc 15 435.85 435.85 435.85 144 133 3.17 1.39 Copper 11 319.95 319.95 321.00 148 121 2.75 1.14

Both on IBM 3081.

minimal time span parameter to guide the search performed competitively. Three major performance measures with the MTS procedure, the average number of nodes visited during the search process, the average R a and R 2, are close to that with the LP procedure, for all N evaluated. On the other hand, the MTS procedure requires a significantly lower computational effort (in terms of the resulting CPU time) than the LP procedure.

Using the minimal time span to check the infeasibility and the profitability at each non-leaf node during the search process requires only simple algebraic calculations (additions and subtractions), and thus saves the effort required by using LP procedure as a bounding tool. This saved computational effort can also be seen through the comparison results in terms of the benchmark problems in Table 4. For all the five benchmark problems, the number of nodes visited during the search process which uses the minimal time span is no more than the number of LPs solved by [7,8]. This in turn, together with the fact that only simple calculations are required at each node during the search process (except the leaf), results in a significant reduction in the CPU time required to verify the optimal cycle time.

4. Conclusion

We have introduced a sequence-dependent parameter, the minimal time span, that gives a lower bound on the cycle time for candidate sequences, while requiring much less computational effort as compared to that required for solving linear programming problems. A search procedure has been proposed based on this parameter, and computational results have demonstrated its effectiveness. The resulting procedure can also be used to derive a direct solution to the associated linear programming problem under certain conditions.

Two future extensions of this study are of practical value. The first one is concerned with determining the minimal feasible cycle time for the multi-stage process with similar constraints but multiple materials handling transporters. In many practical settings, these transporters, such as cranes, programmable hoists, or mobile robots, have to share a common track in their movements. To ensure the feasibility of a cyclic schedule, additional constraints that prevent the transporters from colliding must be considered. The second extension is to determine the minimal number of transporters required to meet a given cyclic schedule under a fixed cycle time. Transporter scheduling with fixed cycle time is common in those integrated systems where several subsystems must have identical cycle time in order to synchronize their production paces. For problems of this type, minimizing the number of transporters with fixed job processing time at each stage is solvable in polynomial time by using the assignment method. However, the problem becomes much more complicated when the job processing time at each stage is flexible within a given time interval.

References

[1] Lei, L., and Wang, T.J., "The minimum common-cycle algorithm for cyclic scheduling of two hoists with time window constraints", Management Science 37/12 (1991) 1629-1639.


[2] Lei, L., and Wang, T.J., "A proof: The cyclic hoist scheduling problem is NP-complete", Working Paper No. 89-16, Rutgers University, August 1989.

[3] Lei, L., and Wang, T.J., "On the optimal cyclic schedules of single hoist electroplating processes", liE Transactions (in press). [4] Lieberman, R.W., and Turksen, I.B., "Crane scheduling problems", AI1E Transactions 13 (1981) 304-311. [5] Matsuo, H., Shang, J.S., and Sullivan, R.S., "A crane scheduling problem in a computer-integrated manufacturing environment",

Management Science 37/5 (1991) 587-606. [6] Phillips, L.W., and Unger, P.S., "Mathematical programming solution of a hoist scheduling program", AIIE Transactions 8/2

(1976) 219-225. [7] Shapiro, G.W., "Hoist scheduling for a PCB electroplating facility", unpublished M.S. Thesis, North Carolina State University,

1985. [8] Shapiro, G.W., and Nuttle, H.W., "Hoist scheduling for a PCB electroplating facility", liE Transactions 20/2 (1988) 157-167.

Documents

A bounding scheme for deriving the minimal cycle time of a single-transporter N-stage process with time-window constraints