Resource loading by branch-and-price techniques : models and algorithms

Resource loading by branch-and-price techniques : models

and algorithms

Citation for published version (APA):

Hans, E. W., Gademann, A. J. R. M., Velde, van de, S. L., & Zijm, W. H. M. (2002). Resource loading by

branch-and-price techniques : models and algorithms. (BETA publicatie : working papers; Vol. 87). Twente University.

Document status and date:

Published: 01/01/2002

Document Version:

Publisher’s PDF, also known as Version of Record (includes final page, issue and volume numbers)

Please check the document version of this publication:

• A submitted manuscript is the version of the article upon submission and before peer-review. There can be

important differences between the submitted version and the official published version of record. People

interested in the research are advised to contact the author for the final version of the publication, or visit the

DOI to the publisher's website.

• The final author version and the galley proof are versions of the publication after peer review.

• The final published version features the final layout of the paper including the volume, issue and page

numbers.

Link to publication

General rights

Copyright and moral rights for the publications made accessible in the public portal are retained by the authors and/or other copyright owners and it is a condition of accessing publications that users recognise and abide by the legal requirements associated with these rights. • Users may download and print one copy of any publication from the public portal for the purpose of private study or research. • You may not further distribute the material or use it for any profit-making activity or commercial gain

• You may freely distribute the URL identifying the publication in the public portal.

If the publication is distributed under the terms of Article 25fa of the Dutch Copyright Act, indicated by the “Taverne” license above, please follow below link for the End User Agreement:

www.tue.nl/taverne

Take down policy

If you believe that this document breaches copyright please contact us at: openaccess@tue.nl

providing details and we will investigate your claim.

E.W. Hans, AJ.R.M. Gademann, S.L. van de Velde &

W.H.M. Zijm .

WP-87

BETA-publicatie: WP-87

ISSN: 1386-9213

NUGI: 684

Enschede:

July 2002

Resource loading by branch-and-price techniques: models and

algorithms

E.W. Hans (corresponding author)

Department of Technology and :\lanagement

~C:niversityof Twente

P.O. Box 217. 7500 AE Enschede. The :'\etherlands

email: e.w.hans:Qsms.utwente.nl

A.J.R.M. Gademann

Department of Technology and :\Ianagement LTniversity of Twente

P.O. Box217, 7500 AE Enschede, The :'\etherlands

and ORTEC consultants

S.L. van de Velde

Rotterdam School of :"Ianagement Erasmus LJniversity

P.O. Box 1738, 3000 DR Rotterdam. The Netherlands

W.H.M. Zijm

Faculty of Applied :\IRthematic:s Gni"ersity of 1\\'ente

P.O. Box 217. 7.500 AE Enschede. The l\'ethel'lands

July 12. 2002

The resource loading problem is a tactical capacity planning problem, which concerns the loading of a set of customer orders into a production system with \'arious resources. Resource loading supports customer order processing by determining reliable due dates. and the required regular and nonregular resource capaci ty Ie\'els for a set of kno\\'n customer orders. It can also be used to determine the required resource capacity le\'els for the underlying scheduling problem. Little research has been done in the development of tactical planning methods that incorporate both capacity flexibility and technological constraints.

Our modeling approach offers a generic frame\vork for modeling various resource loading problems. It can handle a large variety of practical aspects, such as generalized precedence constraints. various forms of capacity flexibility. tardiness penalties, and minimum duration constraints. l\loreover, it can handle resource driven and time driven approaches both simultaneously and separately. 'Ye discuss a branch-and-price algorithm to solve this problem to optimality. and various heuristics based on this method. 'Ye have tested the algorithm and some heuristics on a set of test instances with various parameter settings. The computational results show that large problems with a planning horizon of up to 15 weeks can be solved to optimality.

Subject classification: Production/scheduling: planning. Integer programming algorithms:

1

Introduction

The manufacturing typology that \\'e consider in this paper is the make-to-order (?vITO) environ-ment. An MTO environment is typically characterized by a non-repetitive production of small batches of specialty products. which are usually a combination of standard components and

cus-tom designed components. Typicall~',many of today's :\11'0 manufacturers are faced with the

problem that during order acceptance order ch;:"acteristics are still uncertain. Orders may vary significantly with respect to routings. material and tool requirements, etc. 1\loreO\'e1'. these at-tributes may not be fully known at the stage of order acceptance. Companies tend to accept as many customer orders as they can geL although it is extremely difficult to measure the impact of these orders on the operational performance of the production system. due to the uncertainty in the order characteristics. This conflicts with t he prevailing strategy of companies to maintain flexibility and speed as major weapons to face stronger market competition (Stalk Jr. and Hout,

1988). Surprisingly enough. the majority of the companies in this situation do not use planning and control approaches that support such a strategy.

\\'hile much at tent ion in research has been paid to detailed production planning (scheduling) at the operational planning le\'el (short-term planning), and to models for aggregate planning at the strategic planning level (long-term planning). the availability of proper (mathematical) tools for thel-eS01L1'Celoading p1'Obiemat the tactical level is very limited. The models and methods found in the literature for t he operational and strategic level are inadequate for resource loading. Scheduling algorithm'3 are rigid with respect to resource capacity but are capable of dealing with routings and precedence constraints. Agt,rregate planning models can handle capacity flexibility, but use limited product data, e.g .. by only considering inventory levels. Hence they ignore precedence constraints or other technological constraints.

In practice, many large companies choose material requirements planning (MRP) based

sys-tems for the intermediate planning level (Orlicky, 1975). Although :.\IRP does handle precedence

constraints. it assumes fixed lead times for the production of parts or subassemblies which results in rigid production schedules for parts or entire subassemblies. A fundamental flaw of :.\IRP is that the lead times do not depend on the amount of work loaded to the production system. There is an implicit assumption that there is always sufficient capacity regardless of the load (Hopp

and Spearman, 1996). In other words, :\IRP assume.-s that there is infinite production capacity.

The main rea'3on for the lack of adequate resource loading methods may be that models that impose both finite capacity constraints and precedence constraints are not straightforward, and

computationally hard to solve.

The aforementioned difficulties \vith respect to the uncertainty of data in the order processing stage are typical of :\ITO environments. There is uncertainty as to what orders can eventually be acquired, while furthermore order characteristics are uncertain or at best partly known. Moreover, the availability of some resource-s may be uncertain. \Ve present the resource loading model'3 and methods in this paper as tactical instruments in :\ITO environments, to support order processing by determining reliable due dates and other important milestones for a set of known customer orders, as well as the resource capacity le\'el'3 that are required to load this set on the system. Since detailed order characteristics are not available or only partly known, we do not perform a detailed planning, but we do impose precedence constraints at a less detailed level, e.g., between cells. Once the order processing has been completed. the resource loading function can be used to determine the resource capacity levels required for the underlying scheduling problem. Note that in resource loading capacity levels are flexible, while in scheduling they are much less, or not at all. Hence resource loading can detect where capacity level'3 are insufficient, and solve these problems by allocating orders (parts) more efficiently, or by temporarily increasing these capacity level'3 by allocating nonregular capacity. e.g.. working overtime. As a result, the underlying scheduling problem will yield more satisfactory results,

