Approximations with Improving Error Bounds for Makespan Minimization in Batch Manufacturing

Transcription

1 Brigham Young University BYU ScholarsArchive All Theses and Dissertations Approximations with Improving Error Bounds for Makespan Minimization in Batch Manufacturing Whitney Samuel Weyerman Brigham Young University - Provo Follow this and additional works at: Part of the Computer Sciences Commons BYU ScholarsArchive Citation Weyerman, Whitney Samuel, "Approximations with Improving Error Bounds for Makespan Minimization in Batch Manufacturing" (2008). All Theses and Dissertations This Thesis is brought to you for free and open access by BYU ScholarsArchive. It has been accepted for inclusion in All Theses and Dissertations by an authorized administrator of BYU ScholarsArchive. For more information, please contact scholarsarchive@byu.edu, ellen_amatangelo@byu.edu.

2 APPROXIMATIONS WITH IMPROVING ERROR BOUNDS FOR MAKESPAN MINIMIZATION IN BATCH MANUFACTURING by W. Samuel Weyerman A thesis submitted to the faculty of Brigham Young University in partial fulfillment of the requirements for the degree of Master of Science Department of Computer Science Brigham Young University April 2008

3

4 Copyright c 2008 W. Samuel Weyerman All Rights Reserved

5

6 BRIGHAM YOUNG UNIVERSITY GRADUATE COMMITTEE APPROVAL of a thesis submitted by W. Samuel Weyerman This thesis has been read by each member of the following graduate committee and by majority vote has been found to be satisfactory. Date Sean C. Warnick, Chair Date Jordan Cox Date Scott Woodfield

7

8 BRIGHAM YOUNG UNIVERSITY As chair of the candidate s graduate committee, I have read the thesis of W. Samuel Weyerman in its final form and have found that (1) its format, citations, and bibliographical style are consistent and acceptable and fulfill university and department style requirements; (2) its illustrative materials including figures, tables, and charts are in place; and (3) the final manuscript is satisfactory to the graduate committee and is ready for submission to the university library. Date Sean C. Warnick Chair, Graduate Committee Accepted for the Department Parris K. Egbert Graduate Coordinator Accepted for the College Thomas W. Sederberg Dean, College of Physical and Mathematical Sciences

9

10 ABSTRACT APPROXIMATIONS WITH IMPROVING ERROR BOUNDS FOR MAKESPAN MINIMIZATION IN BATCH MANUFACTURING W. Samuel Weyerman Department of Computer Science Master of Science Multipurpose batch manufacturing systems allow a suite of job types to be processed with a fixed set of machines. These types of systems are commonly found in chemical processing, as well as in computer systems and the service industry. In this thesis we consider the problem of sequencing jobs entering the manufacturing system in order to minimize makespan, or total time to complete processing of the jobs. We formulate this problem as a dynamic programming problem and illustrate the computational difficulty of solving this problem. We give a method for simulation of the system by representing each machine in the system as a finite state automata. This allows one to calculate the makespan given a manufacturing system and a sequence. Due to the complexity of the system, we offer an approximation to the problem. We show that the approximation strategy allows refinement. This progressive refinement of the approximation results in a sequence of approximations that approach the true problem. As the approximation is refined, the computational complexity of the approximated problem grows.

11 For a simplified system, we show that the approximation has bounded error. Furthermore, we show that the error bound of the approximation sequence improves as the approximation approaches the true problem. This presents a trade-off between computational complexity and accuracy of the solution. A decision maker using this sequence of approximations can quickly determine a level of approximation based on the amount of computational power available and the accuracy needed in a solution.

12 ACKNOWLEDGMENTS Several people were instrumental in the completion of this work. My advisor, Dr. Sean Warnick, spent countless hours with me working on this problem. Through the process of completing this thesis he has taught me a useful method of problem solving. He also helped me to direct my efforts and keep me on a path that allowed me to complete this work. I thank Dr. Tyler Jarvis for taking time to answer our questions and aid our understanding of the tropical algebra. Thanks also go to my committee members, Dr. Jordan Cox and Dr. Scott Woodfield, and to Dr. Jeff Humpherys for their suggestions and help in clarifying points of my thesis. The other members of the IDeA Labs were also very helpful in motivating me and giving me a fun place to work. Finally, I would like to thank my family for their support. My wife, Sharon, has been invaluable in helping me when the work was difficult and discouraging. She gave me a reason and the motivation to complete this work.

13

14 Table of Contents Acknowledgements xi List of Figures xv 1 Introduction Literature Review Max-Plus Algebra Problem Description Notation and Definitions Simplifying Assumptions Problem Formulation Thesis Statement Modeling and Simulation of the Factory 17 4 Approximation Algorithm One-step Approximation p-step Approximation Analysis Max-Plus Model Modeling the system xiii

15 5.1.2 Properties Error Bounds for Approximation Method step Approximation p-step Approximation Example Conclusions and Future Work Conclusion Future Research A Max-Plus Heaps 57 B Basic Graph Theory 59 xiv

16 List of Figures 4.1 Algorithm to determine a sequence from W Recipe to heap algorithm A Gantt chart representation All sequences with makespans Example of 1-step and 2-step approximations xv

17 xvi

