decisionsupportandoptimizationin ... · informs journal on computing...

INFORMS Journal on ComputingVol. 23, No. 2, Spring 2011, pp. 189–204issn 1091-9856 �eissn 1526-5528 �11 �2302 �0189

informs ®

doi 10.1287/ijoc.1100.0393©2011 INFORMS

Decision Support and Optimization inShutdown and Turnaround Scheduling

Nicole MegowMax-Planck-Institut für Informatik, 66123 Saarbrücken, Germany, [email protected]

Rolf H. Möhring, Jens SchulzInstitut für Mathematik, Technische Universität Berlin, 10623 Berlin, Germany

{[email protected], [email protected]}

Large-scale maintenance in industrial plants requires the entire shutdown of production units for disassem-bly, comprehensive inspection, and renewal. We derive models and algorithms for this so-called turnaround

scheduling that include different features such as time-cost trade-off, precedence constraints, external resourceunits, resource leveling, different working shifts, and risk analysis. We propose a framework for decision sup-port that consists of two phases. The first phase supports the manager in finding a good makespan for theturnaround. It computes an approximate project time-cost trade-off curve together with a stochastic evaluation.Our risk measures are the expected tardiness at time t and the probability of completing the turnaround withintime t. In the second phase, we solve the actual scheduling optimization problem for the makespan chosenin the first phase heuristically and compute a detailed schedule that respects all side constraints. Again, wecomplement this by computing upper bounds for the same two risk measures.Our experimental results show that our methods solve large real-world instances from chemical manufactur-

ing plants quickly and yield an excellent resource utilization. A comparison with solutions of a mixed-integerprogram on smaller instances proves the high quality of the schedules that our algorithms produce within afew minutes.

Key words : project management; planning; scheduling; resource constraints; risk analysis; applications;large-scale systems; chemical industries

History : Accepted by Karen Aardal, Area Editor for Design and Analysis of Algorithms; received August 2009;revised February 2010; accepted March 2010. Published online in Articles in Advance July 2, 2010.

1. IntroductionLarge-scale maintenance activities are conducted ona regular basis in industrial settings such as chemi-cal manufacturing, refining, or power plants. Entireproduction units are shut down for disassembly, com-prehensive inspection, and renewal. Such a processis called shutdown and turnaround (or turnaround,for short). It is an essential process but causes highout-of-service cost. Therefore a good schedule forthe turnaround has a high priority to the manufac-turer. A good schedule is not simply a short sched-ule. The project execution can be speeded up at theexpense of adding resource units, mostly in the formof additional workers. Thus, short projects cause highresource costs, whereas cheap projects take a longtime. Moreover, in practice, task execution times typ-ically involve uncertainty. Such uncertainty arises asa result of unforeseen repair jobs, and naturally, ashort schedule is less robust against unexpected repairjobs or processing delays than a schedule with a longduration that offers more flexibility for rescheduling.Such considerations are fundamental in the decisionprocess of a turnaround project manager. We sup-port this process by analyzing the trade-off between

project duration and project cost as well as the effectson the stability of schedules. Our main contributionis an optimization algorithm within a larger decisionsupport framework that computes a detailed scheduleof given project duration with the aim of minimizingthe total resource cost.Clearly, turnaround projects differ in size, duration,

and particular specifications depending on the actualindustrial site. Generally, the turnaround of a largeplant may take in total up to one year and must berepeated every four to six years. Typically, such largeprojects are split into a sequence of shutdowns of sin-gle production units that are planned individually.The time horizon for those projects is often betweentwo and four weeks. The complex working steps ofa turnaround are planned in advance with very highgranularity. They are split into many jobs that mustbe executed in parallel or directly after each other byworkers with a particular specialization such as elec-tricians, pipe fitters, inspectors, cranes, crane drivers,or other craftsmen. In theory, models with jobs thatare executed by workers with different specializationsseem plausible, but here we focus on the case whereeach job needs exactly one specialized type of worker.

189

INFORMS

holds

copyrightto

this

article

and

distrib

uted

this

copy

asa

courtesy

tothe

author(s).

Add

ition

alinform

ation,

includ

ingrig

htsan

dpe

rmission

policies,

isav

ailableat

http://journa

ls.in

form

s.org/.

Megow, Möhring, and Schulz: Decision Support, Optimization in Shutdown and Turnaround Scheduling190 INFORMS Journal on Computing 23(2), pp. 189–204, © 2011 INFORMS

This is a consequence of the fine resolution of workingsteps in turnaround planning, and it is not too restric-tive because we can model the more general case byenforcing parallel precedence relations for subsets ofjobs; see §3 for more details. At this level of planning,the turnaround of an entire manufacturing site mayconsist of 100,000 to 150,000 jobs, whereas the typi-cally considered (sub)project size for shutting down;e.g., a single cracker is between 500 and 2,000 jobs.More explicitly, we model a turnaround project

as a huge number of precedence-constrained opera-tions or jobs that must be executed by maintenancegroups of different specializations. Scheduling theseis already a complex task because various workingshifts must be respected. However, in this particularproblem another issue increases the complexity dras-tically: the duration of a job is flexible in the sense thata job can be accelerated by increasing the number ofresource units (workers) allocated to it. Typically, tech-nical reasons restrict the choice to a range between amaximum and minimum number of workers. We canassume that the duration of a job is a nonincreasingdiscrete function of the number of workers allocatedto it. Because of communication overhead between theworkers, the duration of a job decreases at a smallerrate than the rate at which the number of assignedworkers increases.We call workers with a particular specialization a

resource type and an individual worker from such agroup a resource unit of that type. Each resource unitcauses a certain cost for each time unit that it isused. For various resource types, a certain number ofresource units is generally available on the manufac-turing site for flexible job assignments. We call theminternal resources. However, during a turnaround, asignificant overhead of work is to be done in a shorttime. This requires hiring external resources if internalcapacities are exhausted. Typically, external resourceunits can only be hired for a certain minimum timeperiod and must be paid for even when they are idle.Therefore, we aim for a schedule in which the con-sumption of these resource types is leveled over theperiod in which they are hired—in our model, this isthe entire turnaround period. By leveled, we mean thatresource units are allocated to jobs in such a way thatthe resource usage of each individual resource typedoes not change much over time. In the end, we wantto hire as few workers as possible and pay as littleas possible for them being idle. In §4 we introduceconcrete measures for the quality of leveling.A feasible schedule consists of an allocation of

resource units to jobs and a feasible temporal plan-ning of jobs with respect to given precedence con-straints and working shifts. Ideally, we would liketo minimize both the project duration and its cost.However, there is the trade-off mentioned above; fast

project executions cause high cost, whereas cheapproject executions take a long time.Determining a good project duration depends on

several aspects that need to be balanced against eachother. These include the total resource cost for hiringresource units, the total production loss caused by theshutdown during the turnaround period, and a “riskcost” because of unexpected repairs and delays thatare inherent in maintenance jobs and tend to becomemore influential the more ambitious, i.e., the shorterthe project duration. Let us neglect the risk cost for amoment. Then, for a given production loss per timeunit, one would ideally like to find a schedule thatminimizes total cost, i.e., the sum of out-of-servicecost and the cost for hiring resource units over theturnaround period. If the out-of-service-cost cannotbe quantified, then the manager defines a deadline forthe turnaround; our goal is to find a feasible scheduleof minimum resource cost that meets this deadline.However, risk issues cannot be neglected in pra-

ctice—in particular, not in turnaround projects thatcontain many maintenance jobs that may causeunforeseen repair work or, even worse, delay thecompletion of the job until, say, the delivery of aspare part. Thus the deadline for a turnaround canonly be met with a certain probability that tendsto decrease with an ambitious deadline. Informa-tion on the risk involved with a decision about thelength of a turnaround is crucial to a manager. For-tunately, companies typically have stochastic infor-mation based on experiences with earlier turnaroundprojects. This information permits a stochastic evalua-tion of the risk of the computed schedule with respectto (w.r.t.) meeting the deadline. The risk measures weuse are (i) the expected tardiness of a schedule w.r.t.the chosen deadline and (ii) the probability distribu-tion of the project duration. Computing these mea-sures is #P -complete in general, which makes efficientcomputations unlikely. However, for problems with-out shifts and with unlimited resource units, we canapply known techniques to determine an upper boundon the expected tardiness for a given project sched-ule as a function of its completion time. Interestingly,the computation of this function is algorithmicallystrongly related to the algorithm we use to determinethe deterministic trade-off between project durationand project cost. Our stochastic evaluation of rele-vant schedules enables the project manager to selecta particular schedule according to his or her own riskpreferences.

1.1. Our ContributionIn this paper, we first introduce the problem ofturnaround scheduling and give an overview onthe large variety of related scheduling problems.We then develop a two-phase model for turnaround

INFORMS

holds

copyrightto