2

Problem description

\Ve consider a job shop that consists of171 independent machine groups Ah, ... ,AIm. A set ofn

orders is to be loaded on these machine groups. As usual at the resource loading level, we discretize

the planning horizonT into time buckets of equal length (indext = 0, ... ,T). In the remainder,

we refer to these buckets as periods. \Vithout loss of generality we assume that the unit of time

is one hour. and that periods hm'e a length of one week. Each order Jj

(j

= 1, ... ,n) consists

of nJ jobs (Bl ), . . . .Bn ) ,)) with linear precedence relations. Hence no job can be started unless

its predecessor has been completed, Job Bb) (b

=

1, ... ,7/j) needs to be performed on machine

g,TOUp flbj E

Ph ....

,jIm}for a gi\'en positive time Pbj (hours). In the resource loading problem

we regard a machine group as one type of resource, while it may consist of several machines. \Ve assume that the further disaggregation of a job into operations, which must be performed on machines, is done at the operational planning level.

A job Bbj may have a prespecified maximum workload per week. This is usually a result of

1lwbj of the total job workload, where /L'bj is the minimum duration of the job in weeks. Each order has a release date r) before which its first job can not be started and a due date dj (both are expressed in weeks) before which all its jobs should be completed. From the (external) order release and due dates, the precedence relations, and the minimum duration of the jobs, we calculate for each job Eo) its internal release date rbj and internal due date dbj. Preemption of jobs is allowed, i.e., the execution of any job may be spread over different. not necessarily subsequent, weeks.

For the resource loading problem we consider two types of resource capacities: machine group capacity and operator capacity. Since machine group capacity investments are made at a higher, strategic level of decision making. they are assumed to be fixed for the resource loading prob-lem. ~lachine group capacity is thus considered as regular capacity, that can not be expanded

temporarily. \Ve indicate the total capacity of machine group iII; in week l by mCit. \Vithout

loss of generality we assume that machine operators are fully cross-trained and can thus operate any machine in any machine group. An operator must be present at the machine group during the entire processing time. 1\Iorem'er, we assume that an operator can operate only one machine at a time. For operators we distinguish regular and nonregular capacity (i.e., working overtime

and hiring st aft'). ~Iachine groups can thus be operated in regular and nonregular operator time.

Correspondingly. we divide the total machine group capacity'nLCit of machine group Ali in week

l into machine group capacity in regular and in nonregular operator time. The machine group

capacity in regular operator time is indicated by 171Cit. As a result, rncit - rncit is the machine

group capacity in nonregular operator time, which can only be obtained by letting operators work in nonregular operator time. To elucidate why it is necessary to make a distinction between ma-chine group capacity in regular and in nonregular operator time, consider the situation where a company lets operators work on a machine group in 1 shift of 8 hours per day, 5 days a week, i.e., mCit =10. Suppose there are .3 operators, i.e .. the operator capacity (indicated by Ct) is 120

hours. The total machine group capacity is med

=

100hours, and the workload to be performed

is 50 hours. Although total operator capacity and total machine group capacity are sufficient to

process the workload (Ct

=

120

>

50and mCit

=

100

>

50), the machine group can be operated

in regular time for only ,10 hours. The remaining 10 hours must be performed with nonregular

operator capacity.

In general, if capacity is insufficient to complete all jobs before their due date in regular time, short-term production capacity may be expanded at extra costs. There are three options to expand short-term production capacity:

• vVorking m over'time. Of course, extra labor costs are invoh'ed, and we assume that the unit overtime cost is a known constant. Furthermore. collective labor agreements put an upper bound on the number of overtime production hours per week. The assigned number of overtime hours in week / is indicated by Ot.

• Hiring extra operators. \\"e assume that the cost per hour of hiring one extra operator is a known constant. \Ve distinguish hiring operators in regular operator time and in nonregular

operator time. The number of hired production hours in week

t

in regular operator time is

indicated by Hr. and in nonregtLlar time this is indicated by

Hi

v .

\Vithout loss of generality we assume that the cost of hiring in regular opccrator time is the same as the cost of hiring in nonregular operator time. \Ve assume there is an upper bound to the total hirable operator capacity per week.

• Outsourcing (stLbco ntracting). \Vhile certain jobs can not be outsourced, other jobs can. \Ve assume that the total cost of outsourcing a job is proportional to the amount of work. The

number of outsourced production hours for machine group IvIi in week

t

is indicated bySit.

The upper bound to Sit is indicated by Sit.

A resource loading is feasible when sufficient operator and machine capacity is assigned to all jobs, while all job constraints (e.g .. precedence relations, release and due dates, etc.) are satisfied. A feasible loading specifies for every period how much and which type of extra capacity is planned to be used in every period and how much of each job will be processed.

In resource loading, two clearly different approaches can be distinguished. In resource driven loading, the resource availability le\'els are fi:'.;:ed. order tardiness is allowed, and the goal is to meet order due dates. In time driven loading. the order due dates are considered as strict (tardiness is thus not allowed). and the goal is to minimize the costs of the use of nonregular capacity. Since time and costs are equally important at this tactical planning level, in practice both approaches

should be used simultaneously. A resource loading tool that uses this approach is an effective

tactical instrument that can be used in customer order processing to determine a collection of orders from the entire customer order portfolio, with a feasible loading plan, that yields the most for a firm. Therefore, the problem is to find a feasible loading that minimizes the total costs. \Ve take two types of costs into account: costs that result from short-term capacity expansions and penalty costs incurred by tardy orders. \\'e refer to this problem as the resource loading problem. After the completion of the customer order processing phase, the resource capacity levels have been set, as well as the (external) release and due dates of the accepted collection of orders. These

due dates are then regarded as deadlines in scheduling. In the following section we present a model that handles time driven planning and resource driven planning simultaneously. The model can be easily adapted to time driven planning by regarding order due dates as deadlines, and it can be adapted to resource driven planning by fixing the resource availability levels.

3

Model approach and notation

The decision problem that corresponds to the resource loading problem is :'\P-complete. This can be l))"o\'en by reduction from the .3-machine job shop problem with unit processing times. This problem is proven to be XP-complete by Lenstra and Rinnooy han (1979).

The complexity of the resource loading problem is mostly due to the precedence constraints between the jobs. \Vhile the resource capacity restrictions can easily be modeled in linear con-straints with continuous variables, formulating the precedence relations requires the use of many integer variables and many additional constraints. Another difficulty is that we allow jobs to be assigned to more than one week, since this increases the number of required constraints and integer variables drastically (Hans, :2001). Any explicit formulation of precedence relations will lead to a model that is so large and complex that optimal results for cases of reasonable size are not likely to be found.

Instead of explicitly formulating precedence constraints we use the concept of order plans. The basic idea is t hat an order plan implies t he difficult order related constraints, such as precedence relations and release and due dates. An order plan

°

J7'

(71

E II_{j )} for an order J_j (j = 1, ...,n)

specifies for each job Bbj (b = 1.... ,nj) the weeks in which Bbj is allowed to be performed.

