Lot streaming for quality control in two-stage batch production

European Journal of Operational Research 170 (2006) 824–843 www.elsevier.com/locate/ejor

Production, Manufacturing and Logistics

Lot streaming for quality control in two-stage batch production Raymond G. Vickson a, Elkafi Hassini a

b,*

Department of Management Sciences, University of Waterloo, Waterloo, Ont., Canada N2L 3G1 b DeGroote School of Business, McMaster University, Hamilton, Ont., Canada L8S 4M4 Received 29 March 2001; accepted 24 March 2003 Available online 29 September 2004

Abstract We consider a two-stage batch manufacturing process in which the first stage shifts out-of-control at iid exponential times after starting in control. To improve quality, a production batch at Stage 1 is subjected to lot streaming: it is divided into sublots that are processed at Stage 1 and then passed one-by-one to Stage 2 for simultaneous inspection and processing. In any sublot, Stage 1 produces good items before the shift and bad items after. The state of Stage 1 is known as soon as a bad item is encountered in Stage 2, at which time Stage 1 is re-set to the in-control state. We examine both cases of continuous first-stage and continuous second-stage production. For each case we examine both LIFO and FIFO inspection and processing policies at Stage 2. We use nonlinear programming to develop lot streaming policies which minimize the expected number of defective items for LIFO and FIFO policies. We also develop simple approximately optimal policies and compare the output performance of optimal, approximately optimal and equallot policies (when applicable) in a numerical example.
2004 Elsevier B.V. All rights reserved. Keywords: Quality control; Process failure; Two-stage production; Lot streaming

1. Introduction An important class of design and control issues pertain to the manufacturing mode known as batch production. In this context, production batches are work portions separated by setup operations. The batches may be the production runs of one or more products in a high-volume manufacturing system, in which case they are typically formed so as to balance the tradeoffs between setup costs and inventory holding *

Corresponding author. Tel.: +1 905 525 9140x27467; fax: +1 905 521 8995. E-mail addresses: [email protected] (R.G. Vickson), [email protected] (E. Hassini).

0377-2217/$ - see front matter
2004 Elsevier B.V. All rights reserved. doi:10.1016/j.ejor.2004.08.002

R.G. Vickson, E. Hassini / European Journal of Operational Research 170 (2006) 824–843

825

costs. However, they may also be the individual customer order batches in a make-to-order environment. According to Egbelu [7], about 78% of all manufacturing activities in the US fall under the batch production classification, with batch sizes ranging from less than 10 to many thousands. In multi-stage batch production, the jobs must be moved between production stages to satisfy processing needs. Usually it is not possible (or desirable) to move the entire batch as a whole; rather, the process batch is handled by resorting to a strategy known as lot streaming. In this strategy, a production lot is subdivided into several sublots, or transfer batches, which are passed individually to the next stage as soon as they are completed at the current stage. The sublot sizes will typically be constrained by the capacity of installed material handling equipment, floor-space requirements, and similar considerations. Furthermore, the mode of transfer employed from one stage to the next will usually constrain the processing discipline at the subsequent stage to be either of FIFO (first-in-first-out) or LIFO (last-in-first-out) type. In FIFO, the individual units in the next stage are processed in the same order as in the current stage, while in LIFO, they are processed in reverse order, from last to first. Nurani et al. [18] relate several types of material handling systems to their LIFO or FIFO requirements. These matters are also treated at length in [11]. In this paper we assume that material handling equipment is already installed, so that the use of LIFO or FIFO processing is no longer a matter of operating choice. The results obtained herein could be used as input information in the preliminary design stage of material handling selection, but there are numerous other considerations that must also be addressed in making the choice. Groover [10] presents a detailed discussion of the principles involved in selecting material handling equipment. The strategy of lot streaming has gained favor recently in the job scheduling literature, where it has been shown to improve typical scheduling objectives, because it permits a job—a production batch—to be partially processed simultaneously on several machines. Some recent work on lot streaming effects in job scheduling may be found in [2–4,6,7,12,21,27–29]. However, in the past two decades, several writers have begun to stress the idea that small lot sizes may also enhance product quality. McClain et al. [17] describe informally the quality improvements arising from small-lot transfers between work centers. Shingo [26] highlights the importance of immediate feedback on a processesÕ failure through the use of small lot sizes. In his lesson on how JIT systematically improves quality control through small lot sizes, Schonberger [25] writes: The reason why minimum lot sizes lead to lower scrap and better quality may be simply explained: if a worker makes only one of a given number of parts and passes it to the next worker immediately, the first worker will hear about it soon if the part does not fit at one of the next work stations. Thus, defects are discovered quickly and their causes may be nipped in the bud; production of large lots high in defects is avoided. This paper studies the effects of lot streaming on product quality rather than on scheduling measures. It considers a two-stage batch manufacturing process in which the first stage shifts out-of-control at iid exponential times after starting in control. Sublots are processed at Stage 1 and then passed to Stage 2 for simultaneous inspection and processing. In any sublot, Stage 1 produces good items before the shift and bad items after. The state of Stage 1 is known as soon as a bad item is encountered in Stage 2, at which time Stage 1 is re-set to the in-control state. The research in this paper thus presents a quantitative analysis of the effects described qualitatively in [17,25,26]. The aim is to develop lot streaming policies that optimize expected quality for a two-stage batch manufacturing system in the presence of a failure-prone, but restorable first-stage process. A different model for the control of deteriorating production with subsequent failure detection (by customers), is presented in [18]. The aim in [18] is to minimize the long-run discounted cost of holding inventory, backordering and scrapping in the presence of Poisson demand arrivals and exponentially distributed processing times. Units are sent to the output buffer one-by-one, and the decision at any time is whether or not to produce another unit. The model in [18] is appropriate for a high-volume repetitive production facility, whereas the model below is appropriate for batch production. Lee and Rung [14] also study a

826

R.G. Vickson, E. Hassini / European Journal of Operational Research 170 (2006) 824–843

two-stage deteriorating batch production process, but their work deals with lot sizing issues and does not involve lot streaming. Several models have been developed recently to describe quality improvement for randomly deteriorating, but restorable single-stage production processes, by partitioning a production batch into inspection sublots; see [9,13,19,20,22,23,30]. Except for [20], existing models assume that either (i) faults are detected instantaneously at the end of each sublot, or (ii) that processing halts until sublot inspection is completed. In either of these cases, each sublot begins in control because the operator knows whether faulty items occur in the current sublot before starting the next one. This will remain true in the two-stage model for the LIFO processing scenario at Stage 2, but not for the FIFO processing scenario. FIFOÕs extra fault detection delays cause significant complications, and lead to much more complex objective function expressions than those encountered in the previous works on single-stage processes. The paper is organized as follows: Section 2 describes the problem for continuous processing in the first stage, and develops expressions for expected quality under the LIFO and FIFO processing scenarios. It states the policy limitations that will be used in the analysis, and explains why LIFO is superior to FIFO within these limitations. Sections 3 and 4 develop the optimization models for continuous first-stage processing in the LIFO and FIFO cases, respectively. They also develop usable closed form approximate solutions. Section 5 develops the model in the presence of interrupted first-stage processing, concentrating on the special case of continuous processing in the second stage. Section 6 reports on some numerical results that show how expected quality varies with the number of sublots. It compares the results obtained from the simple approximate solutions with those obtained from a nonlinear optimization package. Finally, Section 7 briefly summarizes the findings and discusses possible extensions.

2. The problem for continuous Stage 1 processing The problem may be described as follows. A batch of U identical units is to be manufactured in a twostage flow shop. The first stage processes all the units in the batch from first to last without interruption. The process at Stage 1 starts in control, but shifts out-of-control at a random time. Stage 1 produces only good items when in control and only faulty items when out-of-control. An out-of-control condition persists until the presence of faulty items is detected by the operator at Stage 2, at which point Stage 1 is informed about the problem and instantly resets the process to the in-control condition. Rather than completing all U units before transferring them to Stage 2, Stage 1 may split the production batch into n sublots of sizes u1, u2, . . . , un, and transfer each sublot to Stage 2 as it is finished. This lot streaming strategy leads to enhanced quality because the detection of faulty units in a sublot allows Stage 1 to be re-set to good condition prior to completion of the whole production batch. An ideal model would consider discrete production increments with failure in Stage 1 occurring at a discrete, geometrically distributed random item; that is, as in [9] there would be a constant probability a of failure after each unit is produced. The resulting model would add complications without adding insight. This paper adopts instead a continuous work model, in which Stage 1 shifts out-of-control at a random time having an exponential distribution with mean 1/k. It is assumed that after each re-set operation, the next time to failure at Stage 1 is again exponentially distributed with mean 1/k. The model assumes deterministic processing times in each stage. For highly automated systems the assumption of deterministic processing times is valid (this being one reason for automating); see [10]. Deterministic processing times are usually merely an approximation if the production system is largely manual in nature [10], but in many cases the approximation will be a reasonable one. The problem treated here becomes much more difficult if the processing times at either or both of the two stages are regarded as random variables, so for this reason such investigations are left to future research.

