An Integer Programming Based Heuristic in Printed Circuit Card - ISyE

An Integer Programming Heuristic for Component Allocation in Printed Circuit Card Assembly Systems Gail W. DePuy University of Louisville, Louisville, Kentucky Martin W.P. Savelsbergh Jane C. Ammons Leon F. McGinnis Georgia Institute of Technology, Atlanta, Georgia

Abstract Component allocation is an important element of process planning for printed circuit card assembly systems. The component allocation problem directly impacts the productivity and cost of a circuit card assembly system. Many companies have recognized the importance of component allocation and have started to develop a better decision process. Also, a few commercial software packages have been developed that provide environments to support process planning. However, optimization methods are not yet widely used. We demonstrate that component allocation is amenable to improvement using optimization methods. We present an integer programming heuristic for the component allocation problem and report on several case studies that have been conducted and that demonstrate its effectiveness. The heuristic is based on a mixed integer programming formulation of the component allocation problem that incorporates estimates of downstream process planning decisions. 1. Introduction This paper addresses the problem of allocating component types to coupled automated placement machines so as to balance and minimize the workload for a printed circuit card assembly system. The component allocation problem involves determining which component types are placed by which placement machines. These automated placement machines typically are coupled using conveyors to form an assembly line. Therefore, to avoid one machine becoming a bottleneck and slowing down the entire line of machines, a card should spend an equal amount of time at each machine. Balancing the machine workload not only reduces line cycle time, it also reduces work-in-process. The component allocation problem is difficult for a single card type, but obtaining an allocation of component types that 1

simultaneously balances and minimizes the workload for each card type in a group of cards is especially hard. The integer programming heuristic presented in this paper can be used to solve even these difficult multiple card component allocation problems. The component allocation decision is only one of several decisions that has to be made in the design of a printed circuit card assembly system. It is therefore complicated by its interaction with several other process planning decisions. The main process planning decisions that have to be made (e.g. Ammons et al., 1997), are: 1. Setup Strategy - select machine groups and card families and assign families to groups; 2. Component Allocation - decide which component types are placed by which machines; 3. Feeder Arrangement and Placement Sequencing - stage component feeders on each machine and sequence the placement operations for each machine and card type. Together, these three sets of interrelated decisions determine the cycle time for producing each card type, and the associated equipment utilization. Once component types have been allocated to machines, the feeder arrangement and placement sequencing decisions determine the cycle time for each individual placement machine. A number of studies (Ahmadi et al. 1995, Ammons et al. 1992, Ammons et al. 1993, Ball and Magazine 1988, Crama et al. 1990, Gavish and Seidmann 1987, Grotzinger 1988, Grotzinger 1992, Leipala and Nevalainen 1989, McGinnis et al. 1992) have demonstrated that optimization methods for feeder arrangement and placement sequencing have the potential to significantly reduce placement machine cycle times. Component allocation has not been studied as extensively as feeder allocation and placement sequencing, but studies have indicated potential opportunities for significant impacts (Ahmadi and Kouvelis 1994, Ammons et al. 1997, Askin et al. 1994, Ben-Arieh and Dror, 1990, Berrada and Stecke 1986, Carmon et al. 1989, Crama et al. 1990, DePuy 1995, Hillier and Brandeau 1993, Lofgren and McGinnis 1986, Zijm and Van Harten 1993) . These process planning decisions are an important contributor to the productivity and cost of electronics assembly systems. Many companies have recognized this and have started to develop a better 2

decision process. Also, a few commercial software packages have been developed that provide environments to support process planning. However, optimization methods are not yet widely used. In this paper, we report on the design and implementation of an optimization-based heuristic for the solution of component allocation problems, and on the results of several case studies that have been conducted and that demonstrate its effectiveness. The heuristic is based on a large-scale mixed integer programming formulation of the component allocation problem that incorporates estimates of downstream process planning decisions. The emphasis of this paper is on the design and implementation of the optimization-based heuristic and the computational experiments. A more elaborate discussion of the mixed integer programming model can be found in a companion paper (DePuy et al. 1997). The paper is organized as follows. In Section 2, we describe the component allocation problem in greater detail. We focus on the modeling issues related to the incorporation of lower level machine optimization considerations. A mixed 0-1 integer programming formulation of the component allocation problem is presented. In Section 3, we discuss the techniques that were used to customize a linear programming based branch-and-bound algorithm to develop an integer programming heuristic for the component allocation problem. In Section 4, we present several case studies that demonstrate the viability of our approach. Finally, in Section 5, we draw some conclusions and discuss future extensions of this research.