Accordingly. each order plan is a 0-1 vectoroJ" = (OI,j,O.", ... ,0l,j,T.", ... ,on),;,0,,,, ...,Onj,j,T,,,),

where 0b;t"

=

1 (b

=

1", ..11;./

=

0.. , ..T) if job Bbj is allowed to be performed in week

t,

and 0bjt"

=

0 othenvise. A feasible order plan for order Jj is an order plan in which no job is

allowed to be performed before its release date, in which each job can be performed for at least its

minimum duration. and in which all precedence relations are met. \Ve say that an order planOJ,,

is dominated by another order plan when the order plan OJ,, has at least one element Objt"

=

0

that can be changed to 1 without making the order plan infeasible. \Ve only consider order plans

OJ,, that are not dominated by other order plans.

In addition to the order plans, which specify when jobs are ollowed to be performed, \ve use the concept of an order schedule. An order schedule specifies a realization of an order plan, i.e., it specifies how many hours of each job are performed in each week, An order schedule for an order

J] is characterized by a ,'ector Y = Cyl]O ... YljT •...,Y~')jO.... 'Y"jjT), where Yb]t denotes

the fraction of job B bj performed in week

t.

As a consequence, Pbj Y bjt denotes the number of

hours processing time of job Bbj performed in week t. Thus the order plans take care of difficult

order related constraints, the order schedules must meet the capacity and maximum workload constraints.

To penalize tardiness, we use a modeling approach that complies with the concept of order plans. In the objective function we penalize a selected order plan in which jobs are allowed to be tardy. \Ye thus penalize the possibility of tardiness in an order plan, rather than the real tardiness in an order schedule. Of course, if in an optimal solution an order is not tardy in its order schedule, the solution will not select an order plan for this order in which tardiness is allowed.

\Ye calculate for each order plan0)7' its allowed tardiness P

JTC' which is defined as the tardiness

of jobBn d in order plana)re with respect to the (external) order due dated]. Thus, when en]re

is the last week in which jobBbj is allowed to be produced in order plan0jre, the allowed tardiness

is given by:

Pjre = max

{O,

eTn ],jre - dj } .

The tardiness penalty of order plan OF of order Jj is assumed to be proportional to the allowed

tardiness. It is given as Pjre()' where

e

is the tardiness penalty per week.

There are two possibilities to deal with the linear precedence relations between jobs. First, they can be enforced at the resource loading level by forbidding jobs with a precedence relation to be processed in the same week. Second, they can be enforced in the detailed planning stage. To discern between these methods, we introduce a parameter 8 that indicates the minimum number

of \\'eeks between the completion time of a job, and the start time of its successor. \Ve only

consider the cases 8= 0 and 8 = 1. \\'hen 8 = 1, we speak of a one-job-per-week policy. This

implies that predecessors (successors) of a job must complete (start) in the week before (after) this job starts (completes). Although the one-job-per-week policy is quite common in practice (for instance. a metal working plant that motivated this research uses this policy), it may have quite a negative impact on the order lead time, particularly when the time buckets are quite long compared to the work contents of the jobs. Therefore, we also consider the case that the first week in which a specific job is allowed to be performed overlaps with the last week in which its

preceding job is allowed to be performed. The precedence relation then has to be enforced in

the detailed planning stage. In this case "lve set 8 to 0 weeks. As a result, order plans may be generated in which a number of jobs of the same order are allowed to be performed in the same

week. This does not guarantee that precedence relations bet\"een these jobs can be satisfiedwithin

the week. To increase the possibility of satisfying precedence constraints we impose an additional

restriction that at most K jobs of the same order are allowed to be performed in the same week.

Either method (5

=

0 and 5

=

1) is easily modeled using order plans, which is an additional pro

of using the concept. The con is that there are exponentially many order plans, and hence any such type of formulation poses a formidable computation challenge.

\Ve propose a mixed integer linear programming formulation in which exactly one order plan

must be selected for each order. Since the aforementioned job restrictions such as precedence

relations are embedded in the order plans. these restrictions are automatically satisfied. Via

column generation we generate interesting order plans. Via branch-and-price we select one order plan per order, and verify whether more order plans must be generated. \Ve use binary variables X)" to select an order plan a_F for an order J).

The number of order plans for an order J) (i.e.,

IITjl)

is exponentially large. E.g., suppose

an order has Hj jobs with linear precedence relations and k slack weeks, where the number of

slack weeks is the diflerence bet\\'een the ma\:imum order duration (assuming that tardiness is not allowed), and the minimum order duration. The number of order plans for this order corresponds

to the number of ways to divide k slack weeks over nj jobs, which is knO\vn as a redundant

combination. Hence there are

(nJ-kk-l)

different feasible order plans for this order.

In the following section we propose a mixed integer linear programming formulation in which

we make sure that for each order J) the determined order schedule and selected order plan are

consistent.

4

Problem formulation

The following tables summarize the notation that we use to formulate the problem:

Model input parameters:

H the number of orders (index j = 1, ....H).

172 the number of machine groups (index i

=

1, ...• 172).

nj the number of jobs of orderJ) (indexb= 1, ...•nj)'

Bbj the b-th(b = 1, ... ,7lj)job of order J).

ajr; mCit rnCit Ct, 0t, ht Sit Ot, ht , St U'bj 8 Tj,dj,d j Tb], d bj Pjr; (]

the machine group on which jobB bj must be processed.

the processing time of jobBb).

the set of all feasible order plans (for orderJ_{j ).} 'if-th order plan for order Jj •with elements abjtr;'

total regular capacity of machine group "\Ii in week

t.