this

article

and

distrib

uted

this

copy

asa

courtesy

tothe

author(s).

Add

ition

alinform

ation,

includ

ingrig

htsan

dpe

rmission

policies,

isav

ailableat

http://journa

ls.in

form

s.org/.

Megow, Möhring, and Schulz: Decision Support, Optimization in Shutdown and Turnaround SchedulingINFORMS Journal on Computing 23(2), pp. 189–204, © 2011 INFORMS 191

scheduling and present techniques to solve the indi-vidual phases. The first phase supports the projectmanager in finding a good project duration t observ-ing his or her risk preferences, and the second phaseoptimizes the use of resources for the chosen dura-tion t. A case study with real-world turnaroundscheduling problems carried out in cooperation withthe management consulting company T.A. Cook Con-sultants and two of their customers at chemical manu-facturing sites shows that our methods yield provablygood solutions to large-scale turnaround problems ina very short time.The two-phase approach that we implemented

serves as a decision support tool. In the first phase,the strategic planning phase, a project manager has todecide on the desired makespan for the turnaroundproject and has to quantify the number of workersand other resources available for the project. To sup-port this decision process, we provide an approxima-tion of the trade-off between project duration and costas well as a stochastic evaluation of the risk for meet-ing the makespan. The second phase, the detailed plan-ning phase, is then a combination of resource allocationand leveling for the chosen deadline that we solveheuristically. We complement this by a risk analysis ofthe computed detailed schedule that provides upperbounds for the risk measures “expected tardiness”and “probability of meeting the project duration.”Our methods can handle real-world instances with

100,000 to 150,000 jobs from chemical manufacturingplants within a few minutes and yield solutions witha leveled resource consumption. To evaluate the per-formance of our methods, we compare our solutionswith optimal solutions for problems with up to 50 jobsthat are computed by solving a mixed-integer pro-gram (MIP) formulation of the turnaround problemthat includes all the deterministic features such as dif-ferent shifts, variable resource allocation, resource lev-eling, and complex precedence constraints. Our MIPis time indexed and thus is much too large for typicalproblem sizes of turnarounds. In contrast, our heuris-tic algorithm is fast and produces solutions of goodquality as the comparison with the MIP shows.To the best of our knowledge, this is the first time

that the turnaround scheduling problem is treatedwith this combination of optimization techniques. Theinterest of our cooperation partner T.A. Cook Consul-tants in these methods has led to a commercial ini-tiative in which a software company integrated ourmethods as add-ons to Microsoft Office Project.

2. Related WorkThe turnaround scheduling problem has many rela-tionships with well-established areas of scheduling.

Time-Cost Trade-off. Given a project network ofjobs and precedence constraints, a job may be executed

in different modes, each associated with a certain pro-cessing time and resource requirement. The time-costtrade-off problem asks for the relation between the dura-tion of a project and its cost, which is determined bythe amount of nonrenewable resource units necessaryto achieve the project duration. For a nice survey, werefer to De et al. (1995). Fixing either the project dura-tion or the cost leads to the closely related optimiza-tion problems with the objective to minimize the otherparameter; these problems are referred to as the dead-line problem and the budget problem, respectively.When the resource costs for the jobs are continuous

linear nonincreasing functions of the job-processingtimes, then the deadline and the budget problem canbe solved optimally in polynomial time as has beenshown independently by Fulkerson (1961) and Kelley(1961). Later, Phillips and Dessouky (1977) gave animproved version of the original algorithms in whichiterative cut computations in a graph of critical jobsyield the piecewise linear time-cost trade-off curvethat describes the trade-off between project durationt and associated cost for all t. The running time ispolynomial in the number of breakpoints of the opti-mal time-cost trade-off curve, which may, however,be exponential in the input size (see Skutella 1998b).(A breakpoint of such a piecewise linear function isa point in which the function is continuous but notdifferentiable.) Elmaghraby and Kamburowski (1992)generalized previous algorithms to solve a more gen-eral problem variant in which jobs may have releasedates and deadlines and arbitrary time lags betweenthem. They provided a combinatorial algorithm thatiteratively computes minimum cost flows in an iter-atively transformed network modeling the time lags.Other cost functions have been considered such asconvex (Lamberson and Hocking 1970, Kapur 1973,Siemens and Gooding 1975, Adel and Elmaghraby1984) and concave function (Falk and Horowitz 1972).In practical applications, the discrete version of this

problem plays an important role. Here, the process-ing time of a job is a discrete nonincreasing functionof the amount of the renewable resource allocated toit. This problem is known to be ��-hard (see Deet al. 1997). Skutella (1998a) derived approximationalgorithms for the deadline and budget problem aswell as bicriteria approximations, and Deineko andWoeginger (2001) gave lower bounds on the approx-imability of the problems.Various exact algorithms and metaheuristics have

been implemented for the discrete time-cost trade-offproblem. For an overview, we refer to Chapter 8 inthe book by Demeulemeester and Herroelen (2002).

Time-Cost Trade-off with Capacity Constraints.Motivated by restrictions on resource capacities in

INFORMS

holds

copyrightto

this

article

and

distrib

uted

this

copy

asa

courtesy

tothe

author(s).

Add

ition

alinform

ation,

includ

ingrig

htsan

dpe

rmission

policies,

isav

ailableat

http://journa

ls.in

form

s.org/.


real-world applications, the time-cost trade-off prob-lem has been investigated in problem variants withrenewable as well as nonrenewable resource types oflimited capacity. Such problems are also known asmultimode (resource-constrained) project scheduling prob-lems (see, e.g., Demeulemeester and Herroelen 2002).Various versions of linear and discrete time-cost

trade-off–related problems have also been consideredin the theory of machine scheduling. Besides theavailable machines, there is an additional resourcethat allows us to accelerate the processing of jobs.Approximation algorithms and even polynomial-timeapproximation schemes have been derived. Review-ing these results in detail is beyond the scope ofthis paper. We only mention scheduling with control-lable processing times, which concerns the allocation ofnonrenewable resource units (see the recent surveyof Shabtay and Steiner 2007), scheduling jobs withresource-dependent processing times, which assumes adiscrete renewable resource (see Grigoriev et al. 2007and references therein), and scheduling malleable jobson one or several machines, where the duration of ajob is determined by the number of machines allo-cated to it (see, e.g., Du and Leung 1989, Lepère et al.2002, and Jansen and Zhang 2006).

Resources with Calendars and Working Shifts.In real-world applications, resources are rarely con-tinuously available for processing. Working shifts,machine maintenance, or other constraints may pro-hibit the processing in certain time intervals. Also, inmachine scheduling, various problems with limitedmachine availability have been considered, and werefer to the survey by Schmidt (2000) for complexityand approximation results.In project scheduling, such constraints are known

as break calendars or shift calendars. Zhan (1992)provides an exact pseudopolynomial algorithm forcomputing earliest and latest start times in a gener-alized activity network that may contain minimumand maximum time lags but no capacity boundson the resource types. His modified label-correctingalgorithm respects jobs that may be preempted andthose that must not. This algorithm has been modi-fied into a polynomial-time algorithm by Franck et al.(2001). In the same paper, they also provide priorityrule-based heuristics for solving resource-constrainedproject scheduling problems, where each job mayrequire different resource types.Yang and Chen (2000) consider a job-based, more

flexible version of calendars represented by time-switchconstraints. These constraints specify for any job sev-eral time windows in which the job may be processed.They also extend the classical critical path methodto analyze project networks when resource capac-ities are unbounded. Time-switch constraints havealso been incorporated by Vanhoucke et al. (2002) in

the deadline version of the discrete time-cost trade-off problem to model different working shifts. Theypresent a branch-and-bound algorithm that was laterimproved by Vanhoucke (2005). Experimental resultswere shown for instances with up to 30 jobs and upto 7 different processing modes. Recently, Vanhouckeand Debels (2007) investigated the deadline problemwith time-switch and other side constraints with theobjective to minimize the net present value.

Resource Leveling. Typical goals in project man-agement are the minimization of the total projectduration (makespan), the maximization of net presentvalue or more service-oriented goals such as minimiz-ing waiting time or lateness. In certain applications,the objective functions are based on resource utiliza-tion (see, e.g., Neumann et al. 2003). In particular,when resource units are rented for a fixed time period,then they should be utilized evenly over this time.Harris (1990) developed a critical path-based heuris-

tic for resource leveling of precedence-constrainedjobs with fixed processing times and no side con-straints. Neumann and Zimmermann (2000) presentedan heuristic and exact algorithms for the resource-leveling problem with temporal and resource con-straints. In a number of earlier publications, such asBourges and Killebrew (1962), Easa (1989), Phillipsand Garcia-Diaz (1981), and Bandelloni et al. (1994),heuristics and exact algorithms for simplified problemversions can be found.Considering a variant of interval scheduling,