18 Chapter 1 Introduction In a manufacturing environment, it is desirable to produce as large of a suite of products as possible without modifying the factory infrastructure. Multipurpose Batch Manufacturing systems model a general class of systems that allow the production of multiple products, referred to generally as job types, using a fixed infrastructure, or set of resources or machines. These systems are complex for several reasons. The batch property allows for a machine to process several jobs of a single type at a time. The flow of materials is not restricted to a pre-specified route: each job type may have a different route. A workstation, which performs a specific task when processing a job type, may consist of multiple machines. Each machine may also have a different capacity and running time depending on which job type it is currently processing. These complexities make it difficult to characterize and analyze these systems. We are interested in understanding how to optimally schedule factory resources when processing a suite of job types. This turns out to be a hard problem. Nevertheless, understanding this problem is necessary to quantify the capacity, and hence the profitability, of the manufacturing system. Exact methods involve solving large integer programs [26, 18]. Because of the complexity of these systems, these integer programs quickly grow to an intractable size. In this thesis we approach this problem by finding an approximated solution that is computationally feasible while still delivering good results. To this end, we first model this system as a dynamical system and show a simulation method based on this dynamical system. This allows for the verification of a solution. We then formulate the problem as a dynamic programming problem. Because the dynamics 1

19 of the factory are complex, solving the dynamic programming problem involves combinatoric optimization. We propose an approximation to the system that allows for a computationally tractable solution to the dynamic programming problem. We also derive a model of the simplified factory where each workstation has only one machine. This model is useful because it is easily represented in the max-plus algebra described in [15]; this allows us to analyze the system. We analyze the approximation on this simplified system to show that our approximated solution cannot be arbitrarily bad by proving bounds on the amount of error produced when approximating the model. The thesis is organized as follows. In the remainder of this chapter, we review related work and present the max-plus algebra. In chapter 2 we detail our system and formulate the dynamic programming problem. We detail a dynamical systems model which treats each machine as a finite state automaton in chapter 3; this model can be used for simulation and solution of the dynamic program. Chapter 4 details the approximation method and a method for solving the approximation using mixed integer linear programming. We then simplify the system in order to formulate it as a linear autonomous system in the max-plus algebra and analyze the approximation on the simplified system in chapter 5. Finally we conclude and offer future avenues of research in chapter Literature Review The scheduling problem has been posed for many systems of various complexity. The simplest setup and one that is studied widely is scheduling of a single machine [10, 23, 24]. Many different objectives are specified in [24] and others. These objectives cover such ideas as minimum makespan, maximum throughput, minimum (weighted) tardiness, minimum lead time, and so on. In [35, 3] an optimal 2-product cyclical schedule is determined for a single machine with setup costs. A natural extension to this problem is that of scheduling a job shop with multiple machines. The problem of scheduling several jobs on a set of machines with infinite queues is covered extensively in [24]. A method of treating manufacturing systems as continuous systems in time and controlling them using linear programming is given in [36]. 2

20 Several variants of the job shop have been studied in literature. The flowshop problem with sequence dependent setup times, which is a job shop with fixed route that requires a changing time based on the previous job and the next job, is shown to be equivalent to the traveling salesman problem in [13]. Another variant, the so-called hot ingot problem, which requires a scheduled job to move to the next machine in its route with no delay, is shown to be equivalent to a single machine with sequence dependent setup times in [25]. Flexible manufacturing systems have also received a considerable amount of attention. These manufacturing systems have the characteristic that the system can operate on more than one job type. Scheduling of a flexible manufacturing system with unbounded buffers is considered in [32]. Unbounded buffers allow the machines in the workflow to essentially be decoupled, so each machine can be analyzed individually. Scheduling gets considerably more complex when parallel machines are considered. This allows a job shop to contain several machines that have the same purpose. Thus a job may be scheduled on any one parallel machine to satisfy its processing requirement. Parallel machines may be considered as identical or differing in the amount of processing time required for a job. A group of parallel machines is referred to as a workstation. Because this environment is complex, several approximation methods and heuristics have been developed for scheduling of these systems. A comparison of approximation algorithms for scheduling of a single workstation with differing parallel machines is given in [39]. A greedy algorithm for the same setup is given in [29]. Lower bounds are computed for makespan minimization of parallel machine flow shop with multiple workstations in [38]. A more complex environment and the one we consider is that with several workstations with batching machines. Batching machines may process several jobs of a given type simultaneously. Because these systems have clear applications to the chemical processing industry, there have been many papers considering batching machines published in the chemical processing literature. The two main problems 3

21 that need to be solved in batching are lot sizing and scheduling. Lot sizing considers the decision of how many jobs to process at a given time and is discussed in [7, 9, 12]. As with the job shop, a lot of work has been done for the case where one or two batching machines are present [4, 16, 19, 8]. In [4] a variation of the single machine batch scheduling problem is shown to be NP-Hard. A branch and bound algorithm for lotsizing and scheduling of a single batch machine is given in [17]. A two-machine factory is considered in [1] where one or both machines is a batch machine. This paper considers the sequencing of jobs in the system using full batches and permutation schedules. However, they are limited to two machines and only one machine per workstation. They also simplify the problem by considering a batch machine that has a constant running time for any batch of jobs. A graphical solution to the general multipurpose batch plant is given in [31] which works well for simple examples. However, when there are machines of drastically different sizes or complex recipes, the problem grows to an intractable size. Others such as [26] and [18] use a graphical representation of a multipurpose batch plant to derive a mixed integer linear program (MILP) formulation to determine the exact answer to solve several objectives. However, since these methods are exact, they are also computationally intractable for a complex manufacturing system. Two heuristic methods of solution to the minimum makespan problem are given in [2], the better of the two reduces decision variables in the MILP by a linear factor. Although this does allow for the solution of more complex problems, it is still difficult to compute the makespan for a manufacturing system containing a workstation with a much larger capacity or longer processing time than another workstation. A stochastic integer programming problem to determine the schedule for a chemical plant is derived in [30]. This paper is concerned with determining which products to produce and which recipes to use to meet uncertain demand, the capacity of the factory for a product and recipe is given, so this paper is more concerned with deciding recipes than understanding how a scheduling choice affects the manufacturing system. A hybrid constraint logic programming and mixed integer linear programming algorithm is presented in [28] for multipurpose batch scheduling. This 4