capacity of machine group i\Ii in week [, in regular operator time. operator regular, overtime. hiring capacity in week ["

outsourcing capacity in week [,.

overtime, hiring, outsourcing cost per hour. minimum duration (weeks) of jobBbj (/L'bj ::-.: 1).

minimum time lag (0 or 1 week) between adjacent jobs. to impose a one-job-per-week policy.

release date, due date. deadline of order J).

internal release, due date of jobBbj'

allowed tardiness of order planaJ17 for order J].

penalty cost for one week of order tardiness.

maximum number of jobs of the same order that are allowed to be produced in the same week.

Model output variables:

Ot overtime hours in week ["

Hf

hired hours in week [, in regular operator time.

H

f'

hired hours in week [, in nonregular operator time.

S;t outsourced production hours in week [, for machine group i\Ii

(i

=

1, ... ,m).

Uit number of hours on machine group1\.1; in week [, in nonregular operator time.

Xjr; 0-1 variable that assumes 1 when order planajr; is selected for order J_{j .}

Ybjt the fraction of job Bbj processed in week

t.

\Ve propose the following mixed integer linear programming formulation (1LP) of the resource

loading problem. subject to: (1 ) L X j r ; 1 (vj) ,

(2)

r;FIT)

L

abjtr;Xjr; Y bjt - 7iED]

<

o

(vb.j./) ,

(3)

Wbj T L Y b j t 1 (vb. j) ,

(4)

t=rJ m LPbjYbjt

<

Ct

+

o

t

+

_{H t}R

+

H tN

+

L Sit (vt) ,

(5)

b,j ;=1

L Pbj Y bjt

<

mC;t

+

Uit

+

Sit (vi.

t) ,

(6)

{(b,j)ll'b)=;\!')

m

2:=

[lit Ot +H{ ('1

t) ,

(8) i=1 Ot

<

_°t ('1

t) .

(9)

HR+H_{t t}N

_<

_ht (v?) . (10) m

2:=

S';t

<

5t (Vi,

t) .

(11)

i=1 all yariables

>

0, (12) XJT c: {0.1} ('1j.iTE ITj C IT). (13)

In the modeL each order plan 71 for order J_j may be selected by a corresponding binary

variable XJ1:' The objective function 1 penalizes the sum of the total nonregular capacity usage

costs and the total tardiness penalty costs. Constraints 2 and 13 guarantee that exactly one

order plan is selected for each order J). Constraints 3 stipulate that for each order Jj ,the order

schedule (formed by \'ariablesYb)t) is consistent with the selected order plan. It also stipulates

that when a job Bbj has a minimum duration of!Vb) weeks, no more than l/wbj-partof the job

can be performed per week. Constraints c! stipulate that all work is done. Constraints 5 form the operator capacity constraints. Constraints 6-8 form the machine group capacity constraints.

The variable [lit indicates the machine capacity usage in nonregular operator time. Accordingly,

Constraints 8 stipulate that the total machine capacity usage in nonregular operator time is equal to the operator capacity usage in nonregular operator time.

The linear programming relaxation of this problem(LP) is obtained by replacing the integrality

constraints 13 by Xj"

2:

0 ('1),

IT

EIT)).

5

Column generation for solving the linear programming

relaxation

Recall that the number of order plans for an orderJ) (i.e.,

I

ITj

I)

is exponentially large. The general

idea of the algorithm is to first optimize the LPby performing column generation on a restricted

linear programming relaxation (RLP) of theLP. in \vhich for each order Jj we consider a subset

IT

j of all feasible columns IT) for that order. The pricing algorithm generates columns a)" for

orderJ)

(IT

EIT)

\ITj) ,

and adds these columns to

IT)

when they have negative reduced costs. The

optimal LP-solution is generally [LP-infeasible, since theLPallows more than one order plan to

be fractiomtlly selected per order. Hence. after optimizing the LP,we perform branch-and-bound

in conjunction with column generation to find feasible solutions to the I LP. In this section we

5.1

RLP initialization

To obtain an initial feasible RLPwe must find at least one feasible order plan ajr; for each order,

in such a way that a feasible solution to the RLP exists, One feasible order plan ajr; per order

may not result in a feasible RLP because of the finite capacity levels of the resources, vVe may

use a primal heuristic for the I LP to find a feasible set of order plans, Such a heuristic is not

guaranteed to succeed, Note however. that we do not need to find a feasible integer solution, just

a feasible RLP, Since it is easy to finel a basic solution to the RLP we can find a feasible RLP

by column generation as follows, The basic idea is equi\"alent to Phase I of the tvvo-phase simplex method, which is commonly used in situations where a basic feasible solution to an LP model is

not readily available, Phase I of the method involves optimizing a relaxation of theRLP,which is

obtained by adding artificial variables, The objective of this relaxation is to minimize the sum of all artificial variables, The solution to the relaxation is feasible to theRLPif all artificial variables are zero,

The Phase I relaxation of the RLP is obtained by relaxing the work assignment constraints

(4), We do so by adding nonnegative artificial variables Zb):

T

L

Ybjt

+

Zb)

=

1 (Vb,j) ,

t=r_J

As a result, the Phase I relaxation becomes trivially feasible, namely set Xjr;

=

1 for some7rE

TI,

Zbj

=

1(Vb,

j),

and all other variables to 0, The Phase I relaxation is thus feasible for any set of order plans. provided that at least one arbitrary feasible order plan is available per order. These order plans can simply be constructed by. for example. setting the job start times as early as possible, and allowing the jobs to be performed for the minimum duration,

The Phase I objective function becomes:

minL Z b j , b,j

\Ve optimize the Phase I relaxation by column generation, \Ve discuss the pricing algorithm in

the next section, \Ve may in fact use the same pricing algorithm as we use for the original RLP.

After termination of the column generation scheme in Phase I, we evaluate the objective value of the Phase I relaxation, Ifthe objective function value is zero, the current solution is also feasible

to the RLP, Since the order plans in the Phase I relaxation yield a feasible solution to theRLP,

we remove the artificial variables and restore the objective function of the RLP, and continue by

performing column generation on theRLP, However, if the objective function is larger than zero,

5.2

Pricing algorithm

In this section we discuss the pricing algorithm for the case 6

=

O. and arbitrary h. Note that

15

=

0, h

=

1 is equivalent to 15

=

1. From linear programming theory it is known that a solution

to a minimization problem is optimal if the reduced cost of each variable is nonnegative. Since an RLP in a column generation scheme contains for each order only a subset

IT

j of all feasible order

plans IT),we need to determine whether order plans exist with negative reduced cost that are not

inIT). The reduced cost cpr of any order planalT: (T1 E11j , j

=

1" .. ,n) in LP is given by:

11) T

Cj'T: = Pj'T:()

+

0) -

L L

3

b)t ab )t'T:' b=l t=rJ

whereOJ is the (known) value of the dual variable corresponding to condition (2) and

/3

bjtare the

(known) non-negative values of the dual \'ariables corresponding to conditions (3).

To test optimality of the current RLP solution, we determine whether there exists an order

planaj'T:

Crr

E 11j

\IT))

for some order J) (j = 1.. ,.

,12)

with negative reduce costs, that is, with

cJ7r

<

O. To this end, we solve the pricing problem of finding an order plan in

11\IT

with minimum

reduced cost, which boils down to soh'ingn independent subproblems, one for each order. Itwould

be sufficient to find only one order plan with negative reduced costs, however adding all the order

plans with negative reduced costs to theRLP tends to decrease the required number of column

generation iterations. The subproblem for order J_j (j = 1","n) is to minimizeCj'T: subject to

all order plan restrictions: the release date and due date of order J), the minimum duration of

its jobs. the precedence constraints bet,,'een its jobs, and the minimum time lag15. The (binary)

decision variables in the pricing problem are the ab)t'T:'s that form the order plan aj'T: for order J). These \'ariables also determine the \'alues Pj'T: (Pi'T:

"2:

0), which denote the number of weeks that an order is allowed to be tardy. \Yhen the order planaj'T: allows order Jj to be tardy byPj'T:

weeks, a tardiness penaltyPj'T:() is added to the pricing objective.

Note that an order plan may also be represented by the first and last weeks in which each job is

allowed to be produced. For convenience we speak of thestart and completion times of jobs in the

order plan, although the actual start and completion times in the order schedule may respectively be higher and lower.

In the pricing algorithm we account for internal release dates (rb)) and due dates (dbj) of

jobs. These may be calculated from the minimum duration of the jobs, the parameter 8, and the (external) release date and due date of the order. These may also be imposed externally, e.g., to meet certain deadlines on components or parts of an order. Note that. since we allow an order to