Cieliebak et al. (2004) aim for minimizing the max-imum number of used resource units. They deriveapproximation algorithms and hardness results.

Stochastic Analysis of Project Networks. Theimportance of dealing with uncertainty in schedul-ing is reflected by the large number of publicationson various aspects of this topic. These results aremostly restricted to problems without resource con-straints and without shift calendars. Several meth-ods have been developed for analyzing the makespanCmax in project networks with random processingtimes, e.g., bounding the expected makespan or itsdistribution function. An exact computation of themakespan distribution—even just a single point ofthis function—is, in general, a #P -complete problem(as shown by Hagstrom 1988) that presumably rulesout its efficient computation. For a general overview,we refer to Adlakha and Kulkarni (1989); for a surveyon methods for bounding the makespan distribution,we refer to Möhring (2001). An experimental studycomparing the performance of various such methodshas been pursued by Ludwig et al. (2001).In particularly, we want to mention the works

of Meilijson and Nádas (1979) and Weiss (1986).They consider jobs with stochastically dependent

INFORMS

holds

copyrightto

this

article

and

distrib

uted

this

copy

asa

courtesy

tothe

author(s).

Add

ition

alinform

ation,

includ

ingrig

htsan

dpe

rmission

policies,

isav

ailableat

http://journa

ls.in

form

s.org/.


processing times and determine an upper bound onthe expected tardiness Ɛ�max�t−Cmax�0�� for a givenproject schedule with makespan Cmax as a function ofthe completion time t (in the model without resourceconstraints and calendars). Interestingly, the compu-tation of this bound is strongly related to solving alinear time-cost trade-off problem.

3. Problem DescriptionIn turnaround scheduling we are given a set � ofn jobs and a set � of renewable resource types. Eachjob needs a finite number of resource units of exactlyone resource type k ∈� for its processing.Processing alternatives of job j ∈ � are character-

ized by the number rj of allocated resources and itsresulting processing time pj�rj �. We assume that rj isintegral and bounded from below and above by rminj

and rmaxj , respectively. Let �k ⊆ � denote the set of jobsthat requires resource type k ∈ �. Because each jobrequires exactly one resource type, we can partitionthe set of jobs � into disjoint subsets �1��2� � � � ��.The amount of work for processing a job j ∈ � is

given by wj�rj � = rj · pj�rj �. We assume that the pro-cessing time is nonincreasing and the work is non-decreasing in the number of resource units. Thus themonotonicity properties

pj�r1�≥ pj�r2� and wj�r1�≤wj�r2�

hold for any r1� r2 with rminj ≤ r1 ≤ r2 ≤ rmaxj . We denoteeach processing alternative for a job j ∈ � given by theresource allocation rj as a mode of job j and denote theset of feasible modes for job j by �j . Thus each feasi-ble mode for job j defines a tuple �rj� pj � of allocatedresource units rj and associated processing time pj .Furthermore, each job j ∈ � has associated a releasedate sj ∈�+ and a due date dj ∈�+ that define the timewindow �sj� dj � in which j must be processed. Duedates are quite rare in our application, but they gener-alize the model, and they turned out to be useful forthe project planner. Precedence constraints are givenby a directed acyclic graph G= �V �E�, where the ver-tices correspond to jobs and there is an edge �i� j� ∈ Eif job i precedes job j (see the end of this section forgeneralized precedence constraints).A vector of processing times p = �p1� � � � � pn� is

a feasible realization if for each j = 1� � � � �n there isa resource allocation rj ∈ �rminj � � � � � rmaxj � such thatpj = pj�rj �. If the resource allocation rj is clear from thecontext, we will simply write pj instead of pj�rj � and wj

instead of wj�rj �.A schedule for a turnaround problem is given

by a pair �S� r�, where r = �r1� � � � � rn� with rj ∈�rminj � � � � � rmaxj � for each job j is a vector of feasibleresource allocations, and S is a vector S = �S1� � � � � Sn�of start times for the jobs. A schedule �S� r� is time

feasible if it respects the release dates, due dates, andprecedence constraints; i.e.,

Si + pi ≤ Sj for all �i� j� ∈ E

andsj ≤ Sj ≤ Sj + pj ≤ dj for all j ∈ � �

The maximum completion time of all jobs, the make-span, is denoted by

Cmax�S� r� �=maxj∈�

�Sj + pj��

For a time-feasible schedule �S� r�, we denote

rk�S� r� t� �=∑

j∈�k� Sj≤t<Sj+pj

rj

as the resource utilization of resource type k ∈ � attime t, and

Rk �=maxt

rk�S� r� t� for all k ∈�

as the maximum resource utilization of resource typek ∈ �, i.e., the maximum number of resource unitsof type k utilized at any time during the turnaround.The maximum resource utilization of a resourcetype k may be bounded by a constant Rk ∈�+, whichwe call the capacity of that resource type.Each resource type k ∈ � has an individual calen-

dar of working shifts, which represents the availabil-ity periods of k. Jobs cannot be interrupted; thus theyneed to be executed during one availability period.Given a project deadline T , we define the actual work-ing time Tk ≤ T of resource type k ∈� as the total timethat resources units of type k are available in the timeinterval �0�T �.We call a schedule resource feasible w.r.t. resource

capacities and calendars if for any resource typek ∈�, the capacity bounds are respected, Rk ≤ Rk, andeach job is executed during one of the availabilityperiods of the corresponding resource type k.For each k ∈�, we are given a cost rate ck that rep-

resents the cost per unit of resource type k per timeunit. The set of resource types is partitioned into twodisjoint subsets, �l and �f , depending on their pay-ment type. Resources of type k ∈ �l have to be paidduring the entire turnaround period for the maximumamount needed. These are mainly external workerswho are hired for the complete turnaround period,and they must be paid for even if they are temporarilyidle. Clearly, the goal of a project manager is to min-imize the amount of paid idle time. In other words,the maximum resource utilization of those resourcetypes should be minimized. We say that these resourcetypes need to be leveled. In contrast, resource types fromset �f are paid for the actual work they perform. Wesay they are free of leveling. In our application, these

INFORMS

holds

copyrightto

this

article

and

distrib

uted

this

copy

asa

courtesy

tothe

author(s).

Add

ition

alinform

ation,

includ

ingrig

htsan

dpe

rmission

policies,

isav

ailableat

http://journa

ls.in

form

s.org/.


are mainly internal resource types. The job sets cor-responding to �l and �f are denoted by � l and � f ,respectively.Now, we can express the total cost of a sched-

ule �S� r� as∑k∈�l

ck ·Rk · Tk +∑k∈�f

∑j∈�k

ck ·wj�rj ��

The first term is called the resource availability cost andrepresents the cost of resource types that must be lev-eled; the second term, called the resource utilizationcost, represents the cost of jobs that do not need to beleveled.The turnaround scheduling task is to find a sched-

ule that is time feasible and resource feasible and hasminimum total cost. In practice, the first term clearlydominates the cost function. If we neglect the cost forjobs that do not need to be leveled, we speak of theresource-leveling problem. This is the problem on whichwe focus in this paper.For later use, we introduce two additional param-

eters that are related to the goal of minimizing theresource availability cost. The first parameter indi-cates how well a single resource type k is leveled andis called the relative resource consumption of resourcetype k and is denoted by k. This parameter is definedfor a schedule �S� r� as the total work done byresource type k relative to the maximum resource uti-lization Rk over the total available working time ofresource type k; i.e.,

k �=∑

j∈�k wj

Tk ·Rk

� (1)

The second additional parameter !k is very usefulwithin the resource-leveling algorithm itself when weneed to identify a resource type that is badly leveledand causes high cost. We call it the relative idlenesscost !k and define it as the cost for the wasted avail-able but not utilized work volume over the availablework volume; i.e.,

!k �= �1− k� · ck� (2)

Next, we present a mixed-integer programming for-mulation of the turnaround scheduling problem for agiven project deadline T . It borrows from the classi-cal time-indexed formulation based on start times forresource-constrained project scheduling by Pritskeret al. (1969) and incorporates the multimode character-istics of jobs. For an overview on models and notationin resource-constrained project scheduling, we referto Brucker et al. (1999). We use binary decision vari-ables xjlt that indicate whether job j ∈ � starts in model ∈�j at time t ∈ �0�1� � � � � T − 1�.We model resource calendars implicitly using start-

time-dependent processing times. In a preprocessing

step we compute for each job j ∈ � the processingtime pjlt when the job starts at time t in mode l ∈�j .If a job cannot be scheduled with respect to calendarsat time t, we set the corresponding variable xjlt tozero. The resource requirements of job j in mode l isdenoted by rjl. The formulation is as follows:

min∑k∈�

ck ·Rk · Tk

s.t.∑l∈�j

T−1∑t=0

xjlt = 1 ∀ j ∈ �� (3)