R.G. Vickson, E. Hassini / European Journal of Operational Research 170 (2006) 824–843

827

In the sequel, choose time units so that the processing times per item at Stages 1 and 2 are equal to 1 and p 5 0, respectively. Assume as well that (i) Stage 2 always remains in control; (ii) transfer time is negligible; (iii) inspection is instantaneous; and (iv) process re-set is instantaneous. The problem becomes more difficult if any of these three assumptions is violated, so the resulting models are left to future research. In the LIFO scenario, the operator at Stage 2 processes a sublotÕs units in reverse order of their production at Stage 1. In this case, the last item from Stage 1 is examined first. If the last item is defective, this fact is noted and relayed to Stage 1, where the process is then instantly re-set to good condition. On the other hand, if the last unit in the sublot is good, then all units in the sublot are good, and so Stage 1 is told to continue working without re-setting the process. In either case Stage 1 starts the next sublot in control, provided that Stage 2 is ready to start processing a sublot as soon as it is released from Stage 1. In contrast, for the FIFO case Stage 2 does not detect faulty units until all preceding good units in the sublot have been processed. Since the production rate 1/p is finite, detection of faulty units is delayed, thus allowing Stage 1 to unknowingly continue producing bad output during part of the next sublot. These differences suggest that the LIFO method should be used whenever possible, a fact that is justified formally in the sequel. Both methods are of interest, however, since a previously-installed material handling system may dictate the use of one method or the other. It is assumed throughout this paper that in the FIFO processing case, Stage 1 does not knowingly transfer faulty items to Stage 2; that is, it scraps the items produced in a sublot before restoring a faulty process, transferring only those items in a sublot produced after restoration. (Scrapped items may be discarded or later reworked separately.) Of course, if the process fails again in the same sublot, Stage 1 will transfer to Stage 2 those faulty items it produces but does not know about. An alternative, more complex FIFO processing model is obtained if Stage 1 transfers to Stage 2 all items, whether known to be faulty or not. This model will be presented elsewhere. 2.1. Synchronization This paper neglects possible capacity constraints on the individual sublot sizes. Rather, the view is taken that the problem can be solved for various numbers of sublots, until a policy is obtained that satisfies capacity restrictions (if any). However, the paper does restrict attention to policies in which no quality information is wasted. This is taken to mean: (i) in the LIFO case a first-stage process that fails in sublot 1 is corrected before starting sublot 2, and so forth; and (ii) in the FIFO case a process that fails in sublot 1 is corrected during sublot 2, and so forth. These requirements will impose constraints on the relative magnitudes of successive sublots. In the absence of failure, Stage 2 requires pui time units to complete working on sublot i, so would always be ready immediately to receive sublot (i + 1) from Stage 1 only if pui 6 ui+1. In the LIFO case these need hold only for i 6 n
2, as this guarantees that sublots 3, . . . , n always start in control. Of course, sublot 2 always starts in control, so no constraint is needed when n = 2. For FIFO processing the above constraints must hold for i 6 n
1, which guarantees that failures are always corrected during sublots 2, . . . , n. Unlike in the LIFO case, such a constraint is required even if n = 2, since otherwise Stage 1 could produce a completely faulty second sublot if the failure occurred just before the end of the first one. Definition 1. Policy (u1, u2, . . . , un) is called partially synchronized with continuous Stage 1 processing (PSC1) if the constraints pui 6 ui+1 hold for sublots i 6 n
2 and is called fully synchronized with continuous Stage 1 processing (FSC1) if it holds as well for i = n
1. This paper allows the ui to assume any real values. Then, for moderate values of n = 2, 3, . . . , nonlinear programming is used to determine PSC1 policies (for LIFO) or FSC1 policies (for FIFO) that maximize the expected number of good items from Stage 1.

828

R.G. Vickson, E. Hassini / European Journal of Operational Research 170 (2006) 824–843

2.2. Expected quality Let e n denote the exponentially distributed time to first failure at Stage 1 and let G1 ðuÞ ¼ minðe n; uÞ denote the number of good items in a single (sub)lot of size u that starts with Stage 1 in control. The expected value of G1(u) is G1 ðuÞ ¼ ð1
e
ku Þ=k, see [9,13]. More generally, let the random quantity Gn(u) denote the total number of good items produced under sublot policy u = (u1, u2, . . . , un), and let Gn ðuÞ denote its expected value. Let us avoid notational clutter by using the same symbols for both the LIFO and FIFO cases. In the sequel, let x = (x1, . . . , xn) = (ku1, . . . , kun), V n ðxÞ ¼ kGn ðuÞ and N = kU. 2.2.1. LIFO processing With LIFO processing at Stage 2, each sublot at Stage 1 starts in control. The memoryless property of the exponential distribution [8,24] implies that the time to the next failure has the same distribution, whether P the process is P re-set to good condition or continues in good conditionPwithout intervention. Thus Gn ðuÞ ¼ ni¼1 G1 ðui Þ ¼ ni¼1 ð1
e
kui Þ=k, so Vn(x) = n
fn(x), where fn ðxÞ ¼ ni¼1 e
xi . 2.2.2. FIFO processing For the FIFO case: (1) if e n > u1 , the process has not yet failed by the end of sublot 1, so the entire remaining sublot sequence (u2, . . . , un) starts in control; and (2) if e n < u1 , the failed process is restored at t ¼ pe n time units after Stage 1 starts the second sublot, so the remaining sublot sequence ðu2
p e n; u3 ; . . . ; un Þ starts in control. In both cases the remaining sequences satisfy the FS constraints for n
1 sublots. Thus Gn ðuÞ ¼ e n þ Gn
1 ðu2
p e n; u3 ; . . . ; un Þ if e n < u1 and Gn(u) = u1+Gn
1(u2, u3, . . . , un) if e n P u1 . This gives Z u1 Gn ðuÞ ¼ G1 ðu1 Þ þ e
ku1 Gn
1 ðu2 ; . . . ; un Þ þ ke
kn Gn
1 ðu2
pn; u3 ; . . . ; un Þ dn: 0

An easy induction on n shows that V n ðxÞ ¼ kGn ðuÞ has the form Vn(x) = n
fn(x), where f1(x) = e
x and Z x1
x1
x1 fn ðx1 ; x2 ; . . . ; xn Þ ¼ e þ e fn
1 ðx2 ; . . . ; xn Þ þ e
y fn
1 ðx2
py; x3 ; . . . ; xn Þ dy ð1Þ 0

for n P 2. 2.3. LIFO vs. FIFO For any given FS policy the FIFO processing scenario incurs extra process restoration delays beyond those of the LIFO scenario. This suggests that LIFO should produce more good items than FIFO under the same FS policy. The following result justifies this intuition. Theorem 1. For any FS policy the expected number of non-defectives is higher under LIFO than under FIFO processing. Theorem 1 will not be proved here because it is a special case of a result that is proved later, in Section 5. The optimal FS policy for FIFO is a feasible policy for LIFO, but may be suboptimal for the latter because of the extra constraint pxn
1 6 xn. Therefore, LIFO processing may have even greater advantages than indicated in Theorem 1. 2.3.1. Notes 1. The next section shows that for LIFO processing with p 6 1, results for the two-stage case are the same as for the one-stage models in [9,13,22,23].

R.G. Vickson, E. Hassini / European Journal of Operational Research 170 (2006) 824–843

829