job deadline db) as the last week in which a job is allowed to be produced according to an order plan. This deadline is thus not externally given. Accordingly. 'we define the order deadline dj as the deadline of job nj' By default we set: d)

=

dbj

=

T (b

=

1, ... ,nj ). however, we may also set

d

bj to some number smaller thanT to limit the number of feasible order plans, and thus simplify the pricing problem.

\Ve use implicit column generation, i.e., we generate order plans as they are needed. An explicit column generation approach would require that all order plans are generated in advance and kept in computer memory. Since the number of feasible order plans is exponentially large this is not a

serious option. Ourpricing algorithm for solving the subproblem for order Jj is based on dynamic

programming (DP) and uses a forward recursion.

\Ve define the stages, states. and decisions in the DP-algorithm as follows. A stage b in the DP-algorithm is formed by job Bb)' The decision in a stage b regards the start time of job B bj .

The additional restriction that at most 1\ jobs of the same order are allowed to be performed

in the same week implies that we may onl.v allow a job B_b) to be started in a week t, when at

most 1\ - 1 predecessors are allowed to be produced in that week t. Thus to be able to make a

decision regarding a start time of a job B bj . the state(j,b,

t)

must be extended with an additional

parameter a

<

1\. that indicates the number of predecessors that are allowed to be produced in

weekI. l'\ote that sincej is fL;;:ed in a pricing problem, the state (j,b,t.a) is in fact 3-dimensional. Let aj7T be an order plan in state (j.b.l.a) ivith value F)(b,t,a), and let b

>

1. To determine

from which possible previous statesOF can be created. we must distinguish two cases, i.e., a

=

0

and a

>

O. \Vhen a = O. the predecessor (Bb--1,J) is not allowed to be performed in weekt, so

the completion time of the predecessor must be smaller than t. As a result, Jr must have been

created by allowing B bj to be performed in weeks s .. ..,tfor some rb) ::; s ::;t - Wbj

+

1, and the

completion time of the predecessor must be min {t - 1,s }. Accordingly, the previous state must

be(j.b-1. min

{t -

1.s} ,a' )for somes,,'ith rbj ::;s ::;1-Wbj

+

1. and somea '

<

1\.Whena>0,

the completion time of the predecessor of job B_{bj is} t. Accordingly, the previous state must be

(j,b-1,t,a-1).

\Ve now give the dynamic programming recursion to solve the j-th subproblem. The initial-ization is:

F(b

t

)

= { G). ifb=O,

J , ' .a 00, otherwise.

The recursion for a = 0, b = 1, ... , ILj.

t

= rb)

+

Wb) - 1, ' , , ,db) is then:

Fj(b,l,O) = _{rb)~s-:;t-wbJ-t-l}min {min {FJ(b - 1, min

{t -

1, s} ,a' )}

+

!':!.bjt -

~

'3bjU }

(Y'<1'. ~

ifb= n) and 1

>

dbj

otherwise.

The recursion for0

<

(J

<

1\. b= 1. ....

Il

j, I= l'b)

+

U'bj - 1. .... dbj is then:

For all other(J.b, I:

Lemma 0.1 When /5

fOlLnd as:

0, and nj

>

1\, Ihe optimal solution to the j-th pricing SlLbproblem is

Ft

= lpin rj

(Il) ,

I,(J),

(j

= 1, ... ,

Il).

dJ<:t<;d),O<;CT<:h:

o

\Vhen

F/

<

O. a candidate order plan can be found by backtracking. The pricing algorithm

for the j-th subproblem uses O(n)1'I\) space and can be solved in 0(n_J1'2",2) time. Hence the

pricing problem uses O(max(llj)Thn) space and can be solved in 0(max(nj)1'21\2n ) time.

) J

5.3

LP solution analysis

After termination of the column generation scheme on an RLP we evaluate the resulting optimal

LPsolution, Ifthe optimalLPsolution is integral with respect to theXj -" variables, the solution

also forms an optimal solution to the resource loading problem, and we are done. However, a

feasible LP solution in general is not integral. Suppose in an LP solution for an order Jj there

are at least two order plans aJh (7f E

IT

_{j ), for which XJh}

>

0, \Ve call such an order a fractional

order. In contrast, we call order J) an rntegral order if there is a 7fE

IT

j with Xj-"

=

1. Observe

that the order schedule that corresponds with the selected order plan of an integral order is by definition feasible. For a fractional order this is usually not the case. \Ve may transform (a part) the fractional solution to an integral solution as follows. For each orderJj we define an order plan 0j-,,' as follows:

Definition 0.1 Consider any orderJ_j (j = 1. ... ,

n)

and consider the order schedlLle determined

by the r"eali:;ation of the Ybjt values. IVe define the cOTTesponding or'der planOF' as follows: abjt-,,'

=

1if Ybjt

>

0, else ab)t-,,'

=

O.

Lemma 0.2 The order' schedule for orderJ] is feasible if and only if apc' zs a feasible order plan.

o

Since we only work with order plans that cannot be dominated, we define for each order Jj

with a feasible order plan aJ'" a corresponding non-dominated order plan aj,,-. Using Lemma 0.2, the following Ler111na gives a simple but powerful method to try to transform an LP solution into a completely integral or less fractional solution that has the same objective value.

Lemma 0.3 Consider any fractional order J]

U

=

L ....n)with a feasible order plan aj7r' , and a corresponding non-dominated order plan a_J,,-. The 8olution obtained by setting Xj ,,-

=

1 and setting Xj" = 0 for each 'if E

IT

j ('if =1= 'if') is an altemative optimal solution to LP in which Jj

has become an integral order. 0

Thus if a]", is feasible for all orders Jj (j = 1. ... ,n), then we can transform the fractional

solution to a feasible integer solution to the [LP. There generally is no unambiguous way to

transform order plan aj7r' into aj" •. However, Lemma 0.3 holds for any order plan aj.", that dominates aj.",.

6

The branch-and-price algorithm

Ifthe LP solution is fractional, we apply the procedure of Lemma 0.3 to try to transform the

fractional solution into an integral solution without changing the objective function. In general this is not possible, i.e., a part of the solution remains fractional. Hence we apply a branch-and-bound algorithm to find an optirnal integ,Tal solution. In this section we propose a branching strategy to find a feasible integral solution from an optimal fractional LP solution.

The branching strategyB8 aims at fi'Cing violat(xl precedence relations between jobs of

frac-tional orders. \Vhen, in an RLP solution in any node of the branching tree, an order plan

aj7r' (a'i defined in Definition 0.1) is not feasible, there is at least one pair of jobs, say jobs

Bb] and B sj , for which a precedence relation is violated. In B S we alter the allowed intervals

for jobs Bbj and B sj such that they no longer Q\·erlap. \Ve analyze each possible alteration in

the child nodes. _{Recall that job B bj is allowed to be performed in interval}

hj,

d

_{bj ], and job}

Bs ] is allowed to be performed in the (overlapping) interval