∑l∈�j

T−1∑t=0

t · xjlt −∑l∈�j

T−1∑t=0

�t+ pilt� · xilt ≥ 0

∀ �i� j� ∈ E� (4)

∑j∈�k

t∑#=0

∑l∈�j

rjl · xjl# · ��#+pjl#>t��#�≤Rk

∀k ∈�� t = 0� � � � � T − 1� (5)

0≤Rk ≤ Rk ∀k ∈�� (6)

xjlt ∈ �0�1� ∀ j ∈ �� l ∈�j � t = 0� � � � � T − 1�Constraint (3) assures that each job starts exactly

once in one of its modes. Because of (4), every twojobs i� j respect the precedence constraints.Finally, inequalities (5) and (6) guarantee that the

capacity constraints are met.Because of the time expansion, time-indexed formu-

lations for scheduling problems are usually hopelessfor large problem instances. However, small instancescan be solved using integer programming solvers suchas CPLEX, and we can thus evaluate the performanceof our algorithm by comparing the computed solutionwith an optimal solution for such instances.We conclude this section with a remark on fur-

ther so-called generalized precedence constraints that areimportant in some practical turnaround problems.Our algorithms can handle these requirements, butwe do not elaborate on this in the present paper.Constraints occurring in our applications are as

follows:• Fixed start times: A job j ∈ � must start at its

release date Sj = sj .• Parallel sets: Two jobs i� j ∈ � must be exe-

cuted in parallel for the processing time of theshorter job. Without loss of generality we assumethat pi�ri� < pj�rj �. The condition is fulfilled if Si ≥ Sjand Si + pi�ri�≤ Sj + pj�rj �.• Forbidden sets: Two jobs i� j ∈ � that form a

forbidden set must not be executed in intersectingtime intervals. This is expressed by the followingcondition Sj ≥ Si + pi�ri� or Si ≥ Sj + pj�rj �.• Zero maximum finish-start time lags: Job j has to

be executed immediately after the completion of job i;i.e., Sj = Si + pi�ri� must hold.

INFORMS

holds

copyrightto

this

article

and

distrib

uted

this

copy

asa

courtesy

tothe

author(s).

Add

ition

alinform

ation,

includ

ingrig

htsan

dpe

rmission

policies,

isav

ailableat

http://journa

ls.in

form

s.org/.


• Zero maximum start-start time lag: Two jobs i� j ∈ �have to start at the same time Si = Sj .

4. Solution MethodsWe implemented a two-phase solution method forturnaround scheduling problems that serves as a deci-sion support tool. In the following subsections, wegive a brief outline of the method and describe it inmore detail.

Phase I.We compute a time-cost trade-off curve thatprovides the approximate cost for any possible choiceof duration T for the turnaround. To this end, we relaxthe integrality of the resource usage and neglect theresource capacities and working shifts. Then we solvea linear time-cost trade-off problem with time win-dows to optimality. Finally, we apply an heuristic scal-ing technique to approximate the true costs and tocompute associated feasible schedules. This includescomputing job modes for every T that results fromscaling the breakpoints of the linear time-cost trade-offcurve.Based on that curve (and information about the risk

involved; see below), the decision maker chooses aparticular makespan for the turnaround duration. Thismay be fixed by the decision maker based on his orher risk aversion and other preferences but could alsobe the result of minimizing the total cost when out-of-service costs are available. The job modes computedfor the chosen makespan are the basis for the secondphase.

Phase II. In this phase, we solve the actual turn-around scheduling problem with all side constraintsfor the turnaround duration chosen in the first phase.We determine feasible start times for all jobs andadjust the resource allocation such that the temporalunavailabilities of resources as well as the given dead-line T are respected. We find a feasible schedule witha resource profile that is leveled over the project dura-tion, i.e., a schedule with minimized resource avail-ability cost.

Stochastic support. The decision-making process ofthe user is supported in both phases by a risk analysisof the respective solutions. We estimate the expectedtardiness of relevant schedules for a deadline T andthe probability of meeting it. In the first phase, this isdone for each schedule corresponding to a breakpointof the (relaxed) time-cost trade-off curve, and in thesecond phase, it is done for the final schedule afterresource leveling. We complement the expected tardi-ness of a schedule with confidence intervals that tellthe project manager how likely that certain projectdeadlines will be met.In the following sections, we describe the two main

phases of our algorithm and the stochastic analysis indetail.

4.1. Phase I—The Time-Cost Trade-off CurveThe trade-off between project duration and projectcost can be represented as a so-called time-cost trade-off curve. For each possible project duration the curveprovides the minimum cost. Such a curve can guide amanager when making a decision on a project dead-line. Clearly, computing the exact curve is computa-tionally intractable for a complex turnaround problem;however, an approximate curve is sufficient for deci-sion support.In this phase, we do not consider the resource avail-

ability cost as defined in §3. Instead, we computethe actual resource utilization cost without the addi-tional cost for idle times when renting and levelingresources. The reason is that the cost of idle times isvery sensitive to small changes in the schedule thatoccur only at project execution. Therefore, at this stage,when a project manager must decide on a projectduration, he or she is interested only in the trade-offbetween project duration and resource utilization costand does not consider the cost for idle times.To compute such an approximate time-cost curve,

we first compute an optimal curve for a relaxed prob-lem and turn it into a feasible solution using roundingand scaling techniques. To help decide on the projectduration, we add the out-of-service-cost per time unitand thus determine a minimum point of the resultingcurve. The general outline of the procedure is summa-rized below, followed by a detailed description. Fig-ure 1 visualizes the effects of the procedure and thecurves.

Algorithm 1 (Time-cost trade-off algorithm withscaling)Input: Turnaround scheduling instance.Output: Approximate time-cost trade-off curvewith respect to resource availability cost.

1 Compute the optimal time-cost trade-off curvefor the linearized problem version withoutresource constraints (calendars, capacities).

2 for each breakpoint p of the curve do3 Round up fractional resource assignments

to the nearest integral value rj �= � rj .4 Apply list scheduling heuristics that respect

calendars and capacity constraints.5 Scale point p and apply dominance rules.

In the first step we relax our problem. We linearizethe job modes �j and allow nonintegral resource allo-cations rj . We convert the modes of each job into a lin-ear function by linear interpolation. This cost functiondefines the dependency between processing time andcost. Furthermore, we assume that all resource typesare available continuously, and we do not level theresource usage. Then the problem reduces to assign-ing a (possibly nonintegral) resource consumption rj ,

INFORMS

holds

copyrightto

this

article

and

distrib

uted

this

copy

asa

courtesy

tothe

author(s).

Add

ition

alinform

ation,

includ

ingrig

htsan

dpe

rmission

policies,

isav

ailableat

http://journa

ls.in

form

s.org/.


Time

Cos

t

(a)C

ost

Time

155,000

150,000

25015050

145,000

(b)

Figure 1 Time-Cost Trade-off CurvesNotes. The optimal solution for the linear time-cost trade-off problem fora relaxation of the original turnaround problem is shown in (a). The opti-mal solution of the relaxation is turned into an approximate solution for theoriginal turnaround problem by applying heuristics at the breakpoints in (b).The time is given in hours and the cost is given in euros. Adding the out-of-service cost to the cost function yields a cost optimal makespan and servestogether with risk analysis to support managerial decision making.

and thus a processing time pj , to each j ∈ � and find-ing a time-feasible schedule of minimum resourceutilization cost. This is the classical time-cost trade-off problem with additional release dates and dead-lines (time windows) for jobs.This problem without time windows can be solved

optimally in polynomial time in the input and thenumber of breakpoints of the curve (Fulkerson 1961,Kelley 1961, Phillips and Dessouky 1977). In fact,most of our real-world instances do not require themore sophisticated and time-consuming algorithmthat respects also time windows by Elmaghraby andKamburowski (1992).The optimal time-cost curve for the relaxed problem

is a lower bound on the optimal time-cost curve for thetrade-off problem including all other side constraints.Now, the schedules associated with points on

the time-cost trade-off curve need not be feasible.Usually, resource assignments are nonintegral andresource calendars are not respected. To obtain a costcurve respecting these conditions, we consider allbreakpoints T i of the relaxed curve and turn the cor-responding schedules into feasible schedules. Interpo-

lation between the cost of these schedules then givesthe new approximate-cost curve.For a particular T i, we round up a nonintegral

resource allocation rj to the nearest integer. Thisincreases the resource utilization cost but also guaran-tees that we do not exceed the job completion timesfrom the linear relaxations. Once all jobs j ∈ � haveintegral values rj , we greedily try to decrease theresource allocation and thus the cost without violat-ing the deadline T i.Furthermore, schedules must be adapted to respect