22 approach uses a decomposition technique to solve two parts of the scheduling problem, one with CLP and the other with MILP techniques. This allows for the solution of complex systems. However, due to the decomposition and a heuristic method to solve the problem in a reasonable amount of time, the approach is not exact. The authors do not provide an analysis of the quality of the solution obtained. We present an approximation method for scheduling of multipurpose batch manufacturing systems. We show that this method can be scaled to achieve a better guarantee on the solution by using more computational power. We also show that this method has bounded error when used for manufacturing systems with single machine workstations. Much of the analysis and modeling of job shops and manufacturing systems is done using discrete event systems. Multipurpose batch manufacturing systems are modeled as Petri nets in [27, 40, 20]. An optimization procedure for Petri nets is also given in [27], however, it is exact and thus not tractable for complex systems, so they offer a tree pruning heuristic to reduce the search time. A method for representing Petri nets as heaps of pieces in the max-plus algebra is given in [11]. We give a method to directly model a class of multipurpose batch manufacturing systems as heaps of pieces. Certain discrete event processes are shown to be linear in the max-plus algebra in [6]. They note that this is useful for performance evaluation in manufacturing. We use the max-plus algebra to obtain a simpler representation for our system and use this for the analysis of our approximation algorithm. 1.2 Max-Plus Algebra We will briefly discuss the max-plus algebra. A more thorough treatment is given in [15]. The max-plus algebra is defined over R max = R. We will define 5

23 three operations for scalars: a, b R max a b = max(a, b), a b = a + b, a b = a b. The zero element is defined as ǫ =, and the unit element is defined as e = 0. Matrix arithmetic is also defined. For matrices, A, B R nl max, C R lm max we define the operations: [A B] ij = a ij b ij l [B C] ik = b ij c jk. j=1 The zero vector and the unit vector are given by ǫ = e = ǫ., ǫ e.. e The identity matrix is e ǫ... ǫ ǫ e ǫ I max = ǫ ǫ... e x(k) R n max We can now define a linear state-space system in the max-plus algebra. For, and A Rn n max, there is a linear autonomous system, x(k + 1) = A x(k). 6

24 Definition We say a max-plus autonomous system is stable if i, v R such that lim x i (k) x 1 (k) = v. k This means that a system is stable if the distance between all elements of the vector x reach a finite constant as the system is simulated. Throughout this paper we will use the convention that for any y R max, the indeterminate form y (ǫ ǫ) = y. We will also define the 1-norm in the max-plus algebra. Definition The 1-norm of a max-plus vector, b R n max is b 1max = n b i = e T b i=1 Note that this norm is the maximum element of the vector b. This norm induces a norm on a matrix. Definition The max-plus 1-induced norm of an operator A R n m max is A 1max = max x ( A x 1 max x 1max ). Theorem Given a matrix A R n m max, the max-plus 1-induced norm of A is A 1max = max a ij. ij Proof: Let A R n m max be given. Without loss of generality, we will say that x 1 max = e. Note that A x 1max = e T A x. The vector v T = e T A is the vector containing the max element of each column of A. Therefore, we want to maximize 7

25 v T x. Because x 1max = e, the largest element in x is e. To maximize v T x, we want to make each element of x as large as possible; this means we set x = e which gives v T x = max ij a ij. By this theorem, we see that the max-plus 1-induced norm of a matrix is very simple to compute. A similar result holds for min x A x 1max x 1max. Theorem Given a matrix A R n m max, min A x 1max x 1max = min[e T A] i. x i Proof: Let A R n m max be given. Without loss of generality, let x 1 = e and consider v T x with v T = e A. Now we want to minimize v T x, so we want each element of x as small as possible. However, having x 1max = e requires at least one element of x equal to e. Thus, we need only consider each e i where e ii = e and e ij = ǫ for j i. So min v T x = min(v T e i ) x i = min i (v i ) = min i [e T A] i. 8

