European Journal of Operational Research 53 (1991) 131-148 131 North-Holland

Theory and Methodology

Multilevel capacitated lotsizing complexity and LP-based heuristics

J ohan Maes Kathofieke Universiteit Leuven, Division of Industrial Management, Leuven, Belgium

J ohn O. McC la in Cornell University, Johnson Graduate School of Management, Ithaca, N Y, USA

Luk N. Van Wassenhove * Erasmus University Rotterdam, Econometric Institute, Rotterdam, Netherlands

Received May 1989: revised December 1989

Abstract: This paper presents the first heuristics capable of solving multilevel lotsizing problems with capacity constraints on more than one level. Moreover, the form of the heuristics is quite general so that they can easily be extended to solve a variety of problems. If one wants to solve these problems on a routine basis in a real environment one needs to find fast and easy algorithms. However, we show that for certain problem classes this is a very difficult task, far more difficult than has been suggested in the literature. For problems with setup times we show that finding a feasible solution is NP-complete. Even without setup times testing for feasibility can be very difficult. Just how time consuming such heuristics must be is demonstrated. This leaves little chance to build fast and easy heuristics except for the most simple cases. Our exploration of the complexity issues points to mathematical programming as a potential source of heuristics for these problems. This paper presents a new and general approach based on rounding an LP solution for the problem without setup times. The methods use different information and patterns evident in the LP solution are explored. The approach is tested on a large set of problems. The main contributions of this paper are the way in which we distinguish between the easy and hard lotsizing problems, the LP-based heuristics and the test set of capacitated multilevel lotsizing problems.

Keywords: Production planning, linear programming, heuristics

1. Introduction

A multilevel production environment occurs when several production stages are to be planned (or scheduled) simultaneously. Choosing lot sizes in such a system with limited capacity is a complex task. The multilevel capacitated lotsizing problems most commonly dealt with in the literature are a simplification of reality and can be described as follows:

* Present address: INSEAD, Fontainebleau, France.

0377-2217/91/$03.50 ~ 1991 - Elsevier Science Publishers B.V. (North-Holland)

132 J. Maes et al. / Multilevel capacitated lotsizing

given the external demand for N items over a time horizon of T periods, find the solution which minimizes total setup and holding cost, without violating the following constraints: - backlogging of end items is not allowed, - an item can be produced when all required components are available, - there are resources with limited capacity which must be respected,

- each time an item is produced, a setup cost has to be paid and (in some cases) setup time is lost, - holding cost is calculated based on the end of period inventory.

Mathematically this can be stated as follows:

Problem CLSP

N T

min E E (s,Y~, +hili, ) i=1 t= l

s.t. Ii.1 1 ~- Xit -- l it = dit + Y'~ rijxl,, i= I , . . . ,N , t= l , . . . , T , j ES( i )

N

E(a~xi,+A~Y~,)~C, k, k=l . . . . . K, t= l . . . . . T, i=1

x,,0 , i= l , . . . ,N , t= l . . . . . T,

~ ,~(0 ,1} , i=1 . . . . . N, t= l . . . . . T,

(1)

(2)

(3)

(4) (5) (6)

where

a, k = the capacity needed on resource k to produce one unit of item i. A) = the setup time or fixed loss of resource k incurred in preparation for production of i. di, = the external demand for item i in period t. s i = the setup cost for item i. h, = the cost to keep one unit of i in inventory for one period. C, ~ = the available capacity of resource k in period t. B = big number. S(i) = the set of successors of item i (S(i) =0 if i is an end item). N = the number of items. T = the number of time periods. K = the number of resources. r,j = the number of units of item i required to produce one unit of j. x , = the amount of item i produced in period t. I , = the inventory of item i at the end of period t. Y,, = a binary setup variable indicating whether production is allowed for i in t or not.

As we will show in the following sections, additional complications make the problem much more difficult than the generic formulation suggests. On the other hand introducing constant leadtimes or transfer times when moving from level to level does not considerably change the complexity of the problem, as long as these move times remain independent of actual shop load. They may however introduce some period zero infeasibilities.

Figure 1 gives an example of such a general model and will be used to explain some definitions. In this example there are four end items (1 to 4) each with known external demands (d 1 to d4). For all components (5 to 17), the dependent demand can be calculated from the product structure and the successor's demand (e.g., 1 is the successor of 5). For component 8 there is also an additional independent demand (ds). The product structure in Figure 1 is very general. There are a number of assembly type operations, series type operations as well as item commonalities (e.g., item 12 is used by 7 as well as 8). There are three capacity constraints (A, B and C) as indicated by the boxes in the figure. The first two

J. Maes et al. / Multile~,el capacitated lotsizing 133

dl d2 d3 d4

I II III

Figure 1. Schematic problem representation

~8 "

constraints (A and B) both cover only a single stage of the product structure, while the third capacity constraint (C) contains items in different stages of production (e.g., items 12 and 17). For the sake of completeness Table 1 gives a brief review of different types of lotsizing algorithms. A more detailed review was recently published by Bahl et al. [3].

In the remainder of this paper we restrict ourselves to assembly type problems (i.e. no commonality) with external demand for the M end items only and with no capacity constraints that cover multiple levels.