2. The quality performance of LIFO and FIFO is the same if the second stage uses a modified FIFO policy in which the last item in a sublot is always inspected before any work begins. However, the last item may not be physically accessible initially, so this may be impossible in practice: the second stage may have no choice but to use a FIFO policy exactly as defined above. 3. System control may be achieved by inserting signal kanbans [26] into the production batch at the locations of sublot boundaries. Equal-sized sublots are thus simpler to plan, but not substantially simpler to manage than unequal sublots. 4. For a PS policy under LIFO or an FS policy under FIFO processing, the total number of good items from Stage 1 is unaffected by whether Stage 2 processes good items only, or processes both the good and bad items it receives from Stage 1 at the same rate 1/p.

3. Optimal LIFO policies for continuous Stage 1 processing For continuous first-stage processing under LIFO, the problem of maximizing the expected number of good items is n X min fn ðxÞ ¼ e
xi i¼1

s.t.

pxi 6 xiþ1 ; i ¼ 1; . . . ; n
2; n X xi ¼ N ;

ð2Þ

i¼1

xi P 0;

i ¼ 1; . . . ; n.

This can be reduced to a simple one-dimensional optimization problem, by noting first that if the constraints pxi 6 xi+1 are omitted, the optimal solution has equal sublots x1 ¼ x2 ¼    ¼ xn ¼ N =n. ð3Þ (See, e.g., [9].) If p 6 1, solution (3) satisfies the omitted constraints and hence also solves (2). Intuitively, the optimal solution for p > 1 should remain as close as possible to the equal sublots solution, so should satisfy pxi = xi+1 for i 6 n
2. This is justified by the following result. Theorem 2. If p > 1, k P 1 and S > 0, the point x1 ¼ x , x2 ¼ px ; . . . ; xk ¼ pk
1 x , x = (p
1)S/(pk
1), is a Kuhn–Tucker point for the problem k X e
xi min i¼1

s.t.

pxi 6 xiþ1 ; i ¼ 1; . . . ; k
1; k X xi ¼ S;

ð4Þ

i¼1

xi P 0;

i ¼ 1; . . . ; k.

Proof. Let LðxÞ ¼

k X i¼1

e


xi

þ

k
1 X i¼1

vi ðpxi
xiþ1 Þ þ vk S


k X

! xi

i¼1

be the Lagrangian for (4). The Kuhn–Tucker conditions for (4), see [15], state that oL(x )/oxi = 0 for i = 1, . . . , k, that vi P 0 for i = 1, . . . , k
1, that the constraints hold, and that either pxi
xiþ1 ¼ 0 or

830

R.G. Vickson, E. Hassini / European Journal of Operational Research 170 (2006) 824–843

vi = 0 for each i 6 k
1. The inequality constraints are all tight at x , so the only remaining conditions are
 oL(x )/oxi = 0 for i 6 k and vi P 0 for i 6 k
1. Writing bi ¼ expð
xi Þ and vk ¼ vþ k
vk , vk P 0, these T
T conditions become Av = b and v P 0, where v ¼ ðv1 ; v2 ; . . . ; vk
1 ; vþ ; v Þ and b = (b , b , . . . , b 1 2 k) are colk k umn vectors and A is the k · (k + 1) matrix 1 0 p 0 0    0
1 1 C B B
1 p 0    0
1 1 C C B C B A ¼ B 0
1 p    0
1 1 C: C B .. C B . A @ 0 0 0   
1
1 1 By FarkasÕ Lemma (see, e.g. [5]), the linear system Av = b, v P 0 has a solution if, and only if the dual system wA P 0, wb < 0 has no row-vector solution w = (w1, w2, . . . , wk). To prove the latter property, conPk sider any w 5 0 such that wA P 0. These inequalities read as pwi P wi+1, i = 1, . . . , k
1,
i¼1 wi P 0 Pk Pk Pk and i¼1 wi P 0, hence i¼1 wi ¼ 0. Let i = max{l : wl > 0} and j = min{l : wl < 0}. Since l¼1 wl ¼ 0, p > 1 and w 5 0, we have 1 6 i < j 6 k. Furthermore, wl > 0 if l 6 i, wl < 0 if l P j and wl = 0 ifPi < l < j. i    Now i Þ ¼ expð
xiþ1 Þ, so b1 > b2 >    > bk > 0. This implies wb P bi l¼1 wl
Pi Pk expð
xi Þ > expð
px bj l¼j wl ¼ ðbi
bj Þ l¼1 wl > 0, so wb < 0 is impossible. h The objective function in (2) is strictly convex, so any Kuhn–Tucker point of (2) is a globally optimal solution [15]. For any fixed xn, put S = N
xn and k = n
1 in Theorem 2 to conclude that the optimal xi have the form xi = pi
1x for i 6 n
1, and xn = N
x(pn
1
1)/(p
1). Thus, (2) becomes the problem of minimizing

n
1  n
1 X p
1 i
1 x
N expð
p xÞ þ exp /ðxÞ ¼ p
1 i¼1 over the interval 0 6 x 6 N(p
1)/(pn
1
1). Although minimizing /(x) numerically is not difficult, even for large n, it is still useful to have a more : easily computed approximate solution. Applying the second order expansion expðhÞ¼1 þ h þ 12 h2 in all terms of / gives

2

 1 p2n
2
1 2 1 pn
1
1 : N
x /ðxÞ¼n
N þ þ : x 2 p2
1 2 p
1 The right-hand side above is minimized at x = (p2
1)N/[2(pn
1)], which yields the following approximate solution x = xq for p > 1: xqi ¼

1 p2
1 i
1 p N; 2 pn
1

i ¼ 1; . . . ; n
1;

pn
1
1 1 ðp
1Þðpn
1 þ 1Þ xq1 ¼ N: xqn ¼ N
p
1 2 pn
1

ð5Þ

4. Optimal FIFO policies for continuous Stage 1 processing For continuous first-stage processing under FIFO, the problem of maximizing the expected number of good items is

R.G. Vickson, E. Hassini / European Journal of Operational Research 170 (2006) 824–843

min

fn ðxÞ

s.t.

pxi 6 xiþ1 ; n X

831

i ¼ 1; . . . ; n
1; ð6Þ

xi ¼ N ;

i¼1

i ¼ 1; . . . ; n;

xi P 0;

where the fn are given by the recursion (1). 4.1. The case p51 For p 5 1, let a1 = 1
p and ai = 1
pai
1 for i P 2. Then f2 ðx1 ; x2 Þ ¼ e
x1 þ e
x1
x2 þ

1 1 1 ð1
e
ð1
pÞx1 Þe
x2 ¼ e
x1 þ e
x1
x2
e
a1 x1
x2 þ e
x2 ; 1
p a1 a1 1
x1
a1 x2
x3 1 1 e
e
a1 x1
x2
e
a1 x1
x2
x3 a1 a1 a1 1
x2 1
x2
x3 1
a1 x2
x3 1 þ e þ e
e þ e
x3 a1 a1 a1 a2 a1

f3 ðx1 ; x2 ; x3 Þ ¼ e
x1 þ e
x1
x2 þ e
x1
x2
x3
þ

1
a2 x1
a1 x2
x3 e a1 a2

and so forth. The general fn(x) can be obtained by using the recursion (1) to successively compute f1(x Pnk), f2(xn
1, xn), etc. To this end, assume that fk = fk(xn+1
k, xn+2
k, . . . , xn) has the form fk ¼ j¼0 fkj , where fk0 = fk0(xn+2
k, . . . , xn), fk1 = exp(
xn+1
k)gk1(xn+2
k, . . . , xn), and fkj = exp(
aj
1xn+1
k)gkj (xn+2
k, . . . , xn) for j = 2, . . . , k. This assumption holds for k = 1, 2 and 3. Consider now how each of these terms propagates from fk to fk+1 in the recursion (1). 1. The term fk0 propagates unchanged. Rx 2. The term fk1 propagates to expð
xn
k Þfk1 þ 0 n
k expð
y þ pyÞfk1 dy ¼ expð
xn
k Þfk1 þ ð1=a1 Þ ½1
expð
a1 xn
k Þ fk1 ¼ expð
xn
k Þfk1 þ ð1=a1 Þfk1
ð1=a1 ÞRexpð
a1 xn
k Þfk1 . x 3. For j > 1 the term fkj propagates to expð
xn
k Þfkj þ 0 n
k expð
y þ paj
1 yÞfkj dy ¼ expð
xn
k Þfkj þ ð1=aj Þfkj
ð1=aj Þ expð
aj xn
k Þfkj . It follows that fk+1 = fk+1(xn
k, . . . , xn) has the form fkþ1 ¼ fkþ1;0 ¼ fk0 þ