26 Chapter 2 Problem Description 2.1 Notation and Definitions The fundamental processing unit in our manufacturing system is the machine. A machine is a resource that performs a specific job in processing various job types. Common examples include mixers, extrusion presses, air dryers, heaters, etc. Note that the resource represented by a machine has different characteristics depending on the job type it is processing. For example, when manufacturing one product, a boiler may only process 5 kgs of material for 1 hour. Nevertheless, while manufacturing another product, the same boiler may process 10 kgs for 24 hours. Thus, the availability of the resource represented by a single boiler may be very different depending on the product to which it is assigned. A manufacturing system, or factory, then, is a finite set of machines F = {M 1, M 2,..., M n }. Because a factory often has multiple machines that perform the same job, we partition this set into a set of workstations, {W 1, W 2,..., W p }, where p n. The set of workstations characterizing a given manufacturing system define the factory s functional capabilities, while the machines assigned to each workstation indicate the amount of that particular resource available at the factory. Any particular manufacturing system represents a collection of resources that are capable of producing a set of job types J = {J 1, J 2,..., J m }. Each job type is characterized by a recipe that defines a sequence of resources that are required to process the job type. Specifically, the recipe for job type i is a triple R i = {S i, B i, T i }, where S i is a sequence of o i workstations, indicating the sequence of processing steps needed to process the job type i; B i is a sequence of o i vectors, where the j th entry of the k th vector is a rational number, b, that indicates the batch size of job type 9

27 i on machine j of workstation S i (k) during processing step k of job type i; and T i is a sequence of o i vectors, where the j th entry of the k th vector is a real number, τ, indicating the amount of time machine j of workstation S i (k) would be occupied during processing step k of job type i. Thus, the processing of job type i may require a sequence of processing steps that revisits the same workstation multiple times, leading to a total number of processing steps o i that is larger than the total number of workstations at the factory. Moreover, this sequence of processing steps may skip other workstations altogether. Likewise, note that not only may the batch sizes and processing times of the same machine be different when processing different job types, but they may also change from one processing step to another in the manufacture of a single job type if the recipe recirculates to the machine multiple times. 2.2 Simplifying Assumptions We place several constraints on our system to both represent how the manufacturing system operates and to simplify the problem. The first three constraints can be seen as hard constraints, imposed by either the production process itself, or by management to satisfy some competing objectives such as safety requirements, regulatory standards, etc. The latter four impose some simplifying assumptions that facilitate our analysis and make exposition more clear. Unlike the operational constraints, however, these assumptions are not essential to problem definition nor or they critical to our results. In particular, our assumptions are: 1. A machine must be loaded to capacity before it is allowed to run. As a result, the recipes of the job types are determined such that a machine s capacity is a rational multiple of the previous machine s capacity. There can be many reasons for this kind of constraint, including that the partially full batch will not develop correctly except as a full batch, that polluting emissions become unacceptable if partial batches are processed, etc. 2. We only consider the no intermediate storage (NIS) queuing policy. Thus any machine must wait for the next machine to be available before it can unload 10

28 any processed jobs. This constraint complicates the analysis of the factory since buffers between processing stages are removed, thus tightly connecting the behavior from one machine to the next. Nevertheless, this constraint is also fundamental to various manufacturing systems. For example, a hot ingot system requires processing to occur immediately, and a waiting period or inter-processing queue would drastically affect the production process. Likewise, safety regulations may prevent any kind of stockpiling certain combustible materials between processing steps, thus forcing machines to hold their jobs until the next workstation in the processing sequence becomes available. 3. No preemption is allowed, meaning that once a batch of jobs has begun processing, it must run to completion. This is consistent with the NIS queuing policy, as any preempted material would have no storage and would have to be discarded. 4. All recipes end their processing sequence at the same workstation. This assumption is made without a loss of generality since we can always augment any recipe to include a final workstation, such as storage of the final product. 5. All machines in the same workstation are identical. This assumption simplifies notation and the data structures used to store recipe information, but it is not essential. Note in particular that some machines in the workstation may process one job type while the others work on an entirely different job type. 6. The only schedules considered are permutation schedules. Thus, once a decision has been made to manufacture a sequence of job types, resources are assigned to the processing of those job types in the same order as they were scheduled. Note that this assumption is, in many cases, restrictive since parallel machines at workstations could allow one job type to be held dormant while another passes it in the production sequence. Nevertheless, we impose this assumption in this work and leave its relaxation for future research. 11

29 7. The factory works as designed. That is to say, machines are reliable and do not break down, nor does their performance in processing products deteriorate over time. The recipes, then, will produce exactly the desired products, and no quality control is needed to tune recipes or adapt to machine failure, etc. Clearly our results can be extended to consider stochastic models of failure rates or time variation of production processes, but this is left for future work. From these assumptions, we can then develop some specialized definitions that are meaningful for discussing this particular class of production environments. In particular, given no intermediate queues and our restriction to permutation schedules, a decision to process job type i begins with loading relevant materials into the machines at the first workstation of job type i s recipe. From there, these materials will pass from workstation to workstation as defined by the recipe until job type i is processed on the final workstation. Nevertheless, since each workstation operates on a possibly different batch size of materials, and since the workstations operate only when full, it may be the case that many batches of job type i must be processed in tandem before some machine in the production sequence is filled and can begin processing. Thus, the concept of a load for each job type becomes meaningful. A load of a job type is the minimum number of jobs required to complete processing of that job type in the factory and is equal to the least common multiple of the batch sizes of the machines in a job type s route. Note that the permutation schedule assumption and the no-preemption constraint imply that loads can not be interrupted; all operational decisions of the factory boil down to scheduling a sequence of loads of various job types, which we write as U = {u(0), u(1),...}, where u(k) P = {P 1, P 2,..., P m } and means that the k th load processed by the factory will be a load of job type u(k 1). Another useful concept is the notion of job type dominance of the factory; a job type is said to be dominating the factory while the final workstation is processing its load. A job type s runtime at load or step k, r(k), is the amount of time that that load dominates the factory when processed at step k. Finally, the idle time of transition k, (k), is the idle time of the final workstation once the k 1 load of 12