the given calendars. This will usually result in jobdeferrals and increased cost, but this way, we obtainfeasible solutions. We apply simple but fast list-scheduling heuristics that reschedule with respect tothe resource availability (timewise and capacitywise).We refer to this as scaling a breakpoint T i and the asso-ciated schedule. Within this heuristic approach, wemay turn two infeasible schedules �S1� r1� and �S2� r2�with makespans Cmax�S1� r1� > Cmax�S2� r2� and costscost�S1� r1� < cost�S2� r2� into two feasible schedules�S ′

1� r′1� and �S ′

2� r′2� with costs cost�S ′

1� r′1� < cost�S ′

2� r′2�

but with makespans Cmax�S′1� r

′1� < Cmax�S

′2� r

′2�. In

that case, schedule �S ′2� r

′2� is dominated by �S ′

1� r′1�,

and therefore, we do not store �S ′2� r

′2�. The scaled

time-cost trade-off curve is obtained by interpolationbetween the points obtained after scaling and apply-ing this dominance rule; see Figure 1(b). The differencebetween the linearized curve and the scaled curveobviously depends on the resource calendars and theresource capacities. In our real-world instances theproject durations are scaled by a factor between 2and 3, whereas the costs hardly differ.The resulting curve is an approximation of the opti-

mal time-cost trade-off curve where the computedcosts in the breakpoints are an upper bound forthe optimal resource utilization cost. We guaranteethat each point of the curve corresponds to a fea-sible schedule respecting all constraints. However,the resulting curve need not be convex anymore; seeFigure 1(b).Although resource calendars and precedence con-

straints are considered, leveling the resource usageover time has not yet been addressed. This objective istaken care of in the next phase when a project deadlineis fixed. In the current stage, the approximated time-cost trade-off curve together with the stochastic analy-sis as described in §4.3 guides a turnaround managerin his or her decision on the project duration T .

4.2. Phase II—Resource Leveling andDetailed Scheduling

We enter the second phase with a maximum projectduration T and a feasible choice of processing times p&

(with corresponding resource consumptions r&j forj ∈ � ) given by the chosen approximate solution of

INFORMS

holds

copyrightto

this

article

and

distrib

uted

this

copy

asa

courtesy

tothe

author(s).

Add

ition

alinform

ation,

includ

ingrig

htsan

dpe

rmission

policies,

isav

ailableat

http://journa

ls.in

form

s.org/.


the first phase. Whereas T remains fixed, the choiceof job modes �r&j � p

&j � serves solely as a starting point

for solving the resource-leveling problem. We con-struct a schedule �S� r� that is time feasible andresource feasible and minimizes the resource avail-ability cost

∑k∈�l ck ·Rk · Tk. In Figures 4 and 5 in §5

we illustrate the difference between a schedule withtemporary high-resource consumptions and a sched-ule with evenly used resource types that causes lowerresource availability cost based on real turnarounddata.Our solution approach focuses on the minimiza-

tion of the resource availability cost with respect tothe feasibility of a schedule. To that end, we com-bine binary search on capacity bounds with differentlist-scheduling procedures. Recall that only resourcetypes k ∈�l need to be considered for leveling.We compute initial lower and upper bounds, LBk

and UBk, respectively, on the maximum resource uti-lization Rk for each resource type k ∈ �l. A lowerbound is given by the minimum resource require-ment of each job and by the minimum total workloaddivided by the working time of the correspondingresource. More formally,

Rk ≥ LBk =max{max� rminj � j ∈ �k��

∑j∈�k

rminj · pj�rminj �

Tk

}�

The upper bounds UBk for k ∈ � might bepart of the input; otherwise, we compute an earli-est start schedule �S� r� without limitations in theresource availability and use the resulting maximumresource utilization as upper bounds; i.e., UBk �=maxt rk�S� r� t�.In our algorithm we iteratively choose a resource

type k ∈�l that is badly leveled, meaning that a largefraction of the total availability cost is spent on idletimes of resource type k with respect to its currentbound UBk. In §3 we therefore introduced the mea-sure of relative idleness cost (2) for each resourcetype k depending on the maximum resource utiliza-tion Rk. At this stage of the algorithm, the relativeidleness cost is defined based on the current upperbound UBk on the maximum resource utilization Rk,i.e., with a slight abuse of notation,

!k =Tk ·UBk−

∑j∈�k wj�rj �

Tk ·UBk

· ck�

In each iteration, we choose a resource type k& withmaximum relative idleness cost, !k& =maxk∈�l !k, andtry to decrease the upper bound UBk& on its capacitywhile all other resource capacities remain fixed. Weaim at decreasing UBk& to ' · UBk& +�1 − '� · LBk& forsome 0<'< 1. An upper bound can be decreased to avalue u if we find a time- and resource-feasible sched-ule for the given total project duration T that utilizes at

no time more than u units of resource type k&. We ver-ify this property heuristically by using list-schedulingprocedures. Each of these procedures considers a dif-ferent ordering (list) of jobs by which jobs are insertedinto a partial schedule. With respect to the given prece-dence constraints, it is desirable to place jobs accord-ing to a topological ordering. Such orderings can beobtained by forward and backward computations ofearliest start dates, earliest completion times, lateststart dates, and latest completion times of the jobs withrespect to the given shifts and the given makespan T .We also use lists that have a random switch; i.e., thebeginning of the list up to a randomly chosen positionis sorted by increasing earliest start dates, whereas thejobs after that position are sorted by increasing latestcompletion times. We use five different such lists.If the list-scheduling procedures do not yield a fea-

sible schedule, we find the lowest upper bound thatallows a feasible schedule by binary search. If anupper bound UBk cannot be decreased in this way, wedo not consider resource type k for leveling anymoreand set its lower bound to LBk =UBk.Notice that in this procedure, we do not aim

at decreasing one particular badly leveled resourcetype immediately down to its lowest utilization limit.Instead, we consider all badly leveled resource typesin a round-robin fashion and decrease their utiliza-tion in each round to a certain fraction of the pre-vious bound. The idea behind this is to balance theeffects that the decreases in utilization of differentresource types have on each other. Experiments haverevealed that it is beneficial to focus not only on a sin-gle resource type but on all of them, one after another.The relative idleness cost !k steers the prioritizationof resource types within the round-robin selection.A more formal description of our algorithm is as

follows.

Algorithm 2 (Resource leveling)Input: Set �l of resource types that must beleveled, set L of topologically sortedlists of jobs, maximum total projectduration T , and parameter ' ∈ �0�1�.

Output: Leveled resource utilization Rk

for each resource type k ∈�l.1 Set LBk and UBk to initial values

for each resource type k ∈�l.2 while ∃ k ∈�l� LBk <UBk do3 Choose resource type k& ∈�l with

LBk& <UBk& and !k& maximum.4 Set a temporary upper bound

uk& �= ' ·UBk& +�1−'� ·LBk& .5 for each list in L do6 if List scheduling yields a feasible schedule

with makespan at most T then7 Set UBk& �= uk& .

INFORMS

holds

copyrightto

this

article

and

distrib

uted

this

copy

asa

courtesy

tothe

author(s).

Add

ition

alinform

ation,

includ

ingrig

htsan

dpe

rmission

policies,

isav

ailableat

http://journa

ls.in

form

s.org/.


8 goto Step 3.9 // if List scheduling failed for each list:10 Set LBk& �= uk& .11 if LBk& =UBk& then12 Rk& �= LBk& .13 �l �=�l\�k&�.14 else15 goto Step 4.

At the end of §3 we introduced additional, more-complex generalized precedence relations betweenjobs. Our algorithm can handle these constraints:when inserting a job into a partial schedule during thelist-scheduling procedure (Step 6), this type of addi-tional constraint can be respected. However, depend-ing on their complexity, these constraints weakenthe performance of the list-scheduling heuristics andclearly slow down the computation process. In ourreal-world instances, these constraints have mainly acommon structure. In most cases they involve cranesthat are required for a short time in parallel to a longjob. It appears that cranes are no bottleneck resourcein our instances and they are free of leveling. There-fore we can eliminate those precedence constraintsin the resource leveling and handle them in a post-processing step without causing major conflicts. Sim-ilarly, we can substitute a group of jobs associatedwithin generalized precedence relations by a singleone if their time windows and respective resourcecapacities are no bottleneck and reinsert them afterthe resource-leveling procedure. In this way, gener-alized precedence constraints become rare and theincrease in the running time is acceptable.Another refinement of our list scheduling heuris-

tic concerns the flexibility in the resource utilizationand thus the influence on the processing times ofjobs. Traditional list-scheduling procedures deal withfixed realizations of processing times. Notice that sofar we have only used the unchanged job modes asthey were fixed in the first phase of the turnarounddecision framework. Certainly, these first choices arebased on an optimal solution for a relaxed problemversion, and thus they are a good starting point, butwe would neglect optimization potential if we keptthem fixed. In particular, in such a complex schedul-ing situation as the turnaround problem, the “wrong”resource allocation for a single job may block theresource unfavorably and prohibit an already feasiblesolution for a certain resource capacity.We address this issue by incorporating a local