k X 1 fkj ; a j j¼1

fkþ1;1 ¼ expð
xn
k Þ 1 þ

k X

Pkþ1

j¼0 fkþ1;j ,

where

! fkj ;

ð7Þ

j¼1

fkþ1;jþ1

1 ¼
expð
aj xn
k Þfkj ; aj

j ¼ 1; 2; . . . ; k:

The recursions (7) are initialized using f1,0 = 0 and f1,1 = exp(
xn). For moderate values of n, say n 6 7, these recursions are well suited to spreadsheet implementation, with (7) acting not as a set of constraints, but merely as intermediate steps in the final computation of fn(x) for a given x. The only ‘‘constraints’’ in this approach are those of the original problem (6). On the other hand, in

832

R.G. Vickson, E. Hassini / European Journal of Operational Research 170 (2006) 824–843

a modeling language implementation the fkj may be regarded as additional variables and the relations (7) as additional nonlinear equality constraints. We use this method to formulate the problem in the GAMS 2.25 modeling language, and solve it using the MINOS 5.4 nonlinear solver. 4.2. The case p = 1 When p = 1, Eq. (1) gives f2 ðx1 ; x2 Þ ¼ e
x1 þ e
x1
x2 þ x1 e
x2 ; f3 ðx1 ; x2 ; x3 Þ ¼ e
x1 þ e
x1
x2 þ e
x1
x2
x3 þ e
x1
x3 þ x1 e
x2 þ x1 e
x2
x3 þ x1 e
x1
x3 þ ðx2
1Þe
x3 and so forth. A general, recursively-computable expression for fn is obtainable in terms of the functions uj ðxÞ ¼ e
x xj =j!; j ¼ 0; 1; 2; . . . ; vj ðxÞ ¼ xj =j!; j ¼ 1; 2; . . . ; p1 ðxÞ ¼ x
1 ¼ v1 ðxÞ
1 and j

pj ðxÞ ¼ vj ðxÞ
vj
1 ðxÞ þ    þ ð
1Þ ¼ vj ðxÞ
pj
1 ðxÞ;

j ¼ 2; 3; . . . Pk Pk Assume that fk = fk(xn+1
k, . . . , xn) has the form fk ¼ C k þ rj¼0 uj ðxnþ1
k ÞAkj þ sj¼1 vj ðxnþ1
k ÞBkj , where Ck, Akj and Bkj are functions of xn+2
k, . . . , xn. This is certainly true for k = 1 and 2, with r1 = s1 = 0 and r2 = 0, s2 = 1. Temporarily set xn
k = x and xn+1
k = x 0 for notational convenience. Now examine the propagation of terms from fk into fk+1 through the recursion (1). 1. The term Ck propagates unchanged. 2. The term uj (x 0 )Akj propagates to   Z x j
x 0
y 0 y
x0 e uj ðx Þ þ e ððx
yÞ =j!Þe dy Akj : 0 0

The binomial expansion e
x ðx0
yÞj =j! ¼ "

Pj

i¼0 ð
1Þ

i

uj
i ðx0 Þvi ðyÞ yields the result

# Z x j X i 0 ð
1Þ uj
i ðx Þ vi ðyÞ dy Akj ¼ ½u0 ðxÞuj ðx0 Þ þ v1 ðxÞuj ðx0 Þ
v2 ðxÞuj
1 ðx0 Þ u0 ðxÞuj ðx Þ þ 0

0

i¼0

þ    þ ð
1Þj vjþ1 ðxÞu0 ðx0 Þ Akj : Rx 3. The term vj(x 0 )Bkj propagates to ½e
x vj ðx0 Þ þ 0 e
y ððx0
yÞj =j!Þ dy Bkj . Now the binomial expansion Rx Rx Pj i 0 u ðyÞ dy ¼ 1
u0 ðxÞ and yields an integral i¼0 ð
1Þ vj
i ðx Þ 0 ui ðyÞ dy. Since 0 0 Rx Pi of the form u ðyÞ dy ¼ 1
u ðxÞ for i P 1, the result is l¼0 l 0 i " 0

vj ðx Þ þ

j
1 X i¼1

i

0

ð
1Þ vj
i ðx Þ 1


i X l¼0

! ul ðxÞ

þ ð
1Þ

j

1


j X

!# ul ðxÞ

Bkj

l¼0

¼ ½pj ðx0 Þ þ u0 ðxÞpj
1 ðx0 Þ þ u1 ðxÞpj
1 ðx0 Þ
u2 ðxÞpj
2 ðx0 Þ þ    þ ð
1Þj
1 uj ðxÞ Bkj :

R.G. Vickson, E. Hassini / European Journal of Operational Research 170 (2006) 824–843

833

P sk Prk þ1 It follows that fkþ1 ¼ C kþ1 þ j¼0 uj ðxn
k ÞAkþ1;j þ j¼1 vj ðxn
k ÞBkþ1;j , where sk X C kþ1 ¼ C k þ pj ðxnþ1
k ÞBkj ; j¼1

Akþ1;0 ¼ 1 þ Akþ1;1 þ Bkþ1;1 ; " # sk X j
1 Akþ1;j ¼ ð
1Þ Bkj þ pi
j ðxnþ1
k ÞBki ;

j ¼ 1; . . . ; sk ;

ð8Þ

i¼jþ1

Bkþ1;j ¼ ð
1Þ

j
1

rk X

uiþ1
j ðxnþ1
k ÞAki ;

j ¼ 1; . . . ; rk þ 1:

i¼j
1

Since rk+1 = sk and sk+1 = rk + 1, it follows that rn = b(n
1)/2c and sn = bn/2c, where bhc denotes the greatest integer not exceeding h. In a modeling language the Ck, Akj, Bkj, ukj = uj (xn+1
k), vkj = vj (xn+1
k) and pkj = pj (xn+1
k) can be regarded as additional variables that are subject to nonlinear equality constraints, viz., the definitions of the uj, vj and pj, and the recursions (8). These recursions are also practical for spreadsheet implementation, for moderate values of n. 4.3. Approximate solution Rather than using the full power of the nonlinear program (6), a decision maker may prefer to use a more easily computed closed-form approximate solution. For this reason, it is worthwhile to examine as well an approximate policy obtained from a quadratic approximation to fn for small xi. Starting from the second order expansion f1(x) G 1
x + x2/2, and keeping P in the recursion (1) all terms of the form Pn
1 n xi, x2i and xixj, it follows that fn(x) G qn(x), where qn ðxÞ ¼ n
i¼1 xi þ ð1=2Þðp þ 1Þ i¼1 x2i þ ð1=2Þx2n . Using qn instead of fn in (6) yields the following strictly convex quadratic program: n
1 X 1 1 ðp þ 1Þ x2i þ x2n min 2 2 i¼1 s.t.

pxi 6 xiþ1 ; i ¼ 1; . . . ; n
1; n X xi ¼ N ;

ð9Þ

i¼1

xi P 0;

i ¼ 1; . . . ; n.

Problem (9) is easily solved in closed form. Note first that if the constraints pxi 6 xi+1 are dropped, the solution is x = xq: 1 N ; i ¼ 1; . . . ; n
1; xqi ¼ pþn ð10Þ pþ1 N: xqn ¼ pþn If p 6 1 this solution satisfies the omitted constraints, hence solves (9). As p is increased to 1 in (10) the constraints pxi 6 xi+1 become tight Assuming that they remain tight for p > 1, let xi = pi
1x1 Pn
1for i 6 n
2. n
1 for i 6 n
1 and set xn ¼ N
i¼1 xi ¼ N
ðp
1Þx1 =ðp
1Þ. For such x the objective in (9) becomes

2 1 p2n
2
1 2 1 pn
1
1 ðp þ 1Þ 2 N
x1 ; x þ 2 p
1 1 2 p
1 which is minimized at x1 = (p
1)N/(pn + p
2). This solution satisfies

834