[I'

5j,

d

₅

J

To repair the violated

precedence relation between these jobs. we must alter job deadlines, which were introduced to limit the number of feasible order plans and thus reduce the pricing problem size, and job

I

job Bsj Ib+

8

d

sj I I 4 5 6 7 8 weeks - .

- - - - I

Ib f_bj job Bbj db fbj job Bbj ) 1 ~ job B_sj f . d S) 3) I I I I I I I I 0 1

2

3 4 5 6 I 8 0 1

2

3

weeks - .

Figure 1: Repair of a \'iolated precedence relation (S

=

1)

(lb E [max{rbj

+

Wbj - L rsj} .min{dbj .d s) - tUS )

+

1 - S}]). This is illustrated in Figure1. The values (rb), dbj, db)) for jobBb) thus become(rbj.min{db), ld ,lb).and the values (rsj, ds),

d

sj )for

job B sj become (max{rb).lb+S}.dsj.ds))' Subsequently, we eliminate all order plans a)" that

do not comply with the updated job release dates. due dates and deadlines. As a consequence, the

(modified) RLPor even the (modified) LP may no longer be feasible. To determine whether the

modified LP is feasible we apply column generation to the Phase I LPrelaxation, as described in

Section .5.1, and account for the modified job release dates, due dates and deadlines in the pricing

algorithm. \Vhen the modified LP is infeasible. we prune the node. Otherwise, we continue in

this node by performing column generation on the RLP. \Vhen we prune a node, we return to

the parent node in the branching tree.

7

Speed-up techniques

The branching strategy BS forms the basis of our algorithm. In this section we discuss various

ways to speed up the algorithm, First, we may speed up the algorithm by trying to reduce the number of nodes that have to be explored. \Ve try to achieve this by improving the lower and upper bounds before and during branching. Second, we may speed up the method by refraining from finding an exact solution. In the following sections we discuss these methods.

7.1

Lower bound determination by Lagrangian relaxation

Lagrangian relaxation can complement column generation, since it can provide a lower bound to the original problem in every iteration of the column generation procedure with little computa-tional effort (see. e.g., Van den Akker, Hoogeveen and Van de Velde, 2000; Vanderbeck and \Volsey, 1996). Relaxing all constraints in ILP, except constraints

I:"EII]

Xj" = 1 (\fj) and variable re-strictions X)7T E

{O,

I} (\fj,7f E IIj C II), yields a Lagrangian relaxation LILP ('\) that possesses

the integrality property (see Hans, 2001 for details). \\"e can obtain a Lagrangian lower bound to

the line.ar programming relaxationLPeach time an HLP has been solved to optimality, by using

the dual solution of the HLP as Lagrangian multipliers, and by performing a pricing algorithm

on all orders. The lower bound can be determined as follows:

'~;np

+

I,>j8 j.

j

wherezjnp is the optimal objective value of theHLP, c_J is the objective value of thej-th pricing algorithm (i.e., the lowest reduced cost factor of all order plans of order

J)),

and 8_J is a binary variable that is set to 1 when Cj is nonnegative. and set to O. otherwise.

\Ye apply column generation in each node of the branching tree. Hence, in each column

generation iteration in each node we may deternline a lower bound to the LP relaxation of the

resource loading modelfor that node and for all nodes below that node (note that the branching

changes the LP relaxation in every node). Hence, when branching downwards in the branching tree, we store the best lower bound found so far. \Ye compare the best lower bound to an upper bound after every column generation iteration, and terminate column generation and fathom the node when the best lower bound exceeds the best upper bound. This also alleviates the tailing-off effect of column generation.

\Ve also use the Lagrangian lower bound to fix variables. \Vhen the reduced cost of a variable

IS larger than UB - LB (i.e., the difference between the upper and lower bound), we fix that

variable to O. since we know from linear programming theory that that variable must be 0 in any

solution with a value less thanU B. Analogously, we fix each variable with a reduced cost smaller

than LB - UB to 1.

7.2

Finding and improving the upper bound

Before branching we try to find a strong upper bound by first applying various priority rule based heuristics. These load the jobs in a sequence determined by the priority rule, and hereby construct

an order schedule. As an example we mention the eaT/zest due date (EDD) priority rule, that sorts

orders or jobs according to their due dates in an increasing order, and plans the orders or jobs according to this sequence. \Ve assume here that no tardiness is allowed, so the objective is to minimize the costs of extra capacity. \\"e first try to process each job in regular operator time. If

this is not possible without exceeding its due date, we use whichever type of capacity is cheaper

to complete the job in time. Ifwe still can not meet the due date, then we subcontract the entire

form an RLP that holds only these order plans. Solving this RLP yields feasible order schedules that are at least as good (and usually better) than the ones found by the heuristic.

In any node of the branching tree we may try to improve the upper bound by applying a heuristic. \\'e apply the improvemenc heuristic proposed by Gademann and Schutten (2001). \Ve refer to this heuristic asIH. IH starts from a fe-asible solution and tries to improve the solution by iteratively changing the start and completion times of the jobs in the order plans of the solution. Each time we change a start or completion time of a job in an order plan, we determine the

corresponding order schedules by solving an RLP that only contains the order plans of the initial

solution. \Ve use the dual solution of the RLP to evaluate the expected change in the objective

function value for all possible changes in the order plans. Each of the aforementioned changes in an order plan results in two modified coefficients in the coefficient matri.x of the model. In

heuristic I H we e\'aluate all possible changes in the time windows of all jobs, and sort these by

increasing value of the expected change in the objective value.

\\'e accept the first change according to this sorting that actually leads to an improvement.

This is checked by reoptimizing the corresponding RLP. \Ve repeat this procedure until no more

improvement is found. Gademann and Schutten propose several other strategies for accepting

changes. each of \\'hich leads to different heuristics. \Ve do not use these other strategies.

7.3

Heuristic approaches

For large instances, branch-and-bound methods typically require a long computation time to find an optimal solution. or to prO\'e that the incumbent solution is optimal. \\'e found that this is also the case for the resource loading problem. \Ve therefore tested some branch-and-price based heuristics to find a good solut ion in litt Ie time. \\'e use the integrality gap as an indication of the quality of the solutions of these algorithms.

The first and most straightforward branch-and-price based heuristic we tested is the tnmcated

BS (TB S), that truncates the branching strategy B S after a certain amount of time. The resulting

solution of theTBS method is the incumbent solution at the moment of truncation. The TBS

method enables to test B S on large problems.

Another heuristic based on the BS branching strategy is the e-approximation strategy (EAS).

In this heuristic we fathom all nodes in which the lower bound approaches the incumbent (upper

bound) withine% (i.e .. LB· (1

+

e) ~U B). On termination of EAS, its incumbent solution differs

at most e% from t he optimal I LP solution. Hence, this method allows us to find a compromise

We also tested SL\: variants (HBSL ... HBS·l. HBSl+. HBS2+) of an incomplete branching

strategy that is not based on the aforementioned branching strategyBS. This branching strategy

is based on selecting and fixing an order plan for one order in each layer of the branching tree. Hence each layer corresponds to an order J] for which we set oneX]" variable to1. After selecting