In the next section we discuss how most common sense heuristics are built and what complications are involved in finding a feasible solution when additional constraints are added to the problem. We prove that finding a feasible solution is NP-complete for problems including setup times. Moreover for some other problems the feasibility problem is not trivial either, although not NP-complete. Given this dilemma,

Table 1 Different lotsizing problems and algorithms to solve them

Single level Multi level

Uncapacitated Wagner and Within * [34] Silver and Meal [30] Least Unit Cost Part Period Balancing

Capacitated Eppen and Martin * [15] Barany et al. * [4] Gelders et al. [18] Dixon and Silver [12] Lambrecht and Vanderveken [24] Dogramaci et al. [13] Karni and Roll [22] Maes and Van Wassenhove [27] Eisenhut [14] Giinther [20] Thizy and Van Wassenhove [32] Bahl and Ritzman [2]

indicates an optimal algorithm.

Afentakis et al * [1] Rosling * [29] Graves [19] Blackburn and Millen [9] Crowston and Wagner * [10] Crowston et al. [11] Love * [25] Zangwill * [37]

Billington et al. * [6] Zahorik et al. [36] Billington [5] Lambrecht and Vander Eecken [23] Blackburn and Millen [8] Steinberg and Napier [31] Williams [35]

134 J. Maes et al. / Multilevel capacitated lotsizing

we develop heuristics based on rounding LP solutions which are capable of solving a large class of different capacitated multilevel lotsizing problems. The final section of this paper is devoted to the development of a large set of problems to test the efficiency of these heuristics. Given that no other heuristics for the problem existed which could be used as a benchmark were available we opted for a set of small test problems for which the optimal solution is known.

2. Lots i z ing methods

If we want to solve complex lotsizing problems in real environments we need to use fast and simple heuristics. This is particularly true if this lotsizing procedure is only part of a larger system such as for instance MRP. For the single level capacitated lotsizing problem, heuristics have already shown to produce good results [33]. They are for most environments the only realistic approach.

2.1. Common sense heuristic

When designing heuristics for an optimization problem, one can basically distinguish between two main approaches. The first group of methods is based on optimization theory and is in one way or another a truncated or accelerated version of the true optimization algorithm. The advantages of this approach are that the method is in general quite reliable, it is easy to determine bounds on the obtained solution, etc. On the other hand, this technique requires mathematical insight and can be quite complex. Examples of such heuristics for lotsizing are, e.g., the Lagrangean heuristic developed by Thizy and Van Wassenhove [32] and the network based approach by Zahorik et al. [36].

The second way to develop heuristics is to apply a set of common sense rules to the problem. These rules can be based on insights into the problem (as is the case in most heuristics) or on randomisation as is the case in simulated annealing. The advantages of this second approach mainly come from practical observations. These heuristics are generally quite fast and fairly transparant to the user.

Let us now focus our attention on common sense heuristics for capacitated lotsizing problems. Most heuristics of this type work in very much the same way. Basically one can distinguish between three main steps: - A step aimed at reducing costs through batching into larger lotsizes (i.e. trying to save expensive setups by paying a small amount of holding cost). Actually this is the body of the heuristic. - A step to guarantee a feasible solution when the algorithm stops. This step is needed for two different purposes: (1) to make sure that a feasible solution is created at the end of the algorithm even if no moves have been suggested by the first step, and (2) one needs to preserve feasibility of a partial solution during the batching step. - An optional improvement step to perturb the solution and make additional savings based on small changes to the basic solution.

In order to build this kind of heuristic, one must be able to check quickly whether proposed batchings of demand are feasible or not. In other words the existence of a fast feasibility routine is essential to the design of these heuristics.

2.2. Complexity of heuristics

The main purpose of this section is to classify the complexity of the feasibility ensuring step for different lotsizing problems. The classification will tell us how difficult it is to design common sense heuristics for these problems. Mathematically the feasibility problem can be stated as:

Given an instance of the capacitated lotsizing problem, i.e. a demand matrix, a set of capacity constraints and product structure, does this problem have a solution?

The complexity of the capacitated lotsizing problem itself has been studied extensively [7,16]. The feasibility problem on the other hand has not, except for a few simple cases.

J, Maes et al. / Multileeel capacitated Iotsizing 135

2.2 1. Complexity determining attribute: setup times The following two lemmas permit classification of the feasibility step of different lotsizing problems

into two distinct classes. It is first shown that feasibility can be checked in polynomial time for all problems which do not include setup times. The second lemma shows that the feasibility problem for lotsizing problems which consider these setup times explicitly in the formulation is NP-complete and hence no easy method to check feasibility is available.

Lemma 1. The complexity of the feasibili O, problem for capacitated Iotsizing problems which do not include setup times is in P.

Proof. Consider the following generic lotsizing algorithm: Step 1: Set all setup variables II,,, = 1 (for all i, t). Step 2: Solve the system of inequalities given by the constraints defined by problem CLSP. Step 3: If this system has a solution, the problem is feasible and a solution is found. Otherwise no

solution exists and the problem is infeasible. Since only the feasibility problem is considered costs are not important for the final solution and setup