R.G. Vickson, E. Hassini / European Journal of Operational Research 170 (2006) 824–843

xn ¼ N


pn
1
1 p
1 ðp
1Þðpn
1 þ 1Þ ðp
1Þpn
1  n N¼ N> n N ¼ pxn
1 : n p
1 p þp
2 p þp
2 p þp
2

Global optimality of this solution follows from the following. Theorem 3. For p > 1 the Kuhn–Tucker conditions for problem (9) are satisfied at x = xq, where ðp
1Þpi
1 N ; i ¼ 1; . . . ; n
1; pn þ p
2 ðp
1Þðpn
1 þ 1Þ N: xqn ¼ pn þ p
2 xqi ¼

ð11Þ

Proof. Since pxq,n
1 < xqn, the last synchronization constraint is inactive at xq, so Lagrangian of (9) in a neighborhood of x = xq is ! n
1 n
2 n X X 1 1 2 X 2 LðxÞ ¼ ðp þ 1Þ xi þ xn þ vi ðpxi
xiþ1 Þ þ v N
xi : 2 2 i¼1 i¼1 i¼1 The Kuhn–Tucker conditions in this case include oL/oxi = 0 for i = 1, . . . , n, and vi P 0 for i = 1, . . . , n
2. Defining v0 = vn
1 = 0, the conditions oL/oxi = 0 yield xi = (v
pvi + vi
1)/(p + 1) for i 6 n
1. The constraints pxqi = xq,i+1 for i 6 n
2 imply ðp2 þ 1Þvi
pvi
1
pviþ1 ¼ ðp
1Þv; whose unique solution, subject to v0 = vn
1 = 0, is   v pi þ pn
1
i 1
n
1 vi ¼ ; i ¼ 0; . . . ; n
1: p
1 p þ1 This yields x1 = (v
pv1)/(p + 1) = v/(pn
1 + 1) after simplification. Now oL/oxn = xn
v = 0 and Pn
1 xn ¼ N
i¼1 pi
1 x1 give v = (p
1)(pn
1 + 1)N/(pn + p
2), hence x1 = (p
1)N/(pn+p
2) = xq1. Since v > 0, the vi are strictly concave in i, and since v0 = vn
1 = 0 it follows that vi > 0 for 1 6 i 6 n
2. Thus, the Kuhn–Tucker conditions hold at x = xq. h For p 6 1, the approximate solution xq puts the first n
1 sublots equal to each other, while the nth sublot is slightly larger. In this case, the simpler policy xe = (N/n, N/n, . . . , N/n) of equal sublots is also feasible, as it satisfies the synchronization constraints. Numerical results are shown later for the policies x , xq and (when p 6 1) for the policy xe as well. Note that for p > 1, the equal-sublots policy and continuous firststage processing together violate synchronization. Such non-synchronized policies cannot be evaluated with the methods developed in this paper. They lead to analytically intractable expressions which can only be assessed using simulation.

5. Interrupted processing in Stage 1 The next section presents some numerical results showing that the approximate solutions xq in (5), (10) and (11) are very effective, being almost optimal in a wide range of problems. Therefore, the behavior of xq for varying n and p can be used to gain insight into the nature of effective policies. In particular, when p 6 1 the policy is quite satisfactory, in the sense that the different sublots are reasonably balanced and quality improvements are significant as the number of sublots is increased. This occurs because Stage 2 keeps

R.G. Vickson, E. Hassini / European Journal of Operational Research 170 (2006) 824–843

835

up with Stage 1, so the constraints pui 6 ui+1 are relatively weak. For p = 1 the planned processing is continuous in both stages, except for a scheduled idle time between the last two sublots at Stage 2. Of course, if failures occur at Stage 1 there may be actual, unplanned idle times between some other sublots at Stage 2, because the latter may not receive all of the work it was scheduled to perform. For p < 1, the processing is continuous in the first stage but is interrupted in the second stage, with some planned idle times occurring between all of the sublots. In this case, the first stage cannot keep up with the second, so inserted Stage-2 idle times are unavoidable in a quality-optimal policy. The situation changes when p > 1, so that Stage 2 cannot keep up with Stage 1. The synchronization condition pui 6 ui+1 requires that successive sublots increase in size at a geometric rate governed by the magnitude of p. When the processing rate imbalance is slight (say, p 6 1.25) and the number of sublots is moderate (say, n 6 10), the imbalance between the different sublots is perhaps not excessive. However, if the processing rate imbalance is much larger the resulting optimal synchronized policy leads to extremely unbalanced sublots. For example, when p = 2 and n = 10 the last sublot may be more than half of the total production lot, and may be more than 500 times larger than the first sublot. Furthermore, the quality measure ‘‘flattens out’’ after the first few sublots, so that going from, say, n = 10 to n = 11 sublots yields very little increase in quality. When p > 1, the twin desires of continuous first-stage processing and on-line quality control counteract each other, simply because the first stage runs ahead of the second. Practical and effective results cannot be obtained without moderating Stage 1, allowing Stage 2 to better keep up with it. For this reason, it is advantageous to consider as well a policy of interrupted production in the first stage, hereafter called an I1 policy. This type of policy allows an inserted idle time Ii between sublots i and (i + 1) in Stage 1. The corresponding synchronization condition is pui 6 Ii+ui+1, which is assumed to hold for i = 1, 2, . . . , n
2 under LIFO and for i = 1, 2, . . . , n
1 under FIFO processing. Such policies require constraints on the idle times Ii in order to be realistic, since otherwise the first stage could merely delay starting a new sublot until the second stage finishes its current one. In such an extreme case, the two stages would alternate their work, and both would incur large idle times. A special case of particular interest is that of continuous second-stage processing. By this we mean that the planned schedule calls for Stage 2 to work without interruption from start to finish. Of course, the actual schedule will be interrupted if failures occur in Stage 1, so that Stage 2 receives less than the planned work. Continuous planned processing in the second stage is obtained by imposing the constraints pui = Ii + ui+1, as these guarantee that in the absence of failures, sublot i completes in Stage 2 exactly when sublot (i + 1) completes in Stage 1. In this case, the requirements Ii P 0 imply that pui P ui+1, which is the opposite of the FS condition for the continuous first-stage processing scenario. Definition 2. A policy (u1, . . . , un; I1, . . . , In
1) is called (a) PSI1 or FSI1 (partially or fully synchronized, with interrupted Stage 1 processing) according as the constraints pui 6 Ii + ui+1 hold for i 6 n
2 or i 6 n
1, respectively; and is called (b) PSC2 or FSC2 (partially or fully synchronized, with continuous Stage 2 processing) according as the constraints pui = Ii + ui+1 hold for i 6 n
2 or i 6 n
1, respectively. Policies of PSC2 or FSC2 type possess the operational advantage of at least having continuous planned processing in one of the two stages. General policies of PSI1 or FSI1 type may produce slightly higher quality measures, but possess the disadvantage of having interrupted processing in both stages, in violation of JIT principles. For this reason, our numerical study of I1 policies is restricted to those of PSC2 or FSC2 type. In line with the interpretation of the failure-during-use model, assume that the mechanism leading to failure is in effect only when production occurs. Therefore, the Stage-1 failure mechanism stops during an idle period and resumes from where it left off when Stage 1 resumes work. This means that the

836

R.G. Vickson, E. Hassini / European Journal of Operational Research 170 (2006) 824–843

time to next failure after an idle period still has distribution exponential (k), exactly as in the no-idle-time case. Notation Now a policy must specify both the sublot sizes u = (u1, . . . , un) and the inserted first-stage idle times I = (I1 . . . , In
1). The following developments use the equivalent variables x = ku and z = (z1, . . . , zn
1) = kI/p. The total number of good items is now denoted by Gn(u; I), and is developed below. The expected number of good items Gn ðu; IÞ will be measured by the equivalent quantity V n ðx; zÞ ¼ kGn ðu; IÞ. 5.1. LIFO processing in Stage 2 The objective Vn(x; z) under LIFO is independent of z for any PSI1 policy, so is identical to Vn(x) in Section 2.2. In this case the only role played by the idle time variables is to relax the synchronization constraints, allowing the policy for p > 1 to more nearly match that for p 6 1. A realistic Pn
1 formulation may also require additional constraints on (x; z). For example, these may take the form i¼1 zi 6 a for some specified a > 0. Alternatively, they may take the form of a bound on the planned makespan " # n
1 n
2 X X C max ¼ ð1=kÞ xi þ p zi þ maxðpzn
1 þ xn þ pxn ; pxn
1 þ pxn Þ : i¼1