2. Problem Description and Model Formulation The main objective of the component allocation problem is to balance machine workload while minimizing cycle time. Therefore, accurate estimates of the time required to place components on the cards is important. Unfortunately, obtaining accurate estimates of the placement time of components is nontrivial. To understand why it is hard to obtain accurate placement time estimates we briefly discuss how a typical placement machine works. Both the movement of the feeder carriage and the card locator affect the time required to place a component. Typically, a turret type machine is comprised of a feeder carriage that moves in the X 3

direction, a card assembly locator that moves in the X and Y directions, and a pick/place device that only moves in the Z direction (see Figure 1). Both the card assembly locator which positions the card for the next placement to be made and the feeder carriage which moves to allow the next component to be retrieved must stop moving before the pick/place device can move. Therefore the time the pick/place device has to wait is usually determined by the maximum of the feeder carriage movement time and the card assembly locator movement time. This delay time, i.e., the time the pick/place device is ready and waiting for the card locator or feeder carriage to arrive at the proper location, is called latency. It should be noted that the card assembly locator and the feeder carriage commonly move simultaneously. The card locator and feeder carriage have a certain amount of time (the component placement time) to get to their proper positions without incurring latency. The distance the card locator and feeder carriage can move during the component placement time, i.e., without causing latency, is referred to as the free card distance and free feeder distance (Ahmadi et al. 1988). The “standard” placement time estimate for each component type provided by a machine's manufacturer is usually the fastest time with which a component type can be placed. The standard

FIGURE 1 HERE

4

placement times are often not realized, due to latency, which is determined by the feeder arrangement and placement sequencing decisions. Of course, feeder arrangement and placement sequencing cannot be decided without an allocation of component types to machines. Different allocations will lead to different feeder arrangements and placement sequences and, therefore, may affect the cycle time. Clearly there is a circular interaction between the component allocation and machine optimization problems (i.e. feeder arrangement and placement sequencing). The typical decomposition strategy is to do the process planning in two stages. First, solve the component allocation problem. Secondly, solve the feeder arrangement and placement sequencing problem. A unique feature of the model presented below is that it includes a component placement time estimate which incorporates aspects of the feeder assignment and placement sequencing problems within the component allocation problem. Note that our goal is not to optimize the component allocation, feeder assignment, and placement sequencing decisions simultaneously, but, by approximating latency resulting from feeder assignment and placement sequencing decisions, to obtain better solutions to the component allocation problem. As discussed above, the component placement time estimated can be affected by latency, or a delay time, caused by either the feeder carriage or card locator. To estimate the feeder carriage latency, first the total feeder movement distance is calculated. The total feeder movement distance for a card type j on a machine k is estimated by determining the largest and smallest index of a slot on machine k occupied by a component type being placed on card type j. This total feeder movement distance is adjusted by the total free feeder distance (i.e. the number of slots that can be moved without incurring latency during the standard placement time) to determine the feeder latency distance. This feeder latency distance is then used to estimate the additional time it takes, due to feeder latency, to populate a card. This additional population time will be included in the workload estimate to calculate a more accurate estimate of the actual shop floor population time. Although the majority of total latency time can be attributed to feeder latency (DePuy 1995, Crama et al. 1997), a rough estimate of card locator latency for each component type i on card type j, cmovei , j , is

5

