Publié par : Published by: Publicación de la:
Faculté des sciences de l’administration 2325, rue de la Terrasse Pavillon Palasis-Prince, Université Laval Québec (Québec) Canada G1V 0A6 Tél. Ph. Tel. : (418) 656-3644 Télec. Fax : (418) 656-7047
Édition électronique : Electronic publishing: Edición electrónica:
Aline Guimont Vice-décanat - Recherche et affaires académiques Faculté des sciences de l’administration
Disponible sur Internet : Available on Internet Disponible por Internet :
http://www5.fsa.ulaval.ca/sgc/documentsdetravail
[email protected]
DOCUMENT DE TRAVAIL 2009-015 SEQUENCING AND SCHEDULING MULTI-MOLD INJECTION MOLDING MACHINES Fayez F. BOCTOR Jacques RENAUD Jean-Emmanuel RAPP
Version originale : Original manuscript: Version original:
ISBN – 978-2-89524-341-0
Série électronique mise à jour : On-line publication updated : Seria electrónica, puesta al dia
06-2009
SEQUENCING AND SCHEDULING MULTI-MOLD INJECTION MOLDING MACHINES FAYEZ F. BOCTOR*, JACQUES RENAUD, JEAN-EMMANUEL RAPP Centre Interuniversitaire de Recherche sur les Réseaux d’Entreprises, la Logistique et le Transport (CIRRELT), Faculté des Sciences de l’administration, Université Laval, Québec, Canada G1K 7P4 *Corresponding author:
[email protected]
Abstract This paper introduces the problem of sequencing and scheduling the operations of injection machines with multiple molds. To the best our knowledge this sequencing and scheduling problem has not been the subject of any previous publication. An important feature of our Multi-Mold Injection-machine Sequencing and Scheduling (MMISS) Problem is that to perform any setup, the operations of all molds need to be stopped as they share common raw material feeders. Furthermore, several items from several product families need to be manufactured and each item requires a specific mold. Items of a same family are made from the same raw materials. We propose several heuristics to solve the problem and present a computational experiment carried out to assess the relative performance of the proposed heuristics. Key words: Machine scheduling, Sequencing, Heuristics.
1.
Introduction
In this paper we study the problem of sequencing and scheduling the operations of multimold injection machines or work stations (see Figure 1). The machine has a number of arms (processors) and each arm can hold one mold. All molds are fed by the same raw material feeders and consequently production on all molds needs to be stopped when it comes time to change the contents (raw materials) of one or more of these feeders. Each feeder may hold the same raw material or different materials of the same color or of different colors as other feeders. Another important feature of this type of machine is that all molds are continuously and simultaneously rotating or moving during operations. One-by-one, molds are positioned in front of the injector of each separate feeder to be
1
filledd with the ap ppropriate quuantities of raw r material. This impliees that even if we need to t changge only one of the moldss, we have too stop produuction in all of o them. For the t problem a number of o jobs needd to be accoomplished and a each onne consists of o produucing a num mber of item ms belonginng to a sam me product family where each item m requires a separate specific mold. m The prroblem is tw wofold; first we w need to determine d thhe produuction sequeence for proocessing thee required jobs j and thhen, within each job thhe operaations of eacch arm needss to be schedduled in ordeer to minimizze the overall make-spann. In thhis way therre are two sub problem ms to solvee: job sequeencing sub problem annd operaations schedu uling one.
Figuree 1: A sketchh of an eight--mold, 2-injeector moldinng work statiion
uge numberr of publisheed papers adddressing many m versionns of machinne In sppite of the hu schedduling probllems with different d setuup consideraations (see Pinedo 20002; Lauff annd Wernner 2004; Ho oogeveen 20005; Allahverrdi et al. 20008), to the best of our knnowledge, thhe Multii-Mold Injecction-machinne Sequencinng and Scheeduling (MM MISS) Probllem has neveer been addressed in n the open literature.
2
The contribution of this paper is twofold. First, it develops a number of heuristics to solve the problem and it also provides numerical results to assess their relative performance. The remainder of the paper is organized as follows. Section 2 describes the problem we address. Section 3 describes a construction heuristic to solve the operations scheduling sub problem and section 4 introduces a number of heuristics to solve the sequencing sub problem. Section 5 presents some numerical results to help assess the performance of the proposed heuristics and finally, section 6 provides some conclusions drawn from this work.
2.
Problem description
The problem described here was met in a shoe manufacturing plant, but very similar problems are encountered in many rubber and plastic injection plants. The considered plant uses a multi-mold, two-injector molding machine to manufacture rubber soles for different models of shoes. The soles of the shoes are made of two parts of the same or different colors. The company receives customer orders and each order has a due date, includes several shoe models and indicates the quantity required for each size of each model. For this case, production starts in April and most (90%) of orders are received before the beginning of this month with a due date of the end of September. Orders with the same or close due dates are put together and split into as many jobs as the number of associated product families. A product family is composed of different sizes of the same shoe model with the same combination of colors in the sole. Thus each job consists of a single model of shoes, has the same combination of colors, has the same or close due date and is defined by the quantity to produce of each shoe size. A mold can only be used to produce a given size of a given model whatever the sole color combination, but cannot be used to produce a different size or a different model of shoe. It is important to note that the number of possible sizes is much larger than the number of arms of the machine. This necessitates several mold changes to produce all the needed items of any particular job.
3
To solve the problem, jobs are sequenced. As the bottleneck operation is the molding operation, a production schedule is constructed for the injection molding machine and provides the starting date of each job and the dates to produce each size within each job. To pass from one job to another the machine needs to be stopped, the raw material removed from the reservoirs of the feeders, followed by a thorough cleansing and then the reservoirs need to be filled with new raw material. This is the first type of setup needed between jobs; it will be called job setup. In addition, it may be necessary to change all or some of the molds between jobs. This is a second type of setup called mold setup. Finally, during the manufacturing of a given job, we may also need to stop the machine in order to change one or more molds. This is done each time the required quantity of a given size is finished and we need to start the production of another size within the same job. Recall that the number of sizes is much larger than the number of molds that the machine can hold simultaneously. Both setup types require a significant amount of setup time. In our particular industrial case, the injection molding machine has 8 arms and can hold 8 molds simultaneously while there are 22 standard shoes sizes. Changing the raw material of one feeder requires 45 minutes, changing a mold requires 30 minutes and the machine productivity is one pair of soles per minute. There are five shoe models with approximately 12 different color combinations. There is only one copy of each mold and setup operations are done by only one setup operator. Thus, setup operations are made sequentially and the overall setup time is the sum of the duration of all setup operations that need to be performed. Finally, jobs are sequenced starting with the one with the earliest due date down to the one with the latest due date. In case of orders with the same due date, there are sequenced randomly. We will now describe the considered problem in more general terms in order to provide a description not only of the problem of our partner company but also the problem of some other injection molding plants. In the Multi-Mold Injection-machine Sequencing and Scheduling (MMISS) Problem, a set of J different jobs is to be manufactured where the demand involves up to I different items (sizes). The machine has P arms (processors) and can hold P molds simultaneously, thus at most P items of a same job can be produced
4
simultaneously. However, we can stop the operations of a given mold by closing its injection orifice without removing it from its arm. In other words, we may decide to use some of the arms and not necessarily all of them. At the beginning of the considered planning horizon, there is an initial mold, denoted mp on each arm p. The total processing time for the requested number of units of item i∈I of job j∈J is denoted tij. In order to produce a particular item, a specific mold is required and should be mounted on one of the arms of the machine. This same mold can be used later to produce the corresponding item within a different job as long as the job concerns the same product (shoe model) even if it is of a different color, a different raw material or a different due date. Consequently, in the following, items will be designated by the number of the corresponding mold. Due to the relatively high price of these molds, in many industrial cases only one copy of each mold is available. Changing a mold requires τ1 minutes and this “mold setup” time is constant and does not depend on the molds to exchange. Passing from a job j to job k requires τjk minutes to change raw materials. Notice that if we stop the machine to make only a mold setup, we can resume the production of items processed by the other molds once the machine restarts and we need to produce the remaining quantities only. Again, a very important feature of the problem studied here is that all processors must be stopped whenever any setup is performed. Moreover, as is the case in many practical settings, we assume that setups cannot be done simultaneously because they are performed by the same person. This implies that whenever two or more setups are required, they must be done sequentially. Scheduling job j requires determining for each arm the set of items i1, i2, …, to be executed (requiring processing times t i1 j ,t i2 j ,... ) and the necessary setups for each arm. The execution of a job j is finished when all the units of all its requested items are produced. Hence, the make-span associated with job j, denoted Tj, is equal to the longest make-span of the arms involved in its production. Also, the overall make-span for all jobs is: T = ∑ T j . j∈J
5
Now we can state the studied problem as follows. Given a set of jobs to be processed and their associated requested items and processing times, the objective of the MMISS problem is to sequence jobs, assign the items of each job to processors and determine their processing dates in order to minimize the overall make-span. For illustration, Figure 2 presents an intuitive solution for a problem involving three jobs (A, B and C) and up to four items to be produced on a two-processor machine. Jobs are processed according to the sequence ABC and processing times of the requested items of each job are given in Table 1. Mold setup time τ1 = 30 minutes and molds 1 and 3 are already mounted on processors 1 and 2 respectively. Notice that for a given sequence the sum of job setup times is constant and therefore job setups are not shown on this figure. Figure 2 shows an overall make-span of 315 minutes. The solution was constructed by sequentially minimizing the make-span of jobs, meaning that we minimize the make-span of job A and then that of job B and so on.
Table 1: Processing times (minutes) for the 3-job example Item Job 1 2 3 4 A 60 90 30 B 15 90 C 45 30 -
Arm 1
1A-60
mold change
4A-30
waiting
Arm 2
3A-60
waiting
3A-30
mold change
Make-span
Job A = 120 minutes
4B-90 2B-15
closed
Job B =120 minutes
mold change
waiting
3C-30 2C-45
Job C =75
Overall make-span = 315 minutes
Figure 2: Solution obtained by sequentially minimizing job make-span There are two things that are important to note. First, sequentially minimizing job makespan does not necessarily lead to minimizing the overall make-span. As is shown in
6
Figure 3, the optimal overall make-span of our illustrative example is 300 minutes. Second, it could be optimal to execute the operations of a given job without using all available arms. The molds mounted on the non-used arms are kept closed during the execution of the job. Closing these molds allows us to keep them and to use them for the execution of the subsequent job. Figure 3 illustrates this situation. Job B is executed entirely on arm 1 and the mold of arm 2 is kept closed until the end of this job.
To the best of our knowledge, no previous research dealing with this problem has been published. However, it is easy to see that this problem is NP-hard as it reduces to the standard Parallel (Unrelated) Machines Scheduling Problem (PMSP) if there is only one job and the mold setup time is zero (τ1 = 0). Minimizing the make-span for the PMSP is known to be NP-hard (see Lenstra and Rinnooy Kan, 1978; Garey and Jonhson 1978).
Arm 1
1A-60
mold change
4A-30
Arm 2
3A-60
waiting
3A-30
Make-span
mold change
4B-90 closed
Job A = 120 minutes
Job B =135 minutes
2B-15
2C-45 3C-30 Job C=45
Overall make-span = 300 minutes
Figure 3: Optimal solution of the illustrative example To solve the MMISS problem we propose a number of neighborhood search heuristics where we search the set of possible sequences and for each sequence we solve the corresponding scheduling sub problem. The next section presents the heuristic that we used to solve the operations scheduling problem for a given job sequence. Section 4 presents the heuristics developed to determine the job sequence.
3.
A heuristic for the scheduling sub problem
For a given job sequence, this heuristic constructs a solution by sequentially scheduling the J jobs one by one. To schedule the operations of a job, the heuristic performs the following steps.
7
Initialization: Step 1: Assign items requiring the molds already in place to the corresponding processors. This allows reducing the number of mold changes. Step 2: Divide the remaining items into two subsets: A1, composed of all items required for the current job but not for the subsequent one, and A2, composed of all items required for both jobs. Arrange items of each subset separately according to the descending order of their processing time. Iteration: Repeat until no better job schedule is found during S consecutive iterations where S is a parameter to be chosen by the user. Step 3: Assign items of A1 and then those of A2 one by one to processors (arms). In general, each item is assigned to the arm that will finish it at the earliest time. However, an item is assigned to the arm that finishes it at the second earliest time if: (1) this has no effect on the job make-span or the make-span increase is less than the mold setup time, and (2) the mold on the arm leading to the earliest finish time is needed for the subsequent job. Step 4: Calculate the job make-span. Randomly chose and exchange the positions of two items belonging to A1. Do the same for two items belonging to A2. Figure 5 presents the pseudo-code of the proposed heuristic. This heuristic is quite fast but as we cannot predict the number of times steps 3 and 4 will be executed, we cannot estimate its order of complexity. In order to explain the rational of the assignment rule of step 3, consider the 2-job example of Table 2. In this example, the machine has 3 arms and the molds already in place on these arms are molds 1, 4 and 3 respectively. The mold setup time is one hour.
Table 2: Processing times (hours) for the 2-job example Item Job 1 2 3 4 5 6 A 10 5 5 B 4 6 2
8
Figure 6 presents the schedule that we obtain after the first application of step 3 of the proposed heuristic. The overall make-span is 19 hours. Applying step 3, led us to not assign item 5 of job A to arm 3 although it is the arm that would finish the item in the earliest time. According to the assignment rules of step 3, we preferred to assign this item to the arm leading to the second earliest finish time in order to keep the mold in place on arm 3 until we start job B. Figure 7, shows the solution if we modify step 3 to simply assign items to the arm allowing the earliest finish time. In this case, the overall makespan is increased to 20 hours instead of 19.
4.
Job sequencing heuristics
This section describes the seven job sequencing heuristics tested. All these heuristics examine one or more job sequences and for each sequence uses the heuristic presented in section 3 to construct an operations schedule. Due date based heuristic (DDBH) According to this heuristic, jobs are sequenced from the one with earliest due date to the job with the latest one. In case of jobs sharing the same due date, jobs are sequenced in the descending order of the sum of the processing time of their items. If we still have a tie, we choose randomly. If the obtained sequence is not feasible as it does not allow to meet due dates, we move (advance) jobs where their finish time exceeds their due date to the last feasible position in the sequence. Obviously, this simple procedure does not necessarily lead to a feasible schedule; especially if due dates are very tight and no feasible solution exists. The solution given by this heuristic is considered a reference solution and we will measure the quality of the solutions obtained by other heuristics in terms of the average percentage improvement (reduction) of the obtained make-spans.
9
DO j=1 TO J ‘Step 1: DO p=1 TO P IF ݐೕ >0 THEN assign item number mp to arm p END DO ‘Step 2: N1:=0 ‘number of items in A1 DO i=1 TO I IF tij>0 AND i not assigned to an arm AND ti,jp+1=0 THEN N1=N1+1, A1=A1+{i} END DO Arrange items of A1 in the ascending order of their processing time N2:=0 ‘number of items in A2 DO i=1 TO I IF tij>0 AND i not assigned to an arm AND ti,j+1>0 THEN N2=N2+1, A2=A2+{i} END DO Arrange items of A2 in the ascending order of their processing time A=A1+A2, N=N1+N2 ‘Let ak be the number of the item in position k in A s:=0 min-make-span = large number WHILE s 0 THEN assign i to j2 ELSE assign i to j1 END DO ‘Step 4: Determine the resulting make-span Randomly chose and swap two items among the first N1 items of A (i.e., of A1) Randomly chose and swap two items among the last N2 items of A (i.e., of A2) IF make-span>= min-make-span THEN s=s+1 ELSE s:=0 min-make-span = make-span END IF END WHILE make-span of job j = min-make-span END DO Determine the overall make-span
Figure 5: Pseudo-code of the construction heuristic
10
Arm 1
Mold in place 1
Wait
1A- 5 hours
wait
1A-5 hours
wait
Arm 2
4
mc
2A-5 hours
mc
5A-5 hours
mc 6B-2hrs
Arm 3
3
Closed
Make-span
1B-4 hours 3B-6 hours
wait
Job A = 12 hours
Job B =7 hours
Overall make-span = 19 hours
Legend: mc = mold change
Figure 6: Solution given by the proposed scheduling heuristic
Arm 1
Mold in place 1
Waiting
Arm 2
4
mc Wait
Arm 3
3
Wait mc
1A-10 hours
Waiting
2A-5 hours
Closed
5A- 5 hours
Closed
Make-span Legend: mc = mold change
1B-4 hours
mc Wait 6B-2hrs Wait mc
Job A = 12 hours
3B-6 hours Job B = 8 hours
Overall make-span = 20 hours
Figure 7: Solution if items are assigned to the arms that finish them at the earliest time Similarity based heuristic (SBH) To apply this heuristic, we start by calculating a similarity index ajk for all pairs of jobs (j,k). This index equals 0 if the product family (shoes model) of job j is different from that of job k. Otherwise the similarity index ajk=2cjk+njk where cjk is the number of molds required by both jobs and njk be the number of molds not required by either jobs. We also determine, for all other jobs j, the similarity index a0j with respect to a fictitious job, numbered 0, that only requires the items corresponding to the molds initially in place on the arms. Jobs are then sequenced starting with the one with the largest index a0j. To complete the sequence, the job in position t is the one having the largest similarity index with the job in position t-1. If the resulting sequence is not feasible with respect to due dates, we move (advance) jobs whose finish time exceeds their due date to the last feasible position in the sequence. 11
A greedy neighborhood search heuristic (GNSH) This heuristic starts with the solution obtained by the SBH and looks for the best improved and feasible solution in its neighborhood (see Anderson 1996). If no better solution exists, the heuristic stops. Otherwise, the found solution becomes the current solution and we search for its best improved neighbor. The quality of the final solution depends, among other things, on the definition of the used neighborhood. Three versions of the heuristic using three different neighborhood structures were tested: (1) GNSH 1: where neighborhood is composed of solutions such that only one job moves to a different position in the sequence; (2) GNSH 2: where neighborhood is composed of solutions such that only one pair of jobs exchange their positions; and (3) GNSH 3: where neighborhood is composed of solutions such that exactly three jobs exchange positions. A multi-neighborhood search heuristic (MNSH) The multi-neighborhood search heuristic was first introduced by Boctor (1993) and uses two or more neighborhood structures. The current implementation of the MNSH uses three neighborhoods, starts with the solution obtained by the SBH and looks for the best improved solution in its first neighborhood. The found solution becomes the current solution and we again search for its best improved neighbor. If no better solution exists in the first neighborhood, the heuristic searches for the best improved solution in the second (different and/or larger) neighborhood. If a solution is found, we go back to search the first neighborhood. Otherwise we search the third neighborhood. The heuristic stops if there is no better solution in all predefined neighborhoods. The quality of the final solution depends, among others, on the definition of neighborhoods used. The three neighborhoods used in this implementation are successively: (1) solutions where only one job moves to a different position in the sequence; (2) solutions where only one pair of jobs exchange their positions; and (3) solutions where three jobs exchange positions. An adaptation of the simulated annealing algorithm (SAA) The general framework of this adaptation of the simulated annealing algorithm is presented in Figure 8. The implemented adaptation uses several reheating cycles and
12
variable cooling rates (see Boctor 1996 for more details). Within this algorithm the initial solution is obtained using the SBH presented above. Five parameters are used: hmax (the number of heating phases), T0 (the initial cooling temperature), cmax (the number of cooling cycles within each heating phase), R (the number of visited solutions for the first cooling cycle), and a (the temperature reduction coefficient). The number of visited solutions for a given cooling cycle c is set equal to c*R. To generate a neighbor solution we randomly choose a pair of jobs and permute their positions. If this permutation leads to an infeasible solution, we penalize this solution by adding the sum of the resulting tardiness to its make-span. Within our adaptation of the SA algorithm we used the following parameter values: T0=16, cmax=8, R=132 and a=0.25. The number of heating cycles hmax is chosen such that the total number of visited solutions is 30 000; 80 000 or 130 000 solutions. The best feasible visited is solution is retained as the final solution. Call SBH (find an initial solution) Call current (store the obtained solution as the current solution) Call best (store the solution as the best found so far) h:=0 (initialize the heating cycle counter) REPEAT until h=hmax h:=h+1 T:=T0 (initialize the cooling temperature) c:=1 (initialize the cooling cycle counter) REPEAT until c=cmax rmax:=R*c r:=0 (initialize visited solutions counter) REPEAT until r=rmax r:=r+1 Call neighbor (generate a neighbor solution) d:= make-span(current)-make-span(neighbor) IF d >0 or Random(0,1)< Exp(d/T) THEN Call current (store as current solution) IF make-span(current)