an order plan for an order in a node of the branching tree. \ve apply column generation on the problem with the remaining orders (i.e.. the orders for which no order plans have been fixed) to prevent that ii"Xing variables leads to infeasibleRLPs. \Ve use a depth-first node selection strategy to find a feasible solution as fast as possible.

We propose four rounding heuristics (RH1

(E),

RH2

(E),

RH3

(E),

andRH4 (k)) that are based

on constructing an integral solution from a fractional RLP solution by rounding variables Xj "

(j

=

1, ....n. Ti E

IT

j ). Tht."3e heuristics attempt to com'erge to an integral solution in a number

of iterations. in which we round a number of variables (Le., Ii'< variables Xj" either to 0 or to

1). after which we re-optimize the (modified) RLP. In each iteration we apply the procedure of

Lemma 0.3 to try to eliminate fractional orders. Since we do not add order plans in the iterations,

rounding variables may lead to an infeasible RLP. The rounding heuristics thus do not always

lead to a feasible integral solution.

8

Test approach

All algorithms have been coded and tested in the Borland Delphi 5.0C/Sprogramming language

on a PentiumI I 1-600~IHzpersonal computer. running \Vindows NT-J.O. The application

inter-faces with the ILOG CPLEX 7.0 callable library, which we use for optimizing linear programming models and retrieving the optimization results.

By using different branching strategies and combining branch-and-price algorithms with heuris-tics, we obtain various algorithms for resource loading. To test these, we implemented an instance generator that allows us to produce classes of instances with various parameter settings. Section 3 lists the parameters that charac:terize the test instances. Each parameter influences the complexity of the test instances. \Ve aim at generating test instances that are not too easy to solve with any parameter setting. Some parameters mainly determine the problem size (e.g., the length of the planning horizon), other parameters only influence the solution space (e.g., the release and due dates of the orders determine how much slack the jobs have). Our test approach is to first perform preliminary experiments in which we test all algorithms on a small number of instances. For these instances we vary the length of the planning horizon, the number of orders to be loaded and the

number of available machine groups. Based on the prelimin'wy test results we aim to select the best version of the branch-and-price based algorithm for further evaluation. \Ve also choose an interesting class of instances, which we use for more extensive testing of various other parameters. \Ve restrict ourselves to time driven resource loading problems. As a result, in the test instances the orders are not allowed to be tardy. The testing of the algorithms on resource driven resource loading problems is subject of further research.

9

Test instance generation

In this section we describe a test instance generation procedure, which we use for testing the resource loading methods. \Ve categorize the test instances in classes that correspond to different

parameter settings. \\'e particularly vary the length of the planning horizon T

+

1, the number of

orders 11 and the number of machine gTOUpS m. \Ve consider the following values for T and m:

T E {5,lO,15.20,25,30} ,

m E {3,5,7,1O}.

\Ve generate the order data by simulating nil order arrival process, in which orders arrive with

a Poisson arrival distribution at a mean rate ofA. This implies that the interarrival times have

an exponential distribution with an m'erage interarrival time of 1/A weeks. Furthermore, for the

number of orders 11 we have that E(n)

=

A (T

+

1). The release date rj of an order Jj is found

by rounding the arrival time of t he order to the nearest whole number. \Ve consider the following values for parameter /\: A E {0.5, 1, 2}. The remaining order data for an order Jj is then generated

as follows:

• 11j E {1,2, ... ,10}.

The number of jobs of order J_{j (nj)} is uniformly drawn from {I, 2, ... , 1O}. Observe that when

we solve an instance for

t5

= L orders can have at mostT

+

1 jobs.

• Pb) E {lO,1L. ..,60}.

\Ve give the jobs a processing time of a similar magnitude as the size of a time period (i.e., a

week). Accordingly, we drawPbj uniformly from {10, 11, ... , 60} hours.

• _{{L bj} E

{1,2, ...

,m}.

A machine gTOUp number {Lbj is uniformly drawn for each job Bb) from {I, 2, ... ,m}.

• Wbj

=

1.

All jobs have a minimum duration !l'b) of 1 week. so that. when solving the test instance for

o

=

0, varying parameter" (i.e., the ma'Cimum number of jobs of the same order that are allowed

to be produced in the same week) will generally have significant impact on the solution space.

• dj

=

rj

+

nj

+

k - 1, k E {I0.5·n)

1.

rO.,j·11)

+

In.

The order due dated_j must be large enough to allow the order to complete between the release

and due date. For this purpose we first calculate the order minimum duration, and then add

a number of slack weeks k to determine the order due date. \Vithout adding slack weeks (i,e.,

k

=

0), the planning of the order would be trivial. To pre\'ent this. we give each order at least 1

week slack. Also. we want orders with a small number of jobs to generally have fewer slack weeks

than orders with more jobs, For this purpose. we relate the number of slack weeks of an orderJ_j

to its number of jobs nj' Accordingly, we uniformly draw a value from {I0.5 .nj

l ,

rO.5 .nj

+

11}'

and round the value to obtain the number of slack weeks k.

• 0=0::::;. r,; E {2.3.10}.

The r,;-value only applies \vhen a test instance is solved for 0

=

O. Note that, sincelIj

:s;

10 and Wbj

=

1(Vb,j). we have that when"

=

10, all jobs are allowed to be processed in the same week.

From the order release daterj and the order due date dj we determine the internal job release

dates rbj and due dates dbj .\Ve perform computational experiments for 0= 0 and0= 1 on the

same test instances, \Vhen0= 0 and !l'b) = 1(Vb,

j)

the minimum duration of the order is

r

':;-l.

As mentioned before. when fJ = 0 and"

>

1. the order has more internal slack. Note that /j= 0 and " = 1 corresponds to0= I.

The number of orders that are allowed to be processed in a week will be smaller in the first weeks of the aforementioned order arrival process. \\'e therefore simulate an order arrival process for t= 0, ... ,60, and discard the first 30 weeks and consider, for the test instances \vith parameterT, all

orders that are allowed to be produced in weeks {30, 30

+

T},

Each simulation of the order arrival

process generates one test instance for each \'alue of the parameterT (TE {5, 10, 15,20,25, 30}).

\Vhen the interval in which a job Bb) is allowed to be produced (i.e" {rb] , dbj}) fallspartly inside

the planning horizon {30. 30

+

T}.

we consider that job completely if at least half of the interval

{rbj, db)} falls inside the planning horizon {30, 30

+

T}.

For the determination of the various capacity profiles of the resources, we first measure how

arrival process, per machine gTOUp.IIi

(i

=

1, ... ,m). l\ote that each job Bbj requires PbJ hours of

processing time on machine group fJbJ in the time window {rbj.dbj}' \Ve calculate Qit as follows:

Pb Qit

=

'\"'

J

~ db - rb'

+

1

{(b,jlILb,=.\J,} J J

where db)!'~~J-'-1 is the average requiredcapacit~,per \\'eek for jobB bj in its time window {Tbj, dbj }.

Note that

L

Qit is the approximate required operator capacity in week L. FromQit we calculate

Q

L' the average required machine group capacity from week 30 to week 60 (i.e., corresponding

60

to T

=