i¼1

All such problems are easily treated using a spreadsheet optimizer. 5.1.1. A special case: continuous Stage 2 processing A noteworthy special case is obtained under PSC2 processing when the extra constraints take the form Pn
2 i¼1 zi 6 ðp
1Þðn
2ÞN =np. The resulting optimal solution is xi ¼ N =n; i ¼ 1; . . . ; n; and zi ¼ ðp
1ÞN =np; i ¼ 1; . . . ; n
2:

ð12Þ

The optimal policy in this case is xe, the equal-sublots solution. This policy yields fn ¼ n expð
N =nÞ, exactly as in the optimal LIFO solution with p 6 1. This result is also the same as in the single-stage models in [9,13,22,23]. 5.2. FIFO processing in Stage 2 Let y = kn, for realization n of the time to first failure e n. It is evident that (1) the entire remaining FSI1 sequence (x2, . . . , xn; z2, . . . , zn
1) starts in control if either y > x1 or y 6 z1, because in the former case the process has not failed in sublot 1, and in the latter case the failed process is restored within the idle time pz1 preceding sublot 2; and (2) if z1 < y < x1, the process is restored at py
pz1 time units after Stage 1 starts sublot 2. In this case the remaining FSI1 sequence (x2 + pz1
py,x3, . . . , xn; z2, . . . , zn
1) starts in control. It follows that Vn(x; z) = n
fn(x; z), where f1(x) = e
x and fn ðx; zÞ ¼ e
x1 þ ðe
x1 þ 1
e
z1 Þfn
1 ðx2 ; . . . ; xn ; z2 ; . . . ; zn
1 Þ Z x1 þ e
y fn
1 ðx2 þ pz1
py; x3 ; . . . ; xn ; z2 ; . . . ; zn
1 Þ dy

ð13Þ

z1

for n P 2. For an FSI1 policy under FIFO, the problem of maximizing the expected number of good items is a nonlinear programming problem like (6), but with objective fn(x; z) instead of fn(x), with relaxed synchroniza-

R.G. Vickson, E. Hassini / European Journal of Operational Research 170 (2006) 824–843

837

P tion constraints and with possible additional constraints on i zi or on planned makespan. The extra FIFO constraint pxn
1 6 pzn
1 + xn implies that the last sublot startshat Stage 2 as soon as iit finishes at Stage 1, so Pn
1 the planned makespan expression is changed to C max ¼ ð1=kÞ N þ p i¼1 zi þ pxnþ1 . Pn As before, fn has the form fn ¼ j¼0 fnj , with f1,0 = 0, f1,1 = exp(
xn) and, for k = 1, 2, . . . , n
1,  k X paj
1 fkþ1;0 ¼ fk0 þ 1þ expð
zn
k Þ fkj ; aj j¼1 ! k X ð14Þ fkj and fkþ1;1 ¼ expð
xn
k Þ 1 þ j¼1

fkþ1;jþ1 ¼


1 expð
aj xn
k
paj
1 zn
k Þfkj ; aj

j ¼ 1; . . . ; k;

where a0  1. These recursions are well suited to spreadsheet implementation for moderate n (typically, n 6 7). They can also be formulated in a modeling language, where they act as nonlinear equality constraints on the additional variables fkj. The resulting nonlinear optimization problem is more difficult to solve than before, for reasons that are explained in Section 6. 5.3. Approximate solution As before, truncating the fk to second-order xi and zi terms in the recursion (13) gives fn(x; z) G qn(x; z), where qn ðx; zÞ ¼ n


n X i¼1

xi þ

n n
1 1X pX x2i þ ðxi
zi Þ2 : 2 i¼1 2 i¼1

ð15Þ

Using qn(x; z) in place of fn(x; z) yields an optimization problem which is easily programmed and solved to high accuracy in a spreadsheet. However, depending on the nature of the extra constraints on x and z, it may or may not be feasible to express the solution in closed form. 5.3.1. A special case: continuous Stage 2 processing The case of an FSC2 policy whose only extra constraints are 0 6 zi 6 xi, is especially noteworthy. In this case, substituting xi
zi = xi+1/p into qn yields the result n
N þ ð1=2Þ

n X i¼1

x2i þ ð1=2pÞ

n X

x2i ¼ n
N þ ð1=2Þx21 þ ð1=2Þðp0 þ 1Þ

i¼2

n X

x2i ;

i¼2

where p 0 = 1/p. Since zi = xi
p 0 xi+1 P 0, the problem becomes the same as (9) with p > 1 replaced by p 0 < 1 and with the variables xi numbered in reverse order. Therefore, the problem in this special case has the simple optimal solution x = xq and z = zq: xq1 ¼ ð1 þ p0 ÞN =ðn þ p0 Þ ¼ ðp þ 1ÞN =ðpn þ 1Þ; xqi ¼ N =ðn þ p0 Þ ¼ pN =ðpn þ 1Þ;

i ¼ 2; . . . ; n;

zq1 ¼ pN =ðpn þ 1Þ; zqi ¼ N ðp
1Þ=ðpn þ 1Þ; i ¼ 2; . . . ; n
1:

ð16Þ

The next section restricts attention to the special case of FSC2 policies with simple extra constraints zi 6 xi. It compares the results using computed (locally optimal) solutions (x ; z ) with those obtained using (xq; zq)

838

R.G. Vickson, E. Hassini / European Journal of Operational Research 170 (2006) 824–843

in (16). It also includes the policy (xe, ze), of equal sublots and equal inserted idle times. This policy is now feasible, due to interruption of processing in Stage 1. 5.4. LIFO vs. FIFO The following result generalizes Theorem 1. Theorem 4. For any FSI1 policy the expected number of good items is larger under LIFO than under FIFO processing. Proof. Let V Ln and V Fn denote the LIFO and FIFO values of Vn. Since V L1 ðxÞ ¼ V F1 ðxÞ ¼ 1
e
x , the result is true for n = 1. Assume that V Ln
1 ðÞ P V Fn
1 ð; Þ is true for any FSI1 policy in n
1 sublots, and let (x; z) be an FSI1 policy in n sublots. The induction hypothesis implies V Fn ðx; zÞ ¼ V 1 ðx1 Þ þ ðe
x1 þ 1
e
z1 ÞV Fn
1 ðx2 ; . . . ; xn ; z2 ; . . . ; zn
1 Þ Z x1 þ e
y V Fn
1 ðx2 þ pz1
py; x3 ; . . . ; xn ; z2 ; . . . ; zn
1 Þ dy z1

6 V 1 ðx1 Þ þ ðe
x1 þ 1
e
z1 ÞV Ln
1 ðx2 ; . . . ; xn Þ þ ¼ V 1 ðx1 Þ þ V

L n
1 ðx2 ; . . . ; xn Þ

þ

Z

Z

x1

e
y V Ln
1 ðx2 þ pz1
py; x3 ; . . . ; xn Þ dy

z1 x1

e
y ½V Ln
1 ðx2 þ pz1
py; x3 ; . . . ; xn Þ
V Ln
1 ðx2 ; . . . ; xn Þ dy:

z1

Now V Ln
1 is monotonically increasing with respect to its first argument, so the integrand above is <0 if z1 < y < x1. Thus, V Fn ðx; zÞ 6 V 1 ðx1 Þ þ V Ln
1 ðx2 ; . . . ; xn Þ ¼ V Ln ðxÞ, the inequality being strict if z1 < x1. h