30 any job type leaves the machine until the k th load enters the machine and begins dominating the factory. Moreover, under the assumption that all the machines in the same workstation are identical, we can consolidate the recipe information for the entire production set P in three [m o max ] matrices, where o max is the length of the longest production sequence over all job types. Note that this assumption implies that the vector sequences B i (k) and T i (k), where k is the processing step, can be replaced by sequences of numbers b i (k) and τ i (k), since a distinction between different machines at the same workstation is no longer meaningful. We define the i th row of the first matrix, O w, to be the workstation sequence S i, appended with zeros to match the length of the longest sequence. Likewise, let the i th row of the matrices O b and O τ be the batch sequence b i and the time sequence τ i, each appended with zeros as necessary. Thus, the collection of recipes for all job types supported by the specific manufacturing system define the factory s admissible operations O = {O w, O b, O τ }. Equipped with these definitions, we can now formulate the problem and develop its solution. 2.3 Problem Formulation This general framework sets the stage for our analysis of manufacturing systems. The focus of the analysis is on the interaction between the factory resources (machines grouped into workstations) and job types (characterized by recipes). In particular, we are interested in the production capacity of the factory, and the optimal schedule realizing this maximal throughput. The flexibility of the manufacturing system, however, to produce multiple job types suggests that throughput alone is not sufficient to meaningfully answer the capacity question. Clearly throughput may change drastically depending on which job type is being produced, so the capacity question is meaningful only with respect [ ] T, to a particular quota. Let q = q 1 q 2... q m where qi is an integer number of loads of job type i P be the desired quota of each of the m job types manufactured by the factory. The schedule to maximize throughput then becomes the same schedule to minimize the amount of time required to produce q. Note that the total number of 13

31 manufacturing loads is K = q 1, which also defines the total length of the scheduling sequence u(k), 0 k K 1. We say u is an admissible schedule if the total number of loads scheduled for job type i equals q i. Given the constraints and assumptions imposed on the manufacturing system, it is clear that a given finite production sequence u(k) will generate an output sequence in the same order. What is not clear is the completion time of this final output sequence. Let y(k) = (k)+r(k) be the work time of the final workstation associated with load k. The total completion time is then simply K 1 i=0 y(k). We observe that the factory can be thought of as a complex dynamic system mapping u(k) to y(k). The state of the system at stage k is a vector z R n, where z i (k) is the amount of time from when load k enters the first workstation in its recipe until machine i completes all processing associated with load k. The initial state of the factory, z(0), thus indicates the times when factory resources (machines) become available for processing the first load u(0). The action of a production schedule u(k) on the factory then becomes z(k + 1) = f(z(k), u(k)) y(k) = g(z(k), u(k)) (2.1) for some complex functions f and g. We thus have the problem: Problem Given a factory, a set of job types J with their associated recipes R, and a quota q, find an admissible schedule u such that min u K 1 k=0 y(k) subject to z(k + 1) = f(z(k), u(k)) (2.2) y(k) = g(z(k), u(k)). Note that the complexity of f and g make it very difficult to determine an optimal schedule u, even when it may not be terribly difficult to simulate (f, g) given a particular candidate schedule. We capitalize on this fact to develop a discrete event 14

32 realization of (f, g) in the next section. This is then followed by an approximation method that samples the simulation to characterize certain transition costs, yielding an integer program to compute a suboptimal schedule, approximating a solution to (2.2). 2.4 Thesis Statement Given a batch manufacturing system, F, and a quota, q; we will provide a sequence of approximations to (2.2) such that for n, m N, such that n > m the n-step approximation has a bounded maximum error that is less than or equal to the bounded maximum error of the m-step approximation. This sequence of approximations has the property that depending on the amount of computational power or time available, one can choose an approximation to use the available computational resources and be guaranteed a better bound on the solution obtained. 15

33 16

34 Chapter 3 Modeling and Simulation of the Factory In order to simulate the factory, we model it as a discrete event system. Initially each machine can be viewed as a finite-state automata with a set of states Θ containing three states: loading (θ l ), running (θ r ), and unloading (θ u ). These states can be defined in terms of the portion of a full batch the machine contains, l [0, 1], and the time the machine has been running, T Z. The current state, θ is defined as follows: θ = θ l when l 1 T = 0 θ r when l = 1 T < τ θ u when T τ. Assume a factory with n machines that can manufacture m different products. In order to model the factory as a dynamic system, let the state of a machine be defined by [l T π o], where l and T are defined as before, π N is the current product in the machine, and o N is the operation step of the product in the machine. Let R(t) = [r 1 (t)... r m (t)], r i (t) Z be the remaining supply, or raw materials, for each product given in number of batches of the first workstation for this product s route for each time t {0, 1, 2, }. Also, let Ψ = [ψ 1... ψ m ], ψ i Z be the amount of each product completed, given in batches of the final machine in the product s route. Allowing for workstations requires a trivial mapping from machine number to workstation number. The sequence, U, dictates how we set R. We will define k(t) N as the current step of processing of U with k(0) = 0. When the load of step k(t) 1 has finished processing, we set r uk(t) (t) to the number of batches of 17