search on the resource allocation rj of jobs j ∈ � intoour list-scheduling procedure. If a job j cannot beinserted because its current processing time exceedsthe beginning of a nonavailable period of the respec-tive resource for a small amount, then we increasethe number of assigned resource units rj (if feasible),

and thus, we decrease the processing time until thejob eventually fits feasibly into the schedule. If thisis not successful, we recursively include predecessorsof j in this search. This refinement may speed up theresource leveling algorithm noticeably. The reason isbecause Steps 5 and 6 of the binary search find a fea-sible solution much faster and accept a decrease ofthe upper bound on the capacity.

4.3. Risk Analysis in Phases I and IIOne of the essential features of turnaround schedul-ing is the fixed upper bound on the makespan T forthe whole turnaround. This bound T determines thehiring of external resources, the loss of productionof the factory unit undergoing the turnaround, andthe shifting of production to other factory units. It istherefore crucial to make a good decision about themakespan T in Phase I and to be aware of possi-ble risks of the actual turnaround schedule computedin Phase II. Such risks are inherent in a turnaroundproject because of the many maintenance jobs thatmay involve unforeseen repair activities. Thus over-ambitious values of T will involve a high risk ofexceeding T , whereas values that are too pessimisticwill result in an unnecessary loss of production aswell as possibly higher external resource costs.To aid the decision makers in choosing a good

makespan T , we have implemented methods for eval-uating two risk measures that are used in both phases.These are based on the assumption that the process-ing times of (some) jobs j are random variables Xj

with (roughly) known probability distribution Pj andmodal value pj , where pj is the deterministic pro-cessing time resulting from the given mode �rj� pj � ofjob j (either at a particular breakpoint of the time-cost trade-off curve in Phase I or caused by the fixedmode of the final schedule in Phase II). For computa-tional reasons that will become obvious below, we alsoassume that theXj are discrete random variables. In ourreal-world instances, they have up to four values, p1j <p2j = pj < p3j < p4j , where p1j denotes an early comple-tion, p2j is the planned processing time, and p3j and p4jmodel an increase in processing time because of repairwork and waiting for spare parts plus repair, respec-tively. From the theoretical point of view, one can eas-ily imagine more stochastic events, but the restrictionto at most four events seems to be reasonable andcommon in practice. More parameters are consideredas unnecessary overhead by our industrial partners,because this information is hard to specify.The makespan Cmax is then a function of the ran-

dom processing times Xj and is thus also a randomvariable that depends on the joint distribution P of thejob-processing times Xj . Because these are typicallystochastically dependent (often with a positive corre-lation), an exact calculation of percentiles or other val-ues of the distribution function of Cmax is not feasible

INFORMS

holds

copyrightto

this

article

and

distrib

uted

this

copy

asa

courtesy

tothe

author(s).

Add

ition

alinform

ation,

includ

ingrig

htsan

dpe

rmission

policies,

isav

ailableat

http://journa

ls.in

form

s.org/.


because this is #P -complete even for independent pro-cessing times (see Hagstrom 1988). We therefore com-pute worst-case measures that are valid for arbitrarydependencies among jobs.The first such risk measure is an upper bound +

on the expected tardiness of the makespan, which isdefined as

+�t� �= supQ�Qj=Pj

ƐQ�max�Cmax− t�0��

where Q ranges over all joint distributions of the pro-cessing times whose marginal distributions Qj equalthe given distributions Pj of Xj . Thus +�t� is anupper bound on the expected time by which Cmax willexceed the value t as a function of t.This bound has been extensively investigated by

Meilijson and Nádas (1979) and Weiss (1986). As afunction of t, +�t� is convex decreasing with a slopeof −1 for all t not exceeding a particular value t0 andcan for all t ≥ t0 be computed as

+�t� = min�x1��xn�

∑j∈�

Ɛ�max�Xj − xj�0��

s.t. Cmax�x1� � � � � xn�≤ t �

where Cmax�x1� � � � � xn� is the makespan resulting fromthe processing times xj of jobs j .This minimization problem is the deadline version

of a continuous time-cost trade-off problem in whichthe cost of job j as a function of its processing time xj

51,0306d 23h 50min

45%

0%5%

55%60%

65%70%

90%

75%

85%

95%100%

Projektdauer

52,912

54,795

56,677

58,560

60,442

Datei Optionen

R i

Ansicht Werkzeuge

Dateiauswahl Input Time Cost Tradeoff Kurve Projekt-Schedule

Hilfe

Projektkosten in €

TAR-Planer

– – – –

Figure 2 Evaluation of the Risk in Phase I Illustrated by a Snapshot of Our Software Tool in GermanNotes. The vertical percentage lines refer to the probability that the corresponding time t is met when the turnaround is carried out with the chosen value T .In the example, T ≈ 7 days, and the probability of meeting T is only 45%.

is just the expected tardiness Ɛ�max�Xj − xj�0�� ofthat job and is thus convex and even piecewise lin-ear because the random processing times are dis-crete. These functions Ɛ�max�Xj − xj�0�� are directlyobtained from the values p1j < p2j = pj < p3j < p4j andtheir probabilities, and the standard algorithm for lin-ear time-cost trade-off problems can straightforwardlybe adapted to piecewise linear and convex cost func-tions. Altogether, this yields a very efficient computa-tion of +�t� as a function of t.Meilijson and Nádas (1979) also show that the

bound +�t� is tight in the sense that for every t ≥ t0,there is a joint distribution Q such that +�t� =ƐQ�max�Cmax − t�0��. In general, Q may dependon t, but if the precedence constraints form a series-parallel partial order (which is the case in our real-lifeinstances; see §5), then there is such a joint distribu-tion Q attaining the worst-case bound for all t. More-over, the distribution function F of Q is then given byF = 1−+. This implies that

Prob�Cmax ≤ t�≥ F �t�= 1−+�t��

which means that the probability that the makespanCmax does not exceed time t is at least the value1−+�t� for all possible dependencies among jobs. Thisprobability is exactly the second risk measure thatwe compute, and it can be directly obtained from thefunction +�t�.

INFORMS

holds

copyrightto

this

article

and

distrib

uted

this

copy

asa

courtesy

tothe

author(s).

Add

ition

alinform

ation,

includ

ingrig

htsan

dpe

rmission

policies,

isav

ailableat

http://journa

ls.in

form

s.org/.


Altogether, the solution of a continuous time-costtrade-off problem derived from the stochastic infor-mation about job-processing times gives us directlytwo risk measures: the expected tardiness of exceed-ing the envisioned or chosen makespan T as +�T � andthe probability of exceeding it as 1− +�T �. Figure 2shows the use of the second risk measure in Phase I,where the probabilities of exceeding an envisionedmakespan T are indicated by different colors.

5. Computational ResultsIn this section we report on our computational resultsobtained on the turnaround scheduling algorithm,that is, the resource-leveling heuristic in §4.2 basedon the project manager’s decision made after thetime-cost trade-off computation described in §4.1. Wetested it on three real-world instances from chem-ical manufacturing sites and on additional smallerinstances with similar characteristics that we gener-ated randomly. We evaluate the performance of thereal-world instances by the means of the relativeresource consumption k, which we introduced asEquation (1) in §3 as an indicator for how well theresource type is leveled. For a large class of artificiallygenerated instances, we can compare the resourceavailability cost of our heuristic solution with the costof optimal solutions or lower bounds, both obtainedby solving the MIP introduced in §3. All computa-tions were done on a 64-bit Linux machine equippedwith a 2.66 GHz Intel Core 2 Duo processor with2 GB of RAM. To solve the integer programs, we usedILOG CPLEX 11.The real-world instances consist of about 1,000 jobs,

and in one case, 100,000 jobs. They require roughly15 different resource types, out of which 8 shall be lev-eled. The processing times per job are widely spreadbetween 20 minutes and 2 days. The precedence rela-

Figure 3 Series-Parallel Structure of Precedence Constraints Between Jobs; Part of a Real-World Turnaround Instance