also included in the component allocation model. The interested reader is encouraged to refer to DePuy, 1995 for a detailed discussion of an algorithm that can be used to calculate cmovei , j . The card locator latency estimates can be computed in advance of the mixed integer program and will allow an estimate of card locator latency to be included in the workload estimate. The estimates for feeder latency and card latency are incorporated in the following mixed integer programming formulation of the component allocation problem. This component allocation model also includes considerations for whether a particular component type can be placed by a particular machine (not all machines can place all component types), the number of adjacent feeder slots each component type requires on each machine (typically large component types require several adjacent slots to be staged on a machine while many smaller component types only require one slot), and the amount of standard time required to place a specific component type by each machine (typically large component types require more time to place than smaller component types).

Let i

=

index for component types

i=1, ..., n

j

=

index for card types

j=1, ..., m

k

=

index of machines

k=1, ..., p

clsk =

last slot index on machine k

u

=

index for slots

qj

=

number of card type j to be produced

u=1, ..., clsp

d i, j =

quantity of component type i used on card type j

Sk =

total number of slots on machine k

si , k =

number of slots required by component type i if assigned to machine k

t i,k =

standard time to place/insert component type i using machine k

fmove k

=

time to move one slot distance on machine k feeder carriage

freef k

=

number of slots that can be moved in the average time to place a component on machine k

cmovei , j =

card latency time for component type i on card type j 6

and let the decision variables be Yi , j, u

= quantity of component type i placed/inserted on card type j from slot u

Wi , j, u

ì 1 if component type i from card type j is assigned to slot u ï =í ï 0 otherwise î

Xi, u

ì 1 if component type i is assigned to slot u ï = í ï 0 otherwise î

dj

=

estimated assembly time for card type j

FMD j, k = feeder latency distance of card type j on machine k MXS j, k = maximum machine k slot index occupied by a component from card type j MNS j, k = used to determine the minimum machine k slot index occupied by a

component from card type j

7

OBJECTIVE m

åd j

Minimize

[1]

j =1

SUBJECT TO: æ n d j ³q j ç ç è i =1

clsk

ö

u = clsk -1 +1

ø

å å (t i,k Yi, j,u + cmovei, jWi, j,u ) + fmovek FMD j,k ÷÷

" j = 1,..., m, k = 1,..., p [2]

cls p

å Y i , j ,u = d i , j

"i = 1,..., n, j = 1,..., m [3]

u =1

Y i , j ,u £ d i , j W i , j , u

"i = 1,..., n, j = 1,..., m, u = 1,..., cls p [4]

Y i , j ,u ³ W i , j ,u

"i = 1,..., n, j = 1,..., m, u = 1,..., cls p [5]

Wi , j ,u £ X i ,u

"i = 1,..., n, j = 1,..., m, u = 1,..., cls p [6]

n

clsk

å å s i , k X i ,u £ S k

"k = 1,..., p [7]

i =1 u = clsk -1 +1 n

u + si , k -1

å å X i ,u '

'

£ s i ,k (1 - X i ,u )

"i = 1,..., n, k = 1,..., p, u = cls k -1 + 1,..., cls k [8]

i ' =1 u ' = u +1

MXS j ,k ³ uWi , j ,u

"i = 1,..., n, j = 1,..., m, k = 1,..., p, u = cls k -1 + 1,..., cls k [9]

MNS j ,k ³ ( cls k + 1 - u )Wi , j ,u

"i = 1,..., n, j = 1,..., m, k = 1,..., p, u = cls k -1 + 1,..., cls k [10]

FMD j ,k ³ MXS j ,k + MNS j ,k

éæ clsk - ( cls k + 1) - freef k êç êç u = cls +1 k -1 ëè

n

ö

ù

i =1

ø

û

å å Wi, j,u ÷÷ - 1úú " j = 1,..., m, k = 1,..., p [11]

MXS j,k ³ 0

" j = 1,..., m, k = 1,..., p [12]

MNS j ,k ³ 0

" j = 1,..., m, k = 1,..., p [13]

FMD j ,k ³ 0

" j = 1,..., m, k = 1,..., p [14]

Wi , j ,u , X i ,u Î {0,1}

"i = 1,..., n, j = 1,..., m, u = 1,..., cls p [15]

Yi , j ,u Î {0,1,2,..., d i , j }

"i = 1,..., n, j = 1,..., m, u = 1,..., cls p [16]

8