6. Numerical results This section compares the results for the following policies: (i) the (locally optimal) policy obtained by solving the nonlinear programming problem numerically; (ii) the approximate solution obtained from the quadratic approximation to fn; and (iii) the equal sublots solution, where applicable. This is done for both the LIFO and FIFO cases. The results display the expected proportion of good items P n ¼ Gn ðuÞ=U ¼ V n ðxÞ=N or P n ¼ Gn ðu; IÞ=U ¼ V n ðx; zÞ=N using Vn(x ) or Vn(x ; z ), Vn(xq) or Vn(xq; zq), and Vn(xe) or Vn(xe, ze), where applicable. We do not show all the exploratory findings here, but instead display the (entirely typical) results obtained when the unit processing times at the two stages are equal, or differ by 25%, and the value of N = kU is ‘‘large’’. The parameter N can be viewed as a measure of the systemÕs unreliability, in the sense that the expected quality proportion is P1 = (1
e
N)/N in the absence of lot streaming (n = 1). The illustrative value N = 4 gives P1 G 24.5%, corresponding to a highly unreliable system in which lot steaming should be highly beneficial. Furthermore, the approximate solutions are least accurate for large N, so we are displaying results that are unfavorable for the approximations. The performance of the approximations improves for smaller N values. In the LIFO case, the univariate problem is solved using the GAMS 2.25 modeling language. In the FIFO case, the nonlinear problem (6) or its FSC2 variant is solved as a nonlinearly-constrained problem using the GAMS 2.25 modeling language and the MINOS 5.4 nonlinear solver, starting from the initial feasible solution xq or (xq; zq).

R.G. Vickson, E. Hassini / European Journal of Operational Research 170 (2006) 824–843

839

For n 6 15, the software easily obtained accurate (locally optimal) solutions in the FIFO-FSC1 case. The FIFO-FSC2 analysis is more difficult. In some of our exploratory studies with large N, large p and large n, the GAMS/MINOS package failed to solve the FIFO-FSC2 problem even though it easily solved the FIFO-FSC1 version for the same inputs. This results from the fact that for large n, the fully expanded expressions for fn contain several hundred to several thousand nonlinear terms, some of which are large in magnitude and of opposite signs. This is true for both the FSC1 and FSC2 objectives, but fn is much larger and more complex in the latter case. When computed accurately, the large terms almost cancel, but this does not occur properly unless the precision is high enough. To obtain accurate single-precision evaluations of fn(x, z) for large n, N and p, we sometimes had to increase the numerical accuracy to several hundred digits during intermediate calculations. These symptoms appear to be many orders of magnitude worse in the FSC2 case than in the FSC1 case. For this reason, packages such as GAMS/MINOS or EXCEL, which work with fixed (double) precision accuracy, can fail much earlier (i.e., for smaller problems) in the FSC2 case than in the FSC1 case. Note, however, that no such failures occurred in the examples displayed below. For the FIFO case, we were initially unwilling to accept the GAMS/MINOS solutions without additional validation. To check our solutions we also solved the nonlinear program (6) or its FSC2 variant, in Maple V, by sequential quadratic programming (see, e.g., [15]). We did this using a sequence of reliable second-order Taylor expansions of fn at the successive solution points. These expansions were computed in Maple by using up to several hundred decimal digits of precision for intermediate quantities and then rounding the resulting quadratic approximations to modest (10–15 digit) accuracy. We stopped when the new solution estimate satisfied the Kuhn–Tucker conditions to within about 10
20. In all cases tested the final results for x and fn(x ) or (x ; z ) and fn(x ; z ) agreed to full single-precision accuracy with those obtained by GAMS/MINOS whenever the latter reported finding a reliable solution. For those few FIFOFSC2 problems where MINOS failed to deliver a reliable solution, the solution reports alerted us to possible problems. Table 1 shows the expected quality measures Pn in percentage terms for the LIFO-PSC1 policy with N = 4, p 6 1 and p = 1.25. Eq. (3) implies that for p 6 1, the optimal policy is to use equal sublots. For

Table 1 100Pn% values for LIFO processing n

p 6 1 PSC1 policy

p = 1.25 PSC1 policy



1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

x = xe

x

xq

24.54 43.23 55.23 63.21 68.83 72.99 76.17 78.69 80.73 82.42 83.84 85.04 86.08 86.98 87.78

24.54 43.23 55.09 62.76 67.97 71.63 74.30 76.27 77.76 78.89 79.77 80.45 80.98 81.40 81.73

24.54 43.23 55.09 62.76 67.97 71.63 74.29 76.26 77.75 78.89 79.77 80.45 80.98 81.40 81.73

N=4

840

R.G. Vickson, E. Hassini / European Journal of Operational Research 170 (2006) 824–843

p = 1.25 the approximate policy in (5) is not exact. However, the loss of optimality is so small that Pn(xq) and Pn(x ) are the same to at least three digit precision, hence their differences barely show up in Table 1. Note that Table 1 does not show results for continuous Stage-2 processing when p = 1.25. In fact, for the PSC2 policy in (12), the results for p = 1.25 are the same as for the PSC1 policy with p 6 1, so need not be displayed separately. Table 2 shows the expected quality measures Pn in percentage terms for the FIFO case, with continuous first-stage processing, N = 4, p = 0.8 and p = 1. It displays the results obtained from the computed (locally optimal) solution, the approximate solution in Eq. (10), and the equal lots solution. Table 3 displays the Pn values for the FIFO case, with both continuous first-stage or second-stage processing, for N = 4 and p = 1.25. For the FSC1 policy it shows results using the computed optimal policy and the approximate optimal policy in Eq. (11). For the FSC2 policy it shows results for the computed optimal policy, the approximate optimal policy obtained from Eq. (16), and the equal sublots policy. When the number of sublots is large, there is a gain of almost 10 percentage points in the value of Pn, due to switching from a policy of continuous first-stage to continuous second-stage processing. In Tables 2 and 3, the Pn values for the approximate solutions xq or (xq; zq) differ from those for the exact optima by less than about 1 percentage point, so for practical purposes a decision maker could use the approximate solutions and by-pass the optimization. The equal sublots solutions are also very effective, but are very slightly worse than the approximate solutions xq. Such behavior is observed in a wide variety of problems, including those with N values much larger than N = 4. For smaller values of N the approximate and equal sublots solutions are even more effective than indicated in Tables 2 and 3. Similar results are obtained for other ‘‘reasonable’’ values of p and N. For this reason, we do not hesitate to recommend use of either the approximate or equal sublots policies in typical cases. It is interesting to compare the FSC1 results for p = 0.8 in Table 2 with the FSC2 results for p = 1.25 = 1/0.8 in Table 3. In the quadratic approximation, the two objectives are equal to one another, provided that the variables are listed in reverse order in the FSC2 case. This does not hold precisely for the

Table 2 100Pn% values for FIFO processing: p = 1 and p = 0.8 n

FSC1 policy p=1 x

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15



24.54 40.89 50.06 56.24 60.87 64.53 67.53 70.05 72.19 74.03 75.64 77.06 78.32 79.45 80.47

p = 0.8 xq

xe

x

xq

xe

24.54 40.64 49.03 55.57 60.38 64.20 67.29 69.87 72.05 73.93 75.57 77.00 78.28 79.41 80.43

24.54 39.39 48.86 55.07 59.87 63.66 66.76 69.36 71.57 73.48 75.14 76.60 77.90 79.07 80.11

24.54 41.39 51.11 57.62 62.43 66.18 69.21 71.72 73.84 75.65 77.23 78.60 79.82 80.91 81.88

24.54 41.18 50.40 57.14 62.09 65.94 69.04 71.59 73.75 75.58 77.17 78.56 79.79 80.88 81.86

24.54 40.58 50.40 56.94 61.83 65.65 68.74 71.29 73.45 75.30 76.91 7 8.32 79.56 80.64 81.66

N=4

R.G. Vickson, E. Hassini / European Journal of Operational Research 170 (2006) 824–843

841

Table 3 100Pn% values for FIFO processing: p = 1.25 n

p = 1.25 FSC1 policy

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

FSC2 policy

x

xq

x

xq

xe

24.54 40.27 48.76 54.46 58.69 61.90 64.38 66.32 67.85 69.06 70.02 70.79 71.40 71.88 72.27

24.54 39.98 48.03 54.10 58.45 61.73 64.25 66.22 67.77 68.99 69.97 70.74 71.36 71.85 72.24

24.54 41.39 51.08 57.60 62.42 66.17 60.20 71.71 73.83 75.65 77.22 78.60 79.82 80.90 81.87

24.54 41.18 50.40 57.14 62.08 65.94 69.04 71.59 73.74 75.58 77.17 78.56 79.79 80.88 81.86

24.54 40.59 50.40 56.94 61.83 65.64 68.73 71.29 73.45 75.30 76.91 78.31 79.55 80.66 81.65