tions between jobs form a series-parallel structurethat is somewhat dominated by parallel chains; seeFigure 3 for a visualization of such a structure for apart of a real-world input instance. A (slightly dis-torted) example of such a real-world instance can befound in the Online Supplement (available at http://joc.pubs.informs.org/ecompanion.html). The data setconsists of three files with job, calendar, and resourceparameters for one turnaround project. To imitate aproject manager’s decision on the total project dura-tion (based on Phase I), we compute the time-costtrade-off curve for a turnaround instance and chooseminimum, medium, and maximum feasible projectdurations. This yields three test instances per inputinstance to test the resource-leveling heuristic. Thechosen durations are between 4 and 15 days for thesmaller instances.We compute solutions for the huge real-world

instance in less than 10 minutes, whereas solving the1,000 job instances takes only a few seconds. Therelative resource consumption k of the most impor-tant resource types in these examples lies between95% and 99%. Other less costly resource types yielda lower relative resource consumption; see Figures 4and 5 for a visualization of the resource consumptionof selected resource types before and after the level-ing. Nevertheless, this is a high degree of resourceutilization, and the precedence constraints betweenjobs and resource calendars prohibit a much largerresource utilization. To quantify the optimality gap,we consider instances of smaller size for which wecan compute an optimal solution or obtain lowerbounds from solving the MIP.We generated such additional turnaround instances

by randomly setting the parameters mainly withinthe bounds given by the real-world instances. We cre-ated test sets with 30, 40, 50, and 60 jobs and vari-able resource allocation of one or two resource units

INFORMS

holds

copyrightto

this

article

and

distrib

uted

this

copy

asa

courtesy

tothe

author(s).

Add

ition

alinform

ation,

includ

ingrig

htsan

dpe

rmission

policies,

isav

ailableat

http://journa

ls.in

form

s.org/.


Figure 4 Visualization of the Unleveled Resource Consumption for Two Selected Resource Types in a Real-World Project, Aggregated on aFour-Hour Basis

Note. The resource types are cleaners (on top, 100% = 3 units) and metal workers (bottom, 100% = 22 units), respectively.

per job. We used 10 randomly generated instancesper set. The work volume of any job lies between6 and 20. This is clearly a deviation from thereal-world data we received, but this simplifi-cation enables us to compute optimal solutions.Additionally, we generated instances with six orseven resource units per job. To compare the resultswith the previous test sets, we scaled the work vol-ume for each job with a factor of 6.5. Each job requiresone out of two resource types that must be leveledand have an upper bound on the resource capac-ity of 30 or 40. The resource costs are chosen as inthe real-world instances. The precedence relations arechosen randomly in such a way that the precedencegraph is again series parallel as in the real-worldinstances.For each of these randomly generated instances, we

determine deadlines (that is, turnaround makespans)that a manager may choose in the same way as for thereal-world instances. We compute for each instancethe minimum and maximum project duration and

Figure 5 Visualization of the Leveling for Four Selected Resource Types in a Real-World Project, Aggregated on a Four-Hour BasisNotes. The top two resource types are the same as in Figure 4, i.e., cleaners (3 units) and metal workers (22 units), respectively. The bottom two resourcetypes correspond to two different cranes (14 tons and 22 tons) that are only used sporadically. Such resource types are excluded in the leveling.

a value in between, which gives three instances forthe resource-leveling heuristic. The total computationtime of our algorithm is less than a second for eachinstance. We assess the quality of our solutions bycomparing against CPLEX solutions for the corre-sponding MIP formulation stated in §3. As mentionedearlier, the model uses time-indexed variables and istherefore not applicable to instances of the size asis typical in practice. To solve our smaller-size testinstances, we bound the computation time for CPLEXby one hour. If CPLEX does not find a provably opti-mal solution, then we use the current lower bound onthe optimum value for comparison with the results ofour heuristic. Tables 1 and 2 summarize the computa-tional results for each of the two classes of instances,with resource requirements of one to two and six toseven units per job.As already mentioned, our heuristic solves all test

instances in less than one second. In contrast, CPLEXneeds for instances with 60 jobs on average nearlythe total given time limit of one hour. The fourth

INFORMS

holds

copyrightto

this

article

and

distrib

uted

this

copy

asa

courtesy

tothe

author(s).

Add

ition

alinform

ation,

includ

ingrig

htsan

dpe

rmission

policies,

isav

ailableat

http://journa

ls.in

form

s.org/.


Table 1 Comparison of Runtime and Resource Availability Cost (or Lower Bounds) of Optimal Schedules Obtained by CPLEX and Schedules Obtainedby Our Heuristic (Between One and Two Resource Units per Job)

Average Optimal Optimal Gap Max. gap Gap Max. costNumber Runtime runtime solutions solutions heuristic heuristic heuristic gap heuristicof jobs heuristic CPLEX CPLEX (%) heuristic (%) vs. opt. (%) vs. opt. (%) vs. LB (%) vs. LB (%)

30 <1 sec 20 sec 100 61 8 33 — —40 <1 sec 20 sec 100 47 10 38 — —50 <1 sec 25 sec 100 59 7 29 — —60 <1 sec 12 min 83 40 9 33 10 33

Table 2 Comparison of Runtime and Resource Availability Cost (or Lower Bounds) of Optimal Schedules Obtained by CPLEX and Schedules Obtainedby Our Heuristic (Between Six and Seven Resource Units per Job)


30 <1 sec 20 min 68 25 12 48 15 4840 <1 sec 36 min 43 0 13 24 14 3050 <1 sec 36 min 41 7 16 33 17 3860 <1 sec 54 min 10 3 10 19 18 36

Table 3 Comparison of Runtime and Resource Availability Cost (or Lower Bounds) of Optimal Schedules Obtained by CPLEX and Schedules Obtainedby Our Heuristic (Between Two and Four Resource Units per Job)


30 <1 sec 29 sec 100 43 9 31 — —40 <1 sec 19 min 73 10 11 57 14 6950 <1 sec 45 min 15 0 11 17 15 25

column in Tables 1 and 2 reveals that with the increas-ing the number of jobs, CPLEX computations reachthe given time limit, and thus, the computation pro-cess is aborted without having found an optimal solu-tion. This situation occurs, in particular, if we set theresource allocation to six or seven resource units. Ina few cases, our heuristic actually found an optimalsolution after a few seconds, whereas CPLEX did notwithin one hour. The fifth column in Tables 1 and2 quantifies how often our heuristic yields provableoptimal solutions. For resource allocations betweenone and two units, we solve a significant numberof instances to optimality. This changes when theresource requirements increase to six and seven units.In those cases, in which a provably optimal solutionis found (by CPLEX), we compare its cost with thoseof our heuristic. The sixth column in the tables showsthat we obtain solutions that are close to optimum.We leave, on average, a gap of about 7% to 10%and 38% in the worst case; see Table 1. Increasingthe number of resource units yields somewhat worseresults with an average gap of up to 16% and 48%in the worst case; see Table 2. The last columns inTables 1 and 2 compare the results of our heuristic

to the lower bounds obtained by CPLEX. If CPLEXhas solved all instances to optimality, we omit the lastentries because they are equal to the sixth and seventhcolumns. We compute the cost gap of our heuristicto the lower bound over all instances and to thosewhere CPLEX found an optimal solution. In total, thisdoes not dramatically increase the average gap, whichshows that our solutions leave a gap of same size tothe lower bounds as to the suboptimal solutions byCPLEX.So far we have evaluated our heuristic on instances

with up to two processing alternatives per job. Table 3shows our computational results on instances whereeach job requires two, three, or four resource unitsthat are given in advance per job. The work volumeper job lies between 20 and 50. The other parame-ters are equal to those of the instances before. Withincreasing numbers of jobs as well as increasingproject durations, the number of optimal solutionsfound by CPLEX decreases and thus the number ofproven optimal solutions found by our heuristic solu-tions also decreases. It turns out that the average opti-mality gap is again about 10%. The maximum gap hasbeen 57% for a single instance.

INFORMS

holds

copyrightto

this

article

and

distrib

uted

this

copy

asa

courtesy

tothe

author(s).

Add

ition

alinform

ation,

includ

ingrig

htsan

dpe

rmission

policies,

isav

ailableat

http://journa

ls.in

form

s.org/.


6. Conclusions and ResearchPerspectives

To the best of our knowledge, popular project man-agement software does not support a time-cost trade-off related analysis. Resource-leveling packages doexist but seem to use very simple heuristics. More-over, they have their limitations in the presence ofworking shifts, capacity bounds, or other specializedconstraints such as conflicting job sets.Motivated by applications in chemical manufac-

turing, we have formulated the shutdown andturnaround scheduling problem as an integratedproblem that contains various optimization problemsas subproblems, such as the time-cost trade-off prob-lem, the problem of scheduling with resource capac-ities and working shifts, and the resource levelingproblem, all of which have been considered individ-ually previously. We reported on our successful solu-tion approach within a more comprehensive decisionsupport tool that additionally provides tools for riskanalysis during the decision process and for the finalschedule. Our optimization algorithm yields near-optimal solutions in a very short time. We hope thatour work initiates more research on this general andintegrated model to overcome the deficiencies of cur-rent project management tools.Another very challenging line of research has come

out of extensive discussions with practitioners abouthow to cope with uncertainty in turnaround schedul-ing. One question addresses the risk inherent in thewhole planning process. So far we have only imple-mented tools for risk evaluation of given schedules.We applied techniques to determine an upper boundon the expected tardiness and the probability of meet-ing the makespan for a given project schedule. Thisallows the project manager to choose a scheduleaccording to his or her risk affinity. Nevertheless, thismethod is only applied after the schedule optimiza-tion. We expect that an integrated approach that com-bines risk analysis and scheduling might yield betterdecision support for turnaround projects, but this iscurrently beyond the optimization methods availablein practice.

AcknowledgmentsThe authors thank T.A. Cook Consultants for providing thedata used to test their solution method and for explain-ing the details of shutdown and turnaround schedulingprojects. The authors also thank Eamonn T. Coughlan,Elisabeth Günther, Ralf Hoffmann, Robert Pankrath, andInes Spenke for their support in implementing the algo-rithms and developing their software tool.

ReferencesAdel, S. M., S. E. Elmaghraby. 1984. Optimal linear approximation

in project compression. IIE Trans. 16(4) 339–347.

Adlakha, V. G., V. G. Kulkarni. 1989. A classified bibliography ofresearch on stochastic PERT networks: 1966–1987. Inform. Sys-tems Oper. Res. 27(3) 272–296.

Bandelloni, M., M. Tucci, R. Rinaldi. 1994. Optimal resource level-ing using non-serial dynamic programming. J. Soc. Indust. Appl.Math. 78(2) 162–177.

Bourges, A., J. Killebrew. 1962. Variation in activity level in a cycli-cal arrow diagram. J. Indust. Engrg. 13(2) 76–83.

Brucker, P., A. Drexl, R. Möhring, K. Neumann, E. Pesch. 1999.Resource-constrained project scheduling: Notation, classifica-tion, models, and methods. Eur. J. Oper. Res. 112(1) 3–41.

Cieliebak, M., T. Erlebach, F. Hennecke, B. Weber, P. Widmayer. 2004.Scheduling with release times and deadlines on a minimumnumber of machines. J.-J. Lévy, E. W. Mayr, J. C. Mitchell, eds.Exploring New Frontiers of Theoretical Informatics: IFIP 18th WorldComput. Congress. Proc. Third IFIP Internat. Conf. Theoret. Com-put. Sci. (TCS 2004), Kluwer Academic Publishers, Norwell, MA,209–222.

De, P., E. J. Dunne, J. B. Ghosh, C. E. Wells. 1995. The discrete time-cost tradeoff problem revisited. Eur. J. Oper. Res. 81(2) 225–238.

De, P., E. J. Dunne, J. B. Ghosh, C. E. Wells. 1997. Complexity of thediscrete time-cost tradeoff problem for project networks. Oper.Res. 45(2) 302–306.

Deineko, V. G., G. J. Woeginger. 2001. Hardness of approximationof the discrete time-cost tradeoff problem. Oper. Res. Lett. 29(5)207–210.

Demeulemeester, E. L., W. S. Herroelen. 2002. Project Schedul-ing: A Research Handbook. Kluwer Academic Publishers,Norwell, MA.

Du, J., J. Y.-T. Leung. 1989. Complexity of scheduling parallel tasksystems. SIAM J. Discrete Math. 2(4) 473–487.

Easa, S. M. 1989. Resource leveling in construction by optimization.J. Construction Engrg. Management 115(2) 302–316.

Elmaghraby, S. E., J. Kamburowski. 1992. The analysis of activitynetworks under generalized precedence relations (GPRs).Man-agement Sci. 38(9) 1245–1263.

Falk, J. E., J. L. Horowitz. 1972. Critical path problems with concavecost-time curves. Management Sci. 19(4, Part 1) 446–455.

Franck, B., K. Neumann, C. Schwindt. 2001. Project scheduling withcalendars. OR Spectrum 23(3) 325–334.

Fulkerson, D. R. 1961. A network flow computation for project costcurves. Management Sci. 7(2) 167–178.

Grigoriev, A., M. Sviridenko, M. Uetz. 2007. Machine schedulingwith resource dependent processing times. Math. Programming110(1) 209–228.

Hagstrom, J. N. 1988. Computational complexity of PERT problems.Networks 18(2) 139–147.

Harris, R. B. 1990. Packing method for resource leveling (PACK).J. Construction Engrg. Management 116(2) 331–350.

Jansen, K., H. Zhang. 2006. An approximation algorithm forscheduling malleable tasks under general precedence con-straints. ACM Trans. Algorithms 2(3) 416–434.

Kapur, K. C. 1973. An algorithm for the project cost-duration anal-ysis problem with quadratic and convex cost functions. IIETrans. 5(4) 314–332.

Kelley, J. E., Jr. 1961. Critical-path planning and scheduling: Math-ematical basis. Oper. Res. 9(3) 296–320.

Lamberson, L. R., R. R. Hocking. 1970. Optimum time compressionin project scheduling. Management Sci. 16(10) B597–B606.

Lepère, R., D. Trystram, G. J. Woeginger. 2002. Approximation algo-rithms for scheduling malleable tasks under precedence con-straints. Internat. J. Found. Comput. Sci. 13(4) 613–627.

Ludwig, A., R. H. Möhring, F. Stork. 2001. A computational studyon bounding the makespan distribution in stochastic projectnetworks. Ann. Oper. Res. 102(1–4) 49–64.

Meilijson, I., A. Nádas. 1979. Convex majorization with an applica-tion to the length of critical paths. J. Appl. Probab. 16(3) 671–677.

Möhring, R. H. 2001. Scheduling under uncertainty: Bounding themakespan distribution. H. Alt, ed. Comput. Discrete Math. Lec-ture Notes in Computer Science, Vol. 2122. Springer, Berlin, 79–97.

INFORMS

holds

copyrightto

this

article

and

distrib

uted

this

copy

asa

courtesy

tothe

author(s).

Add

ition

alinform

ation,

includ

ingrig

htsan

dpe

rmission

policies,

isav

ailableat

http://journa

ls.in

form

s.org/.


Neumann, K., J. Zimmermann. 2000. Procedures for resource level-ing and net present value problems in project scheduling withgeneral temporal and resource constraints. Eur. J. Oper. Res.127(2) 425–443.

Neumann, K., C. Schwindt, J. Zimmermann. 2003. Project Schedul-ing with Time Windows and Scarce Resources, 2nd ed. Springer,Berlin.

Phillips, D. T., A. Garcia-Diaz. 1981. Fundamentals of Network Anal-ysis. Prentice-Hall, Englewood Cliffs, NJ.

Phillips, S., Jr., M. I. Dessouky. 1977. Solving the project time/costtradeoff problem using the minimal cut concept. ManagementSci. 24(4) 393–400.

Pritsker, A. A. B., L. J. Watters, P. M. Wolfe. 1969. Multiprojectscheduling with limited resources: A zero-one programmingapproach. Management Sci. 16(1) 93–108.

Schmidt, G. 2000. Scheduling with limited machine availability. Eur.J. Oper. Res. 121(1) 1–15.

Shabtay, D., G. Steiner. 2007. A survey of scheduling with control-lable processing times. Discrete Appl. Math. 155(13) 1643–1666.

Siemens, N., C. Gooding. 1975. Reducing project duration atminimum cost: A time-cost tradeoff algorithm. OMEGA 3(5)569–581.

Skutella, M. 1998a. Approximation algorithms for the discrete time-cost tradeoff problem. Math. Oper. Res. 23(4) 909–929.

Skutella, M. 1998b. Approximation and randomization in schedul-ing. Ph.D. thesis, Technische Universität Berlin, Berlin.

Vanhoucke, M. 2005. New computational results for the discretetime/cost trade-off problem with time-switch constraints. Eur.J. Oper. Res. 165(2) 359–374.

Vanhoucke, M., D. Debels. 2007. The discrete time/cost trade-offproblem: Extensions and heuristic procedures. J. Sched. 10(4–5)311–326.

Vanhoucke, M., E. Demeulemeester, W. Herroelen. 2002. Discretetime/cost trade-offs in project scheduling with time-switchconstraints. J. Oper. Res. Soc. 53(7) 1–11.

Weiss, G. 1986. Stochastic bounds on distributions of optimal valuefunctions with applications to PERT, network flows and relia-bility. Oper. Res. 34(4) 595–605.

Yang, H.-H., Y.-L. Chen. 2000. Finding the critical path in an activitynetwork with time-switch constraints. Eur. J. Oper. Res. 120(3)603–613.

Zhan, J. 1992. Calendarization of time planning in MPM networks.ZOR—Methods Models Oper. Res. 36(5) 423–438.

INFORMS

holds

copyrightto

this

article

and

distrib

uted

this

copy

asa

courtesy

tothe

author(s).

Add

ition

alinform

ation,

includ

ingrig

htsan

dpe

rmission

policies,

isav

ailableat

http://journa

ls.in

form

s.org/.

decisionsupportandoptimizationin ... · informs journal on computing...

Documents