costs can be disregarded. Putting all Y,, to 1 does not consume capacity given the zero setup times. This yields a system of linear inequalities (Ax

136 J. Maes et aL / Multilevel capacitated lotsizing

Combination of these two lemmas yields the following theorem:

Theorem 1. The feasibility problem for capacitated lotsizing problems which do not include setup times is in P. I f setting up machines consumes limited resource, the feasibility problem is NP-complete.

Theorem 1 has important implications for the design of heuristics. If setup times are present, a simple 'common sense' algorithm cannot guarantee a feasible solution to all problem instances. This is probably the main reason why one finds very few articles on lotsizing with setup times although this problem is certainly as important as lotsizing with setup costs. In many cases setup costs are viewed as a Lagrangean substitute for setup times which allows one to develop valid schedules or an otherwise very hard problem.

2.2.2. Capacitated lotsizing - with zero setup times Although ensuring feasibility for problems without setup times is in P, this does not mean that all

different problem types in this class are equally easy. Note that the proof of Lemma 1 uses LP to find a feasible solution. Solving an LP problem may require considerable time. For a number of special cases a faster noniterative approach can be used.

A. Single level, single constraint. This is one of the easiest problems for which a closed form formula can be defined. Dixon and Silver [12] proved that feasibility can be checked using the following formula:

N t

a,dim

J. Maes et al. / Multilevel capacitated lotsizmg 137

3. LP-based heuristics

In this section, new heuristics are developed for the multilevel capacitated lotsizing problem with zero setup times. Linear programming was chosen as a basis for the methods because it inherently captures three very important elements of the problem: links across levels, links between time periods and shared capacity. Equally important, LP codes are readily available in most computer centers. Finally LP models can easily be adjusted when additional constraints apply. Unfortunately, without restricting some of the variables to be integer, setup costs cannot be correctly modeled in an LP formulation. Our approach is to try to round the obtained LP solution using insights into the problem structure.

Before the different heuristics are defined some introductory remarks may be needed to justify this approach. Referring to the literature review of the single level case, one could argue that there may be other (and faster) methods to solve these multilevel capacitated lotsizing problems. However the complex- ity of the multilevel problems prevents one from using these other approaches effectively. Consider the relaxation algorithms presented for the single level capacitated lotsizing problem (e.g., Thizy and Van Wassenhove [32]). If one applies Lagrangean relaxation to the capacity constraint, the problem decompo- ses in N single item uncapacitated lotsizing problems. These problems can be solved quite efficiently using the dynamic programming approach of Wagner and Whitin [34]. When setup variables are fixed (as in the primal part of the TVW algorithm), the problem can be reformulated as a transportation problem, and the extreme flows can be found quite efficiently. For the case of single level capacitated lotsizing problem, the primal as well as the dual problems can be solved to optimality quite fast using the special structure of the problems.

Suppose now that we want to use a similar approach for the multilevel case. When capacity constraints are relaxed in a Lagrangean fashion, they enter as production costs in the objective function. The problem then decomposes in M single (end) item, multilevel uncapacitated lotsizing problems. The objective then is to minimize a function which includes time dependent production costs. However as of yet there is no efficient algorithm to solve these types of problems. Suppose on the other hand that one relaxes the constraints which link the items across levels. In this case one obtains a number of single level capacitated problems and these are of course hard to solve.

Consequently, if one wants to obtain subproblems which can be solyed efficiently, both the capacity constraints and the multilevel constraints have to be relaxed. This is exactly the approach taken by Billington [5] to solve the problem with a single bottleneck. Consider again the primal problem and suppose the setups are specified. Even this simplified version of the original problem remains quite complex since no special structure can be found for which efficient algorithms exist. Hence if one wants to obtain primal solutions, a general LP problem has to be solved. Consequently a monolithic LP approach will probably work more efficiently than these repeated applications of LP codes with fixed setups.

3.1. Simple plant location model

A model based on the simple plant location formulation of the capacitated lotsizing problem is used. The model bears some resemblance to the one used by Rosling [29] in his algorithm for the multilevel uncapacitated lotsizing problem. This model was chosen over other (more compact) representations of the problem, because it showed the best behaviour in multilevel environments given the Lindo LP code we used.

In the mathematical formulation below we assume without loss of generality that the technological coefficients r,j are equal to one.

model (SPLS)

min N T T N T

E 52 52 E E s,r,, (8) t= l "r=l t=7 t - I " r=l

138 J. Maes et al. / Multilevel capacitated lotsizing

where

S(i)

Xi~. t Cirt

s.t. t

Y~xi~,=l , i=1 . . . . . N, t= l . . . . . T, (9) r= l

t t

Y'~xi,,>~ Y'~xs(i,,t, i=1 . . . . . N, t= l . . . . . T, (10) " r= l " r= l

N T

E Eakid,,x,,,

J. Maes et al. / Multilevel capacitated lotsizing 139

Proposition 2. A valid constraint for the problem is:

N

~ ~,,+, >~N- IOm, I -1

the cardinality of the set Qm,. Note that I Qm, with I Qm, t+ l .

(15)

includes all items with zero demand in period

A proof is given in [26].

3.2. Rounding procedures

In this section we develop a number of rounding heuristics which start from the solution to the LP relaxation of problem (SPLS). Rather than using sophisticated mathematical techniques, these heuristics try to find a solution based on the structure of the problem. Three classes of heuristics are discussed.

Class 1: Single pass algorithm The first algorithm (LPH1) works according to the following ideas: at each iteration of the algorithm

one setup variable is fixed. If the setup variable being fixed was integer in the LP solution, the algorithm simply moves to the next iteration. However, if a non-integer setup variable is fixed to one, the LP problem with this additional setup variable fixed is solved again starting from the previous solution, hence requiring in general few pivots. Using this step by step approach, at each iteration some of the inventory for item i may be shifted to the newly added setup, eventually creating new slack capacity in the periods where this inventory is removed. Indeed, LP sees the setup cost as a production cost which increases linearly as long as Y,, < 1 and drops to zero once Y,t = 1. This implies that for certain items it seems to LP that producing inventory is cheaper than adding the 'production cost' needed to raise Y~t. By forcing a setup to one, this 'pseudo production cost' immediately becomes zero and it will become cheaper to produce in period t itself rather than in any earlier period (provided that enough capacity is available) since this will eliminate the holding cost.

Note that since setup variables can only be rounded up the algorithm will never arrive at an iteration which yields an infeasible intermediate solution. Although setups are never explicitly forced to zero, some of the fractional might be eliminated during the different iterations, thus reducing the number of setups.

LPH1: Single pass heur&tic

Step O. Solve the LP relaxation. Step 1. Select a non-integer setup variable and fix it to 1. (In the implementation tested in this paper we

simply selected the largest non-integer; however one can think of many different variations some of which are tested in [26].)

Step 2. Resolve the LP. If the resulting solution is all integer STOP, else go to Step 1.

Class 2." Multiple decision algorithm The second class of algorithm (LPH2) is very much related to the previous one. However, rather than

treating each fractional setup independently, it considers sequences of fractional setups. It was observed that for many capacitated problems, the suggested fractional setups are scattered throughout the complete setup matrix. Moreover some of these fractionals come in series which sum to one in the LP solution, whereas in the optimal solution, these fractional setups are often replaced by a single setup. The following algorithm tries to fix fractional setups to integers not only by forcing them to one, but also by reducing their number, forcing some of the fractionals to zero. Note that again different strategies can be used to select the next group of fractionals.

140 J. Maes et al. / Multilevel capacitated lotsizing

This algorithm treats the different levels starting from the most constrained level (defined as the level with the highest ratio of total demand to the total available capacity) and ties are broken arbitrarily. On each level the items are treated in order of nonincreasing setup cost s;. As long as the setup matrix is not completely integer the different steps of the algorithm are repeated.

LPH2: Fix chains of setups Assume levels have been reordered such that level 1 is the most constrained level and items are

reordered on each level in decreasing order of their setup costs. LP denotes the LP relaxation of the problem.

Solve LP. Set level = 1, item i = 1. Find Q = {~j l0 < Yq < 1, y '~2j~/= 1, Jl and .]'2 as small as possible}. If IQ[ = 0 then go to

Step O. Step 1.

Step 4. Step 2.

fractional Step 3.

or if

Put Y,7 = 1 where Y/7 = max( Y/j I Y,j ~ Q }- If I Q I = 2 and J2 =Jl + 1 also put the second Y,j variable = 0. Solve LP and go to Step 3. Else solve LP and go to Step 1. If the LP solution is infeasible or if

Y' E [g.tlaftr> E E [Yn,] befre n=l . . . . . i t= l . . . . . j n=l . . . . . i t= l . . . . . j

s ; * (2 - ybefre-tj, - y before]ij2 ] < Lpaf ter _ Lpbefore ,

then delete the most recently added constraint which forced an Y~j to zero and resolve LP. Goto Step 1. Step 4. Find j lY, j ~ {0, 1} and j as small as possible: if Yq ~< 0.5 then put Y,j = 0, solve LP and goto

Step 5; if ~j > 0.5 then put Y,j = 1, solve LP and goto Step 1. If no such j is found then i = i + 1, if i > N then level = level + 1 and i = 1. If level > L STOP. Else goto Step 1.

Step 5. If the LP solution is infeasible or if

or if

E E . r 1after /rntl >~ y" y" [Ynt] befre n=l . . . . . i t= l . . . . . j n=l . . . . . i t= l . . . . . j

S i * (1 - - ~ j ) < LP after - LP befre.

Replace the most recently added constraint which forced an ~j to zero with ~j Step 1.

= 1 and resolve LP. Goto

Step 1 searches for chains of Yq which sum up to 1. If two consecutive fractional ~j are found the smallest is forced to 0 and the largest to 1 in Step 2. Otherwise only the largest ~j in the chain is forced to 1, leaving the others free. If no such chains were found, Step 4 searches for the first free setup variable for the considered item and forces it to 1 or 0 depending on its fractional value being above or below 0.5. In cases where some setup variables were fixed to 0, some additional checking is done in Steps 3 and 5. These steps check whether feasibility remains guaranteed, whether the new rounded solution is cheaper than before and whether it would not have been cheaper if this variable had also been forced to 1.

Class 3: Curtailed branch and bound Any optimality seeking algorithm will probably take too much computation time to find an optimal

solution and prove its optimality. We therefore develop a faster way to limit the search among the candidate solutions, but at the expense of losing the guarantee of finding an optimal solution. Although many clever branch and bound algorithms could be thought of we present a very simple and straightfor-

J. Maes et al. / Multilevel capacitated lotsizing 141

ward one here. In our implementation a simple backtracking algorithm with a last in, first out strategy is used which fixes setup variables in order of increasing product number and period over all levels.

Algorithm PBB: Partial branch and bound

Step O. Solve the LP relaxation. Step 1. Fix all integer setup variables in this solution to their respective values. Step 2. Do a limited branch and bound on the remaining setup variables.

All three methods along with a model builder were integrated into the 'USER' subroutine of LINDO and can be obtained from the authors upon request.

4. Computational performance

In this section we will test our heuristics on a number of problems. Since until now, no other heuristics or optimal algorithms have been developed for these types of problems, we opt for rather small problem sizes. This allows us to compare the performance of these heuristics to optimal solutions. In a companion paper we compare these LP based heuristics to common sense heuristics for some restricted problems [28]. The set of test problems considers only serial product structures.

4.1. Experimental design

In order to allow for an absolute comparison rather small problems were generated (all with three end items and 10 time periods) since this allowed us to solve the problem to optimality using the MIP code of LINDO.

Five different parameters were included in the experimental design. The number of levels ranged from one to three with a capacity constraint at each level. Cost structures for all items (i.e. end items, subassemblies and components) were chosen to reflect either low (L) or high (H) TBO values, where TBO is defined as the average time between orders according to the classical EOQ lotsize formula. At each level all possible cost structures were combined with all combinations at the other levels. Hence two different combinations were generated for single level problems (L and H), 4 for two level problems (LL, HH, LH, HL) and 8 for three level systems (LLL, LLH, LHL ... . ). For each of these combined cost profiles, 3 replications were taken. Hence there are 3 ,2L sets of cost data depending on the number of levels L. Capacity absorption was either the same for all items (value 1; i.e. uniform processors) or randomly selected (i.e. random processors). Capacity tightness as measured by total demand over total available capacity is given four values, 95%, 75%, 50% and 1% or uncapacitated. For two level systems the available

Table 2 Summary of experimental design

No. of levels Uniform processors Random processors

1 level 6 cost sets 6 cost sets 4 capacity profiles 4 capacity profiles PROB301 PROB301M

2 levels 12 cost sets 12 cost sets 16 capacity profiles 16 capacity profiles PROB302 PROB302M

3 levels 24 cost sets XXXXXXXXXXXXX 14 capacity profiles PROB303

142

Table 3 Average CPU in seconds on VAX 11/785

J. Maes et al. / Multilevel capacitated lotsizing

Problem LPH1 LPH2 PBB IP

PROB301 2.8 2.5 9.7 18.4 PROB301M 4.7 5.0 51.0 214.8

PROB302 17.4 20.5 138.4 441.9 PROB302M 28.3 38.3 2603.7 6677.3

PROB303 45.2 55.9 1011.5 2935.5

capacity at level 1 compared to level 2 is either equal (11), has the bottleneck at the end items ( / \ ) or the bottleneck at the components ( \ / ) . For the three level problems only hourglass profiles were tested, i.e. with the bottleneck located at the middle level. Table 2 summarizes the experimental design. For three level systems, the case of random processors was omitted due to computer time limitations. A more detailed description is given in the appendix.

4.2. Discussion

4.2.1. Computational requirements All problems were solved on a VAX 11/785 using the four algorithms described earlier. Table 3 gives

average CPU times in seconds for all algorithms. A number of important remarks can be made. For the LP oriented heuristics the large difference in

CPU time between uniform and random processors can be explained by the width of the integrality gap between the LP solution and the optimal solution. Whereas for uniform processors this gap is on average 2.28% and less than 5% for the most difficult problems, these values grow to 4.67% and 18% for random processors. As a consequence there will be more noninteger values in the latter case hence requiring more iterations of the algorithm. Note also that even for these small problems CPU times become excessively large for PBB and the optimal solution method as the number of levels grows.

4.2.2. Solution quality We next investigate the solution quality of the different algorithms as a function of the number of levels

and the capacity absorption coefficient. These two parameters were selected because of their specific influence on the performance for multilevel problems.

>" 3 I - - ...I <

I-- 13_ 0 2

0 rr LL Z 1 o I--

> l.iJ

o LPH1

~1~ SINGLE LEVEL

TWO LEVELS

~ THREE LEVELS

LPH2 PBB

HEURISTIC

Figure 2. Solution quality of heuristics - Influence of the number of levels

J. Maes et al. / Multilevel capacitated lotsizing 143

>- F- -q <

O_ o

o 13Z I.I.

Z o

<

C3

4

3 //~>5/ ~'

o

LPHl-single level

I SINGLE LEVEL, UNIFORM PROCESSOR

~ WO LEVELS, UNIFORM PROCESSOR

SINGLE LEVEL, RANDOM PROCESSOR

~//~.' TWO LEVELS, RANDOM PROCESSOR

LPH2-single level PBB-single tevef

LPH1 two Pevels LPH2-two levels PBB-twe levers

HEURIST IC

Figure 3. Solution quality of heuristics - Influence of the processor type

Figure 2 shows the influence of the number of levels on the quality of the solutions obtained for uniform processors. Figure 3 on the other hand shows the effect of uniform and random processors. Again averages are taken over all problems in each dataset.

PBB is in both cases the best algorithm, but very large CPU times were needed to obtain these solutions. Although almost 1% worse on average, method LPH2 also looks very promising. It shows a very interesting behaviour since the performance is hardly influenced by the problem structure as reflected by capacity absorption coefficient and by the number of levels. It is very robust in this perspective. It is not surprising that LPH2 does worse than PBB, since it only searches a very limited branch and bound tree which is characterized by a one pass down with only a very limited number of backtracking passes (i.e. in Steps 3 or 5 of LPH2).

Compared to the LPH2 algorithm, the related approach LPH1 behaves poorly although its behaviour is also quite stable. More detailed analysis in [26] shows that in general LPH1 works fine for problems with rather loose capacity constraints. Indeed in this case the LP solution will be almost all integer. Fixing the fractional variables will make the entire solution near optimal. When capacity constraints are tight on the other hand, this approach does not really work. In this case LPH2 shows far better results. Here a lot of fractionals will be found and hence merely fixing them to one will make the solution much too expensive. Apparently the more intricate pattern search for chains of setups is quite effective in this case. Furthermore, these LP heuristics are virtually not influenced by the cost structure of the items, neither by the capacity profile.

5. Conclusions

This paper discussed two main topics related to the capacitated lotsizing problem. The first part of the paper discussed complexity issues for realistic lotsizing problems. We proved that the main complexity factor for the design of heuristics is the occurrence of setup times. More specifically, if setup time consumes part of the limited capacity, finding a feasible solution is NP-complete. Consequently designing simple heuristics for this problem is very difficult, unless one allows the heuristic to stop without a solution.

Checking feasibility for problems without setup times on the other hand, can be done in polynomial time. However, as shown in Section 2, constructing a feasible solution can be quite intricate. For certain problem classes (i.e. those which are most realistic: multilevel, multiple capacity constraints, assembly type

144 J. Maes et al. / Multilevel cupacitated lotsizing

of problem .. . . ) an iterative procedure may be needed for this purpose. Therefore, even for the so called easy problems, simple heuristics may in fact become quite intricate and time consuming.

Based on these conclusions one might argue that one of the few alternatives remaining to solve these problems is mathematical programming. In the second part of this paper we develop some heuristics based on an LP formulation of the problem. The heuristics described in Section 3 try to curtail the enumeration process, using information from the problem structure and LP relaxation of the model. Tests on small problems show that these heuristics perform rather well under various circumstances.

Finally, we conclude that these heuristics are the first of their kind to solve multilevel lotsizing problems with capacity constraints at multiple levels. The approach is very general in that a wide variety of different lotsizing models can easily be solved by the same heuristics. Moreover the approach can be easily extended to include additional constraints (e.g. aggregate inventory level).

Since up to now only small test problems have been solved some further research remains to be done. First, the heuristics can be tested on larger problems taken from practical applications. The heuristics may be improved by looking for other structural information or patterns in the LP solution. Finally the complexity issue can be explored in more depth, trying to define more distinct classes such that it becomes clear which specific lotsizing problems remain good candidates for heuristic development and which problems should be solved based on mathematical programming based algorithms.

Append ix

Experimental design

The problems have the following characteristics: - there are 3 end times each of which have a serial structure of L levels, - each level is capacitated, - demand is known for all end items over a given horizon of 10 periods, - components do not have any outside demand.

The parameters which vary from dataset to dataset are: number of levels, cost structure, capacity absorption coefficient and problem density, defined by total demand for capacity over total available capacity. For each specific instance which can be created using these four parameters three replications were considered by defining three different cost sets for each problem.

Demand set

Table A.1 presents the demand in units for the three end items. Demand for each item was randomly generated with a mean of 100. A different demand variability was chosen for each item.

Cost sets

Table A.2 presents 6 different setup cost sets. The first three sets in the table are data for low TBO problems, while the last three cost sets result in a higher TBO. Note that since the systems under study are serial and consequently have the same number of items on each level of the product structure, these cost

Table A.1 Demand set: 3 items - 10 periods

Period 1 2 3 4 5 6 7 8 9 10

item l 110 120 89 80 125 93 92 88 92 109 item2 78 119 81 120 115 90 107 85 124 100 item3 25 8 129 237 105 139 0 155 262 9

J. Maes et al. / Multilevel capacitated Iotsizing

Table A.2 Cost sets for 3 item problems. Echelon holding cost equal 1 for all items

145

Set1 L1 L2 L3 HI H2 H3

item 1 52 92 78 160 220 205 item 2 88 83 53 230 280 210 item 3 76 105 90 310 190 290

Table A.3(a) Capacities for single level problems

Prob. No. Capacity

1 0.95 (T) 2 O.75 (M) 3 0.50 (L) 4 0.01 (U)

Table A.3(b) Capacity profiles for two level problems

Prob. No. Profile Capacity level 1 Capacity level 2

1 II 0.95 (T) 0.95 (T) 2 11 0.75 (M) 0.75 (M) 3 II 0.50 (L) 0.50 (L) 4 H 0.01 (u) 0.01 (u) 5 / \ 0.95 (T) 0.75 (M) 6 / \ 0.95 (T) 0.50 (L) 7 / \ 0.95 (Y) 0.01 (U) 8 / \ 0.75 (M) 0.50 (L) 9 / \ 0.75 (M) 0.01 (U)

1o / \ 0.50 (L) 0.01 (U) 11 \ / 0.75 (M) 0.95 (T) 12 \ / 0.50 (L) 0.95 (Y) 13 X/ 0.01 (U) 0.95 (Y) 14 \ / 0.50 (L} 0.75 (M) 15 \ / 0.01 (U) 0.75 (M) 16 \ / 0.01 (U) 0.50 (L)

sets can be used at any level. The table gives the setup cost to be used, while it is assumed that the echelon holding cost for all items is set equal to 1 at each level. This results in TBOs from 1.02 to 1.50 for low cost values and from 1.8 to 2.5 for high values.

Capacities

Tables A.3(a), A.3(b) and A.3(c) give the capacity profiles used for single, two and three level problems respectively. For two level problems a symbolic representation for the relative availability of capacity for the first and the second level is also given in the table. For three level problems, all generated cases have an hourglass profile, with the most constrained level in the middle. Table A.3(d) indicates how the actual capacity in each period can be calculated using the information in the tables.

For two level problems three possibilities for the relative capacity availability of level 1 over level 2 were included (i.e. equal II, bottleneck at end level / \ and bottleneck at component level \ / ) . For three level

146

Table A.3(c) Capacity profiles for three level problems

J. Maes et al. / Multilevel capacitated lotsizing

Prob. No. Capacity level 1 Capacity level 2 Capacity level 3

1 0.01 (U) 0.50 (L) 0.01 (U) 2 0.01 (U) 0.75 (M) 0.01 (U) 3 0.01 (U) 0.75 (M) 0.50 (L) 4 0.50 (t ) 0.75 (M) 0.01 (U) 5 0.50 (L) 0.75 (M) 0.50 (L) 6 0.01 (U) 0.95 (T) 0.01 (U) 7 0.01 (U) 0.95 (T) 0.50 (L) 8 0.01 (U) 0.95 (T) 0.75 (M) 9 0.50 (L) 0.95 (T) 0.01 (U)

10 0.50 (L) 0.95 (T) 0.50 (L) 11 0.50 (L) 0.95 (T) 0.75 (M) 12 0.75 (M) 0.95 (T) 0.01 (U) 13 0.75 (M) 0.95 (T) 0.50 (L) 14 0.75 (M) 0.95 (T) 0.75 (M)

Table A.3(d) Calculation of actual capacity at each level

The value for the actual capacity used in the experiments was calculated using the following FORTRAN formula: capacity = AINT (total demand/(FLOAT(No, periods)* fraction) + 0.5), where capacity is the capacity in each period used in the experiment. total demand is the demand over all periods and all items expressed in capacity units. No. periods is the number of periods in the problem. fraction is the value taken from tables A.3(a), (b) or (c).

problems on the other hand only an hourglass profile was used since all other situations are extensions to two level problems.

Capacity absorption coefficient

Table A.4 gives the absorption coefficients used. There are only two different sets, the first one (U) with identical coefficients for each item on each level and a second set with random capacity absorption coefficients (R), such that the items have different capacity needs on each level. Due to the complexity of the problem and limitations in computation times, three level problems with mixed capacity absorption

Table A.4 Capacity absorption coefficients

Set I M

item 1 at level 1 1 1 item 2 at level 1 1 2 item 3 at level 1 1 3

item 1 at level 2 1 2 item 2 at level 2 1 3 item 3 at level 2 1 1

item 1 at level 3 1 X item 2 at level 3 1 X item 3 at level 3 1 X

J. Maes et al. / Multilevel capacitated Iotsizing 147

coefficients were excluded from the tests, since these require large amounts of CPU times with their 90 integer variables.

References

[1] Afentakis, P., Gavish, B., and Karmarkar, U., "Computationally efficient optimal solutions to the lotsizing problem in multistage assembly systems", Management Science 30/2 (1984) 222-239.

[2] Bahl, H.C., and Ritzman, L.P., "A cyclical scheduling heuristic for lotsizing with capacity constraints", International Journal of Production Research 22/5 (1984) 791-800.

[3] Bahl, H.C., Ritzman, E.P., and Gupta, J.N.D. "Determining lot sizes and resource requirements: A review", Operations Research 35/3 (1987) 329-345.

[4] Barany, I., Roy, T.J. van, and Wolsey, L.A., "Strong formulations for multi item capacitated lotsizing", Management Science 30/10 (1984) 1255-1261.

[5] Billington, P.J., "Multilevel lotsizing with a bottleneck work center", Unpublished Ph,D. Thesis, Graduate School of Manage- ment, Cornell University, May 1983.

[6] Billington, P.J., McClain, J.O., and Thomas, L.J., "Mathematical programming approaches to capacity-constrained MRP systems: Review, formulation and problem reduction", Management Science 29/10 (1983) 1126-1141.

[7] Bitran, G.R., and Matsuo, H. "The multi item capacitated lot size problem: Error bounds on Manne's Formulation", Management Science 32/3 (1986) 350-359.

[8] Blackburn. J.D., and Millen, R,A., "Simultaneous lotsizing and capacity planning in multistage assembly processes", European Journal of Operational Research 16 (1984) 84-93.

[9] Blackburn, J.D., and Millen, R.A., "Improved heuristics for multistage requirements planning systems", Management Science 28/1 (1982) 44-56.

[10] Crowston, WB,, and Wagner, M.H., "Dynamic lot size models for multistage assembly systems", Management Science 20/1 (1973) 14-21.

[11] Crowston, W.B., Wagner, M.H., and Henshaw, A., "'A comparison of exact and heuristic routines for lot size determination in multistage assembly systems", AHE Transactions 4/4 (1972) 313-317.

[12] Dixon, P.S. and Silver, E.A., "A heuristic solution procedure for the multi item, single level, limited capacity, lotsizing problem", Journal of Operations Management 2/1 (1981) 23-39.

[13] Dogramaci, A., Panayiotopoulos, J.C., and Adam, N.R., "The dynamic lotsizing problem for multiple items under limited capacity", AIIE Transactions 13/4 (1981) 294-303.

[14] Eisenhut, P.S., "A dynamic lotsizing algorithm with capacity constraints", AI1E Transactions 7/2 (1975) 170-176. [15] Eppen, G.D., and Martin, R.K., "Solving multi item capacitated lotsizing problems using variable redefinition", Working Paper,

Graduate School of Business, University of Chicago, May 1985, 38 pp. [16] Florian, M., Lenstra, J.K., and Rinnooy Kan, A.H.G., "Deterministic production planning: Algorithms and complexity",

Management Science 26/7 (1980) 122 20. [17] Garey, M.R., and Johnson, D.S., Computers and lntractibilio,: A Guide to the Theoo' of NP Completeness, Freeman, San

Francisco, CA, 1979, 338 pp. [18] Gelders, L.F., Maes, J., and Van Wassenhove, L.N., "A branch and bound algorithm for the multi item single level capacitated

dynamic lotsizing problem", in: S. Axs~iter, Ch. Schneeweiss and E. Silver (eds.), Multistage Production Planning and Inventory Control, Lecture Notes in Economics and Mathematical Systems 266, Springer, Berlin, 1986, 92-108.

[19] Graves, S.C., "Multistage lotsizing: An iterative procedure", in: Schwarz (ed.), Multilevel Production and lnvento O, Control ,~vstems: Theory and Practice, North-Holland, Chapter 4, 1981, 95-110.

[20] Gtinther, H.O., "Planning of lot sizes and capacity requirements in a single stage production system", European Journal of Operational Research, 31/2 (1987) 223-231.

[21] Hooker, J.N., "Karmarkar's linear programming algorithm", Interfaces 16/4 (1986) 75-90. [22] Karni, R., and Roll, Y., "A heuristic algorithm for the multi-item lotsizing problem with capacity constraints". HE Transactions

14/4 (1982) 249-256. [23] Lambrecht, M., and Van der Eecken, J., " A facilities in series capacity constrained dynamic lot size model", European Journal

of Operational Research 2 (1978) 42-49. [24] Lambrecht, M.R., and Vanderveken, H., "Heuristic procedures for the single operation multi item loading problem", AI1E

Transactions 11/4 (1979)319 326. [25] Love, S.F., "A facilities in series inventory model with nested schedules", Management Science 18/5 (1972) 327-338. [26] Maes, J., "'Capacitated lotsizing techniques in manufacturing resource planning", Unpublished Ph.D. Thesis, Katholieke

Universiteit Leuven, 1987. [27] Maes, J.. and Van Wassenhove, L.N., "A simple heuristic for the multi item single level capacitated lot sizing problem",

Operations Research Letters 4/6 (1986) 265-273, [28] Maes. J., and Van Wassenhove, L.N., "Simple heuristics for the capacitated multilevel Iotsizing problem", to appear in

International Journal of Production Resarch.

148 J. Maes et al. / Multilevel capacitated lotsizing

[29] Rosling, K., "Optimal lot sizing for dynamic assembly systems", Working paper, Linkrping Institute of Technology, Sweden, 1985, 54 pp.

[30] Silver, E.A., and Meal, H.C., "A heuristic for selecting lot size quantities for the case of deterministic time-varying demand rate and discrete opportunities for replenishment", Production and Inventory Management 2nd Qrt. (1973) 64-77.

[31] Steinberg, E., and Napier, H.A., "Optimal multilevel lotsizing for requirement planning systems", Management Science 26/12 (1980) 1258-1271.

[32] Thizy, J.M, and Van Wassenhove, L.N., " Lagrangean relaxation for the multi item capacitated lotsizing problem: A heuristic implementation", l iE Transactions 17/4 (1985) 308-313.

[33] Van Wassenhove, L.N, and De Bodt, M.A., "Capacitated lot sizing for injection moulding: A case study", Journal of the Operational Research Society 34/6 (1983) 489-501.

[34] Wagner, H.M., and Whitin, T.H., "Dynamic version of the economic lot size model", Management Science 5/1 (1958) 89-96. [35] Williams, J.F., "Heuristic techniques for simultaneous scheduling of production and distribution in multi-echelon structures:

Theory and empirical comparisons", Management Science 27/3 (1981) 336-352, [36] Zahorik, A., Thomas, L.J., and Trigeiro, W.W., "Network programming models for production scheduling in multistage, multi

item capacitated system", Management Science 30/3 (1984) 308-325. [37] Zangwill, W.I., "A deterministic multiproduct, multi-facility production and inventory model", Operations Research 14/3 (1966)

486-507.