N=4

exact objectives, but the results for the two cases are very close to each other for the relevant values of x. Even the computed optimal solution vectors x in the two cases are numerical reversals of one another to about single precision accuracy. For this reason, the Pn values for the FSC2 policy with p = 1.25 are nearly the same as those of the FSC1 policy with p = 0.8. This is true for the optimal solutions, the approximate solutions and the equal sublots solutions. Such equality, or near equality between results for an FSC1 policy with p = p0 < 1 and an FSC2 policy with p = 1/p0 > 1 is observed to hold without exception in a wide variety of problems. This suggests that the FSC2 quality results can be estimated for p > 1 by considering a nearly-equivalent FSC1 problem with p < 1. This becomes important when attempting to examine cases with a large number of sublots and p greater than about 1.5, because of the difficulty of performing accurate evaluations of fn(x, z) for large N and p. It is much easier to deal with the nearly-equivalent FSC1 problem with small p 0 = 1/p. We are not able to verify global optimality of our FIFO solutions, because we are unable to verify convexity or generalized convexity of fn for n > 2. For n = 2, we cannot establish the convexity of the FSC1 objective f2(x1, x2), but we can verify that the univariate function g(x) = f2(x, N
x) is strictly convex on 0 6 x 6 N for any N > 0. The analysis for n = 2 does not extend to higher values of n. For n = 3, we can examine contour and surface plots of h(x1, x2) = f3(x1, x2, N
x1
x2) to at least verify that it is a quasi-convex function ([1] or [16]). However, we have no analytical proof of this property. For n > 3, we have no guarantee of global optimality for the GAMS/MINOS solution, but the solution report indicates that it is at least a strict local minimum. The tables above demonstrate significant quality improvements as a result of lot streaming. Expected quality is increasing with the number of sublots, but at a decreasing rate, so most of the benefits are obtained from a few sublots. A manager can use such results to help assess the trade-offs between the increase in quality and the possible increase in material handling cost due to a larger number of sublots. It is interesting to note that similar behavior occurs in job scheduling, where research shows that an increasing number of sublots benefits typical scheduling measures at a decreasing rate; see, e.g. [3].

842

R.G. Vickson, E. Hassini / European Journal of Operational Research 170 (2006) 824–843

7. Conclusions and extensions This paper considers an imperfect two-stage production system in which Stage 1 randomly shifts to the out-of-control state and stays in that state until its failure is detected at Stage 2. Lot streaming policies are developed to optimize expected quality for both LIFO and FIFO processing/inspection at Stage 2. The paper considers both continuous and interrupted processing in the first Stage. It tests simple approximations to optimal policies and demonstrates numerically that they lead to excellent results. This paper makes a number of assumptions which may be simplifications of reality in some cases. It assumes (i) deterministic unit processing times in each of the stages; (ii) instantaneous sublot transfer, item inspection and process re-set; (iii) the first stage produces only good items before failure and only bad items after; (iv) the second stage does not fail, and is capable of perfect discrimination between good and bad items from the first stage; (v) defective items are processed in Stage 2 at the same rate as good items; and (vi) in the FIFO case, no items known to be faulty at Stage 1 are passed to Stage 2. Some of the assumptions can be relaxed, to obtain more complex versions of the problem. For example, assumptions (ii) and (vi) can be relaxed, while still giving problems similar to, but much more complex than, the ones treated in this paper. These extensions are the subject of our continuing research. However, relaxing the other assumptions will lead to problems requiring different conceptualizations from those developed in this paper. Acknowledgments This research was supported by NSERC Grant A9304 from the Natural Sciences and Engineering Research Council of Canada. It was carried out in association with the Waterloo Management of Integrated Manufacturing Systems (WATMIMS) research group.

References [1] M. Avriel, W.E. Diewert, S. Schaible, W.T. Ziemba, Introduction to concave and generalized concave functions, in: S. Schaible, W.T. Ziemba (Eds.), Generalized Concavity in Optimization and Economics, Academic Press, New York, 1980. [2] K.R. Baker, Lot streaming in the two-machine flow shop with setup times, Annals of Operations Research 57 (1995) 1–11. [3] K.R. Baker, D. Jia, A comparative study of lot streaming procedures, Omega 21 (1993) 561–566. [4] F.C. C ¸ etinkaya, Lot streaming in a two-stage flow shop with set-up, processing and removal times, Journal of the Operational Research Society 45 (1994) 1445–1455. [5] V. Chva´tal, Linear Programming, W.H. Freeman, New York, 1983. [6] S. Dauze`re-Pe´re`s, J.-B. Lasserre, Lot streaming in job-shop scheduling, Operations Research 45 (1997) 584–595. [7] P.J. Egbelu, Unit load design and its impact on manufacturing systems performance, in: J.M.A. Tanchoco (Ed.), Material Flow Systems in Manufacturing, Chapman and Hall, London, 1994. [8] W. Feller, An Introduction to Probability Theory and its Applications, vol. 2, Wiley, New York, 1966. [9] S. Gilbert, H. Emmons, Managing a deteriorating process in a batch production environment, IIE Transactions 27 (1995) 233– 243. [10] M.P. Groover, Automation, Production Systems, and Computer-Integrated Manufacturing, second ed., Prentice-Hall, Upper Saddle River, NJ, 2001. [11] E. Hassini, Managing Deteriorating Manufacturing Processes, MASc Thesis, Department of Management Sciences, University of Waterloo, Waterloo, Ont., 1998. [12] A.A. Kalir, S.C. Sarin, Evaluation of the potential benefits of lot streaming in flow-shop systems, International Journal of Production Economics 66 (2000) 131–142. [13] H.L. Lee, M.J. Rosenblatt, Simultaneous determination of production cycle and inspection schedules in a production system, Management Science 33 (1987) 1125–1136. [14] S.D. Lee, J.M. Rung, Production lot sizing in failure prone two-stage serial systems, European Journal of Operational Research 123 (2000) 42–60.

R.G. Vickson, E. Hassini / European Journal of Operational Research 170 (2006) 824–843 [15] [16] [17] [18] [19] [20] [21] [22] [23] [24] [25] [26] [27] [28] [29] [30]

843

D.G. Luenberger, Nonlinear Programming, second ed., Addison-Wesley, Reading, MA, 1984. O. Mangasarian, Nonlinear Programming, McGraw-Hill, New York, 1969. J.O. McClain, L.J. Thomas, J.B. Mazzola, Operations Management, third ed., Prentice-Hall, Englewood Cliffs, NJ, 1992. R.K Nurani, S. Seshadri, J.G. Shanthikumar, Optimal control of a single stage production system subject to random process shifts, Operations Research 45 (1997) 713–724. E.L. Porteus, Optimal lot sizing, process quality improvement and setup cost reduction, Operations Research 43 (1986) 137–144. E.L. Porteus, The impact of inspection delay on process and inspection lot sizing, Management Science 36 (1990) 999–1007. C.N. Potts, K.R. Baker, Flow shop scheduling with lot streaming, Operations Research Letters 8 (1986) 297–303. M.J. Rosenblatt, H. Lee, Economic production cycles with imperfect production processes, IIE Transactions 18 (1986) 48–54. M.J. Rosenblatt, H. Lee, A comparative study of continuous and periodic inspection policies in deteriorating production systems, IIE Transactions 18 (1986) 2–9. S.M. Ross, Stochastic Processes, Wiley, New York, 1983. R.J. Schonberger, Japanese Manufacturing Techniques: Nine Hidden Lessons in Simplicity, The Free Press, New York, 1982. S. Shingo, A Revolution in Manufacturing: The SMED System, Productivity Press, Cambridge, MA, 1985. D. Trietsch, K.R. Baker, Basic techniques for lot streaming, Operations Research 41 (1993) 1065–1076. R.G. Vickson, B.E. Alfredsson, Two and three machine flow shop scheduling problems with equal sized transfer batches, International Journal of Production Research 30 (1992) 1551–1574. R.G. Vickson, Optimal lot streaming for multiple products in a two-machine flow shop, European Journal of Operational Research 85 (1995) 556–575. R.G. Vickson, Optimal inspection sublots for deteriorating batch production, IIE Transactions 30 (1998) 1019–1024.