35 the first workstation in a load of the product at step k(t), u k(t), denoted as β uk(t) and all other values of R(t) set to 0. We increment k as k(t + 1) = k(t) + 1. We will first handle the update rules of general machines, we will handle special cases next. The amount possibly loaded into a machine that is not in the first workstation of the current product s route is given by: { l + i (t + 1) = l i(t) + min 1 l i (t), l } prev(t). O b,π,prev The amount possibly unloaded from a machine that is not the last machine of the current product s route is given by: l i (t + 1) = l i(t) min {l i (t), (1 l next (t))(o b,π,next )}. If the machine is in the last workstation of the current product s route (o i = o final ), it unloads all of its product. So the load of machine i changes according to: l i (t + 1), = l + i l i (t + 1), θ (t + 1), θ i = θ l and θ prev = θ u i = θ u and θ next = θ l 0, θ i = θ u and o i = o final l(t) otherwise. When machine i is running, T is incremented at each time step. If the machine is empty, T is reset to 0. The update function for T is given by: T i (t + 1) = T i (t) + 1 θ i = θ r 0 l i = 0 T i (t) otherwise. The values for π and o are set when loading a product from machine i to machine j (this implies that machine j is not in the first workstation of the current product s 18

36 route) the update functions for π and o are: π j (t + 1) = o j (t + 1) = π i (t) θ i = θ u and l j = 0 π j (t) otherwise, o i (t) + 1 θ i = θ u and l j = 0 o j (t) otherwise. The storage, Ψ is incremented whenever a machine in the last workstation of the current route is unloaded, so { ψ i (t + 1) = ψ i (t) + 1, A machine in the first workstation of a product s route loads from R. Say the non-zero location in R(t) (at most there will be one) is a. Let the machine in the first workstation be i, then machine i is updated as follows: 1 θ i = θ l l i (t + 1) = l i (t + 1), θ i = θ u and θ next = θ l l(t), otherwise a, θ i = θ l π i (t + 1) = π i (t), otherwise o j (t + 1) = 1 R is updated as follows: r i (t + 1) = β uk(t), r i (t) 1, r i (t), R(t) = 0 and u k(t) = i θ j = θ l otherwise. 19

37 We update k(t) as: k(t) + 1 R(t) = 0 k(t + 1) = k(t) otherwise. Using this simulation we can then calculate each transition s idle time, (k). We calculate (k) as the idle time of the final workstation once the entire load of the product dictated by u(k 1) has left the machine until the product dictated by u(k) begins using the machine, or until it dominates the factory. Note that although the final workstation may be idle at various times during the production of a given load for a specified product, this idle time does not contribute to (k), which really captures the inefficiency related to load transitions. r(k) follows simply as the total amount of time that the product dictated by u(k) dominates the factory. Finally, an important issue for such general manufacturing systems is deadlock. Deadlock is discussed in [33] and [14]. Four conditions for deadlock are given in [5] and heuristic methods for avoiding and preventing deadlock are given in [34]. We implemented a method of deadlock prevention by preventing one of the conditions necessary for deadlock. To do this, we define a linear ordering of the workstations. We then only allow products to occupy workstations in an increasing order. If the recipe dictates that a product use a machine in a decreasing order, we require that all workstations of lower order be reserved, meaning that there must always be one free machine in that workstation, until the product has completed processing of the earlier stages. Although this is a conservative policy, it will prevent deadlock from occurring. 20

38 Chapter 4 Approximation Algorithm The problem in (2.2) is difficult to compute because of the complexity of representing f and g. However, because this system can be simulated, a given sequence can be tested easily. In order to obtain a solution for complex systems, we present an approximation method that can be solved using integer programming. Note that integer programming is shown to be in N P in [22]. In our approximation we reduce the number of decision variables which makes the resulting integer programming problem computationally feasible. Also, because integer programming is a rich area, there are many software packages with good algorithms to compute the solution to an integer program. We also present a sequence of approximations which allow more decision variables to be added by making the approximation closer to the actual problem. We will refer to an approximation as the p-step approximation where as p increases, the number of decision variables increases. 4.1 One-step Approximation We show the one-step approximation in detail. In order to determine a sequence we reduce the factory to a model of a single-machine manufacturing system with sequence dependent setup times. We define one-step transition cost to be the one-step approximation of the idle time of the transition plus the run time of product transitioned to. That is, to calculate the transition cost from product i to product j, we construct the sequence U = (i, j) and compute (1) + r(1): for this sequence, this is the one-step transition cost. The single-machine problem with sequence dependent setup times is known to be a combinatorial problem solved as the traveling salesman problem (TSP) as 21

39 discussed in [23]. The formulation we derive is based on the IP formulation of the TSP given in [37]. We will view scheduling as traversing a graph. If a load of product i is followed by a load of product j, it will be represented by an arc from node i to node j. The cost of transitioning from node i to node j will be given by the transition cost from product i to product j. We wish to minimize total transition cost while still producing a set amount of loads of each product. This problem differs from the TSP in that each node may be visited multiple times. We now give the derivation of the IP. Let the matrix C be the cost matrix for a directed graph representing the transition costs of every product that we desire to make where c ij is the transition cost from product i to product j. If a non-cyclical sequence is desired, this graph must contain a dummy node (0) which represents the empty factory. Because there is no product to transition to when emptying the factory, we define the transition cost from any product to the empty factory to be 0. In the case of a non-cyclical sequence, C is a [m+1 m+1] matrix. The matrix W specifies which arcs to traverse to reach quota and is the same size as C. If we let w ij represent the number of times the arc from node i to node j is traversed and c ij the cost of that traversal, the objective function for the IP problem is thus: min W m j=0 m c ij w ij. (4.1) i=0 Because we want a tour, each node must have the same number of incoming arcs as outgoing arcs. This adds the constraint: m w ij i=0 m w jl = 0; j = 0, 1,..., m. (4.2) l=0 Let q be the quota vector. We will set the quota of node 0 to be 1. The following constraint is added: m w ij = q j ; j = 0, 1,...,m. (4.3) i=0 22

40 The values of W are limited to be integer values because they are the number of times each arc is to be traversed. The full IP problem is: min W subject to m m c ij w ij j=0 i=0 m w ij i=0 l=0 m w jl = 0; j = 0, 1,...,m m w ij = q j ; i=0 j = 0, 1,...,m w ij {0, 1,...}. (4.4) However, this formulation allows for disjoint sets. Let ς be the smallest subtour or disjoint set, ς is a set containing each arc in the subtour. Since we want to find a single tour, this problem may be iteratively solved adding a constraint each iteration to break the smallest subtour, ς, of length ς length : w ij < ς length (4.5) i,j ς Once there is a single tour, the matrix W will represent a directed graph and will specify the number of times each arc is to be traversed. An algorithm to determine a sequence based on W is given in Figure p-step Approximation For the p-step approximation, we now consider the p-step transition cost. Let U p = {(u 1,...,u p ) u i J }, which is the set of all sequences of job types of length p. The p-step transition cost is defined as the cost of transitioning from a sequence, U p U p, of length p to a job type j. So we construct the sequence U = (U p, j) and compute (p) + r(p). This affects the following changes on the IP given in the previous section. 23

41 procedure Sequence(W: matrix) i 1 j 1 S array of lists Q queue while k, l such that w kl 0 do while w ii 0 do PushBack(S[j], i) w ii w ii 1 end while if w ki = 0 k then if Empty(Q) then i k such that l, w lk 0 include all self loops no more outgoing edges this is in a subtour else i Pop(Q) end if j j + 1 else if k w ki > 1 then multiple outgoing edges, save this for later Push(Q) end if PushBack(S[j], i) k l such that w li 0 w ki w ki 1 i k end if end while for k = 2 : j do group all tours that can be combined if Length(S[k]) 1 then front Front(S[k]) if l such that f ront S[l] then loc Location(S[l], f ront) Insert(S[l], loc, S[k]) S[k] empty list end if end if end for return S end procedure Figure 4.1: Algorithm to determine a sequence from W 24

42 For a non-cyclical schedule, the matrices W, C change size to [m p +1 m+1]. This changes our objective function from (4.1) to min W m m p c ij w ij. (4.6) j=0 i=0 We must also change our constraints. The largest change shows up in (4.2) since we must ensure not that each node has both an incoming arc and an outgoing arc, but that the sequences are maintained. Thus we must ensure that if a sequence U p = (u 1,...,u p ) is included in the tour, that we visit this sequence as often as we leave it. To convey this idea, we will use the notation w iup = w st, p 1 s = i + u k m k, t = u p, k=1 and w Upj = w st p s = u k m k 1, t = j. k=1 This changes the set of constraints in (4.2) to m w iup i=0 m w Upl = 0; U p U p. (4.7) l=0 The quota constraints change slightly from (4.3) to m p i=0 w ij = q j ; j = 0, 1,...,m. (4.8) 25

43 Combining these gives the full problem for the p-step approximation, min W subject to m m p c ij w ij j=0 m w iup i=0 i=0 m w Upl = 0; l=0 m p w ij = q j ; i=0 w ij {0, 1,...}. U p U p j = 0, 1,...,m (4.9) Where again we iteratively add subtour breaking constraints until a single tour exists. 26

44 Chapter 5 Analysis In this chapter we will present analysis of our system and the approximation presented in Chapter 4. In order to perform this analysis, we will impose two more simplifying assumptions on our system: each workstation will have only one machine, and each product will follow the same route. We leave it to future work to extend the analysis to the more general case. We will first derive some properties of our system by modeling the system in the max-plus algebra. Then we will use this representation to analyze the performance of our approximation. These two assumptions reduce the complexity necessary to represent a manufacturing system and a recipe. A recipe can now be represented simply by two vectors, c R n, and τ R n. We let c i be the capacity of workstation i and τ i the processing time of workstation i. 5.1 Max-Plus Model We wish to analyze this system in order to validate the approximation method. However, due to the recursive nonlinear definition of f(x(k), u(k)) we seek a different representation of this system. With our simplifying assumptions we are able to model the system using a simpler max-plus representation Modeling the system To create the model, we will consider the system as a heap model, we introduce heaps in Appendix A. We will use two types of pieces, a processing piece and a precedence piece. 27

45 Definition The matrix for the processing piece for job type j with recipe (c(j), τ(j)) at workstation i, P i (j) is given by the lower contour l(p i (j)) = [ ] ǫ e ǫ, where e is at l(p i (j)) i, and the upper contour u(p i (j)) = [ ] ǫ τ i (j) ǫ, where τ i (j) is at u(p i (j)) i. Definition The matrix for the precedence piece for job type j with recipe (c(j), τ(j)) at workstation i, R i (j) is given by the upper and lower contours u(r i (j)) = l(r i (j)) = [ ] ǫ e e ǫ, where e is at u(r i (j)) i and u(r i (j)) i+1. Therefore the time that workstation i spends processing a batch of job type j is represented as a piece occupying resource i with height τ i (j). The matrix, P i (j), is equal to I max except that [P i (j)] ii = τ i (j). Also, the precedence of workstation i over i + 1 is represented as a piece occupying resources i and i + 1 with height 0. This matrix, R i, is equal to I max except that [R i ] i,i+1 = [R i ] i+1,i = e. Using these pieces we can construct the heap created by job type j using the algorithm given in Figure 5.1. This algorithm multiplies several piece matrices together to arrive at a matrix which we refer to as A(j). Thus, the system can now be represented in the max-plus algebra as x(k + 1) = A(u(k)) x(k) y(k) = A(u(k)) x(k) x(k), (5.1) Where the norm here is the max-plus 1-norm; for the remainder of this chapter we will denote the max-plus 1-norm as x. 28

46 5.1.2 Properties To ease notation we will introduce some new symbols. Given A, we define ξ ij = a ij a i,j+1, δ i = a i+1,1 a i1. The horizontal differences in A are represented by ξ and the vertical differences are represented by δ. Matrix Structure We will show that a matrix that defines a recipe is strongly structured. This structure will be useful in showing properties of this system. Definition We will say that a matrix A is monotone if: a ij a i+1,j, i n 1, j n (5.2) a ij a i,j+1, i n, j n 1 (5.3) ξ 1i... ξ ni 0, i n, (5.4) a ij >, j i + 1, i n, j n. (5.5) The following lemmata will build to a proof that a matrix defining a recipe has the monotone property. Lemma Given B R n n max that satisfies (5.3) and (c(k), τ(k)), the matrix resulting from finitely many left multiplications of P i (k) and R i (k) for any i with B satisfies (5.3). Proof: Let B R n n max that satisfies (5.3), (c(k), τ(k)), and i n be given. After a left multiply of P i (k), (5.3) is trivially satisfied. Suppose that i < n. Consider the product A = R i (k) B. We want to show that a ij a i,j+1 and a i+1,j a i+1,j+1 for all j < n. We will consider two cases. 29

47 Suppose b ij b i+1,j. Then a ij = b ij = a i+1,j. Because B satisfies (5.3) it follows that b ij b i,j+1 and b ij b i+1,j B i+1,j+1. So a ij a i,j+1 and a i+1,j a i+1,j+1. same manner. Suppose b i+1,j b ij. We achieve the same result as the previous case in the Thus, because B satisfies (5.3) after a left multiply of an arbitrary P i or R i, after a finite number of left multiplies, the resulting matrix will satisfy (5.3). Lemma Given B R n n max that satisfies (5.4) and (c(k), τ(k)), the matrix resulting from finitely many left multiplications of P i (k) and R i (k) for any i with B satisfies (5.4). Proof: Let B R n n max that satisfies (5.4), (c(k), τ(k)), and i n be given. Left multiplying B by P i adds the same number to every element of row i. As this does not change ξ ij for any j, the resulting matrix still satisfies (5.4). Now suppose that we left multiply B by R i for some i < n. The resulting matrix, A, has rows i and i + 1 equal. We now have ξ ij (A) = a ij a i,j+1 = max(b ij, b i+1,j ) max(b i,j+1, b i+1,j+1 ) = a i+1,j a i+1,j+1 = ξ i+1,j (A). We need now show that ξ i 1,j (A) ξ ij (A) and that ξ i+1,j (A) ξ i+2,j (A). We will handle each of four cases separately. Suppose b ij b i+1,j and b i,j+1 b i+1,j+1. Then a ij a i,j+1 = b ij b i,j+1 and a i+1,j a i+1,j+1 = b ij b i,j+1 b i+1,j b i+1,j+1. 30

48 Suppose b ij b i+1,j and b i,j+1 b i+1,j+1. Then a ij a i,j+1 = b ij b i+1,j+1 b ij b i,j+1 and a i+1,j a i+1,j+1 = b ij b i+1,j+1 b i+1,j b i+1,j+1. Suppose b ij b i+1,j and b i,j+1 b i+1,j+1. But then b ij b i,j+1 b i+1,j b i+1,j+1 which violates the assumption on B, so this case is not possible. Finally, suppose b ij b i+1,j and b i,j+1 b i+1,j+1. Then a ij a i,j+1 = b i+1,j b i+1,j+1 b i,j b i+1,j and a i+1,j a i+1,j+1 = b i+1,j b i+1,j+1. We have shown that in any case, ξ ij (A) ξ ij (B) and ξ i+1,j (A) ξ i+1,j (B). For any l i and l i + 1, ξ lj (A) = ξ lj (B) for all j. Thus, ξ i 1,j (A) ξ ij (A) = ξ i+1,j (A) ξ i+2,j (A), so (5.4) is satisfied after a left multiply of R i. Because we have shown that the resulting matrix after a left multiply of arbitrary P i or arbitrary R i satisfies (5.4), it follows that (5.4) is satisfied after a finite number of left multiplies. Theorem Given (c(α), τ(α)), A(α) as constructed by the algorithm in Figure 5.1 is monotone. Proof: Let (c(α), τ(α)) be given. The algorithm for constructing A(α) begins with I max. The block of I max consisting of i 11 is trivially monotone. Thus we know by 31