30) in the gi\'en realization of the order arrival process, i.e., Qi

=

L

%-t.

For the

t=30

experiments, unless noted otherwise. we generate instances where the utilization rate of the total machine group capacity is approximately 807c. and the utilization rate of the total machine group capacity in regular time is approximately 1007c. Accordingly. we set the machine group capacity

in regular time mCit to Qi and the total machine gTOUp capacity meit to 1.25Qi' Furthermore,

for the experiments we generate instances where the utilization rate of the operators in regular

time is approximately 1:257c. Accordingly. we set the regular operator capacity Ct to 0,8

L

Qi'

The utilization rate of the machine groups in regular time is thus limited to 80% by the operator

capacity. Observe that we do not vary the \'alues ofmCit, mCit, and Ct over the time periods

t,

so

these values are the same for all periods L. regardless of the length of the planning horizon.

\Ve draw the available operator overtime capacity per week 0t and hiring capacity per week

h t uniformly from [0. 0.5Ct]. \Ve draw the available subcontracting capacity per week 5t uniformly from [2Ct, 5Ct]. which is sufficiently high in order to be able to easily obtain an initial feasible solution.

\Ve complete the test instance generation procedure by choosing the nonregular capacity cost parameters as follows: 0t = 1,

h

t = :2,5t = 3.

(\II).

10

Preliminary results

\Ve perform preliminary tests to select a branch-and-price algorithm that seems most promising. This algorithm is then tested further. Each branch-and-price algorithm that we test is executed

as a chain of subalgorithms. We initialize the HLP in the root of the branching tree with order

plans that constitute a feasible primal solution to theLPrelaxation. \Ve try to find such a feasible

solution with a stand-alone heuristic. In all branch-and-price algorithms we apply the earliest

due date heuristic (EDD) for this purpose. Ifthis heuristic fails to find a feasible solution, we

apply column generation on the Phase I HLP to either find a feasible primal solution to theLP

not use the EDD heuristic, because it tends to fail to find a feasible solution more often when

more constraints are added to the problem in the branching scheme, Instead, we immediately

apply column generation on the Phase I RLP,

The size of the initial RLP increases considerably with T. Comparing instances with l'

=

10

andl'

=

30, \ve observe that the number of variables in the initialRLPapproximately grows from

1000to GoOO, Analogously, the number of non zeroes grows from "1000 to 25000, and the number

of rows grows from 1000to G500,

For the preliminary experiments \\'e repeat the order arrival process twice for each value of parameters m (m E{3, 5, 7, 1O}) and A (/\E {0.5,1.2}) to obtain 2

*

12 classes, each containing 6 instances (one for each value of1'), \Ve solve all 111 instances for both 6

=

0 and 6

=

1. \Vhen we

solve an instance for 6

=

0, we allow only two jobs of the same order to be produced in the same

week, i,e., in the preliminary experiments we set h

=

2, This parameter setting comes closest to

the parameter setting 6

=

1,

In conjunction with the test instances, we generate two feasible order plans (i,e" for 6 = 0

and 6

=

1) for each order in each test instance, to form the initial RLP for a branch-and-price

algorithm, For this purpose we use a heuristic based on the earliest due date dispatching rule, or,

if this algorithm can not find a feasible solution, we apply column generation on the Phase IRLP.

Table 1 gives an oven'iew of the heuristics that we tested. Table 2 gives an overview of all branch-and-price algorithms that we use for the preliminary testing.

EDD IH RHI(E) RH2(E) RH3(E) RH4 (k)

stand-alone heuristic based on the earliest due date priority rule

improvement heuristic that uses theEDD solution as an initial solution

rounding heuristic 1 with rounding threshold value 0

<

E

<

1 rounding heuristic 2 with rounding threshold value 0

<

E

<

1 rounding heuristic 3 with rounding threshold \'alue 0

<

E

<

1

rounding heuristic 1 with parameter k (k EX)

Table 1: OWrYiew of heuristics,

1'BS 1'BS\LLB EAS(E) 1'BS+IH 1'BS90 HBSl, .... HBS! HBSl+,HBS2+

truncated (after 30 min,) BSwith Lagrangian lower bound,

l'BS without Lagrangian lower bound.

l'BS with an E-approximation strategy,

TBS with IH solved every 3 minutes to improve the upper bound,

1'BS, truucated after 90 minutes.

incomplete branching strategies based on selecting one order plan in each node of the branching tree,

same as HBSl, HBS2, but with additional order plans for each

order in the initial RLP.

Table :3 shows the test results for the heuristics that are listed in Table 1. The heuristics are

tested on all 288 instances (i.e., 114 instances soh'ed for both [;

=

0 and [;

=

1). The first two

columns compare the average and maximum execution times. The remaining columns compare the solution performance. \\'e compare the number of times (again out of 288) that each heuristic finds the best solution \'alue among all the heuristic solutions. as well as the number of times it finds the unique best solution value among all heuristic solutions. The last column displays the number of times that each heuristic finds a solution value that is proven to be optimal by one of the complete branching strategies.

Heuristic Avg. :\lax.

_#

Avg.

_#

_#

_#

_#

_#

exec. exec. Solutions solution Best unique \Vorst" Unique Proven

time time found value best worst optimal

EDD 0 0.01 288 1094.7 3 1 194 82 2 IH 132.87 3608.89 288 596.5 265 212 0 0 70 RH1 (0.01) 27.1,1 1116.69 281 826.6 21 0 38 3 16 RH1 (0.05) 30.10 1615.72 279 815.0 21 0 36 "1 16 RH2 (0.01) 31.8.5 2311.64 288 768.6 39 3 5 2 30 RH2 (0.05) 37.98 2311.13 288 773.0 36 0 6 1 30 RH3 (0.01) 100.,11 7526.77 288 764.9 ·11 0 13 1 38 RH3 (0.05) 103.53 6319.65 287 762.3 50 1 20 3 41 RH'1 (1) 74.81 5631.7-1 288 78-1.0 -17 0 20 5 41 RH-1(2) 32.78 2108.23 196 702.1 30 1 96 2 2,1 RH4(3) 27.87 1662.10 159 704..5 31 6 135 3 22

G\Yesubtracted the number of tirnes that tite solution found wa.s also the best,

Table 3: Comparison of heuristic solutions.

Table 3 shows that all t he rounding heuristics require small execution times. As may be

expected, for RH-1 (k) the computation time drops significantly when k increases, since a larger

value of k implies that in each iteration more \'ariables are rounded at once. Table 3also shows

that the improvement heuristic I H requires significantly more computation time than the other

heuristics. However, this does lead to improved solution values. Table 3 shows that I H finds

a better solution value than the other heuristics for the majority of the instances. Its average solution value is significantly smaller. and it finds the optimal solution for far more instances than

the other heuristics. The additional computational effort for I H thus clearly pays off. \Ve also

note that IH almost always improves the solution value of RH4(1).

EDD is clearly outperformed by all other heuristics. RH1 (0.05), RH2 (0.05), RH3 (0.01), and RH4(1) are the be.5t rounding heuristics. In all branch-and-price based algorithms we try to find