The objective function minimizes the assembly time for a group of cards. The objective function serves to reduce the bottleneck machine time for each card type and, hence, balance the workload. The assembly time (weighted by a card type's production volume, q j ) for each card type on each machine is

(

)

calculated in constraints [2] by summing the placement time t i , k Yi , j, u , card latency time

( cmovei, jWi, j,u ) , and the feeder latency time ( fmovek FMD j,k ) . As mentioned previously, the card latency time estimate may overestimate the amount of latency due to the card assembly locator, especially if a component type i is placed on card type j from more than one feeder location. A correction factor may need to be considered if many component types are anticipated being assigned to more than one feeder location. Constraints [3] ensure all placements of each component type are made. Constraints [4], [5], and [6] specify the relationship requirements among decision variables. Constraints [7] ensure that each machine's slot capacity is not violated. Constraints [8] guarantee all slots required by a component type that uses more than one slot are located adjacently on the feeder carriage. Constraints [9] and [10] are used to find the largest numbered machine k slot containing a card type j component type ( MXS j, k ) and the smallest numbered machine k slot with a card type j component type ( MNS j, k - (clsk + 1) ). These largest and smallest slot numbers on a machine are then used in constraints [11] to estimate the feeder distance moved that will incur a latency penalty (i.e. the feeder latency distance). Constraints [12], [13], and [14] ensure that all feeder distances are nonnegative. The integrality constraints are shown in [15] and [16]. As stated earlier, this model more closely represents the component allocation problem found in industry than previous models by including machine optimization considerations. This is the first component allocation mathematical model known which considers feeder arrangement issues (DePuy, 1995). Crama et al. (1997) develop a heuristic to assign components to machines based on a workload estimate which includes feeder assignment considerations. Including feeder latency in the workload

9

calculation provides realism that previous models lack. Because the above model assigns component types to specific slots, an initial solution to the feeder arrangement problem is found in addition to the allocation of component types to machines.

3. Solution Approach While developing this model has increased our understanding of the component allocation and feeder assignment problems, a mathematical model is only a valuable tool for practical problems if it can be solved. The size of the mixed integer program is huge for any realistic instance of the component allocation problem; e.g., a group of 4 card types, 140 component types, and 3 machines leads to 57,834 binary variables, 35,206 integer variables, and 287,344 constraints. No currently available commercial mathematical programming solver has been able to find even a feasible solution in a reasonable amount of time (i.e. less than 100 CPU hours) to a realistic instance. Fortunately, because of the myriad of unaccountable manufacturing complications that arise on the factory floor an optimal solution is not needed or necessarily desired by industry. An automated solution methodology is needed that finds a high quality solution in an acceptable amount of time. An 'acceptable amount of time' has to be seen in relation to the amount of time it takes to actually produce the group of cards. For example, a data set for a daily production run should not require more than one or two hours to solve. Because commercial general purpose solvers cannot even find feasible solutions for many realistic instances, another solution methodology was created to find good solutions in an acceptable amount of time. We have taken two approaches to accomplish this goal: reducing the problem size by model simplification and data aggregation, and developing a special purpose solver for the component allocation problem. The latter was accomplished by customizing a linear programming based branch-and-bound algorithm by incorporating problem specific knowledge about the component allocation problem.

10

3.1 Problem Size Reduction The approach used to reduce the size of the mixed integer program is twofold: model simplification and slot aggregation. The model can be simplified by assuming each component type requires 1 slot on each machine to which it is assigned (i.e. si , k = 1 " i , k ). With this simplification constraints [8] can be removed from the model and constraints [7] become: n

clsk

å å

X i ,u £ S k

"k = 1,..., p

i =1 u = clsk -1 +1

This model simplification could alter the accuracy of the feeder movement estimates if there is a wide variation in the number of slots each component type requires on a particular machine. However, if each component type requires approximately the same number of slots on a machine, the assumption that each component type requires 1 slot will not significantly degrade the accuracy of the feeder movement estimate. Note this simplification may require a few proportional machine characteristic changes. For example, if most component types, i, require 2 slots on machine k (i.e. si , k = 2), then simplifying the model by assuming each component type requires one slot (i.e. si , k = 1) would require the total number of slots on machine k, S k , to be reduced by half, as well as the number of slots that can be moved in the average time to place a component on machine k, freefk . In addition, the time to move one slot distance on machine k, fmovek , would need to be doubled for this example. The other approach used to reduce the size of the mixed integer program is slot aggregation. Slot aggregation models several slots as a machine section. Component types are now assigned to a specific section of the machine rather than to a specific slot. Machine sections can be as small as one slot and as large as the entire feeder carriage. If a machine section contains more than one slot, the exact slot within the section to which a component is assigned is not determined. Assigning component types to individual slots (where each machine section is made up of one slot) leads to the best estimation of feeder carriage movement since the distance the feeder carriage moves can be calculated with the most precision.

11

However, machine sections of 1 slot can dramatically increase the number of variables and size of the problem. The model must be slightly altered to accommodate slot aggregation. The index u is now used for machine sections (i.e., Yi , j,u = quantity of component type i placed on card type j from machine section u) and clsk is now used to reference the last machine section on machine k. In addition, the number of slots per machine section ( spsk ) is now included in the feeder capacity constraints. It is assumed that each machine section on a machine k is comprised of the same number of slots as other machine sections on the same machine. Constraints [7] can be written as follows to include slot aggregation. n

å

X i ,u £ sps k

"k = 1,..., p, u = cls k -1 + 1,..., cls k

i =1

In addition, constraints [11] must be altered to reflect the slot aggregation. The variables MXS j, k and MNS j, k are now used to find the maximum and minimum machine k section index occupied by a

component type from card type j. To estimate the feeder carriage distance traveled in number of slots, these section distances must be multiplied by the number of slots in each section ( spsk ). Constraints [11] can be written as follows to include slot aggregation

(

FMD j ,k ³ sps k MXS j ,k + MNS j ,k

n éæ clsk ö ù Wi , j ,u ÷ - 1ú - ( cls k + 1) - freef k êç ÷ ú êç u = cls +1 i =1 k -1 ø û ëè

)

å å

" j = 1,..., m, k = 1,..., p

As discussed above, the number of slots per machine section ( spsk ) determines the total number of variables. Machine sections of one slot are best for more accurately estimating the latency due to feeder carriage movement. However, as the number of machines and total number of slots increases, modeling one slot machine sections may not be practicable. For example, our earlier formulation with one slot per machine section generated 93,040 variables and 287,344 constraints. This problem size can be reduced to 15,550 variables and 48,124 constraints by increasing the number of slots per machine section to 6. 12

Computational experiments using several industry representative data sets (Table 1) show that the number of slots per machine section seems to have little effect on the objective value that can be obtained. For each of the data sets and each of the aggregation levels, we ran our integer programming heuristic for a limited amount of time. Then, we compared, for the different aggregation levels, how long it takes to reach solutions of comparable quality, i.e., to reach a solution that is within 5 percent of the best solution found for the lowest aggregation level. Table 2 shows the effect of various levels of slot aggregation on several sets of industry representative data. It illustrates that, within limits, slot aggregation can be used to significantly reduce the solution time without significantly distorting the quality of the solution obtained. For example, the solution time for Data Set E was reduced from 16560 seconds using 4 slots per machine section to 3595 seconds using 8 slots per machine section, a 78% reduction in solution time, while the objective value (i.e. estimate of the cycle time) was only changed by 1.4%. It should be noted that the quality of the estimate of the distance the feeder carriage moves is influenced by slot aggregation. The more slots per machine section, the less accurate the estimate of feeder movement time may be since it is not known to which slot in a machine section a component type is assigned. Consequently, the objective value (i.e. cycle time estimate) is also less accurate when a large number of slots are aggregated. If the number of slots in a machine section is larger than the number of component types assigned to the machine (for a given card type) it could be the case that all feeder latency distance information is lost. This observation suggests that the number of slots per machine section should be some value less than the number of component types assigned to that machine for a particular card type. An upper bound for the recommended number of slots per machine section can be calculated as follows min ( number of component types on card j) spsk