A computational study of practical issues arising in short-term scheduling of a multipurpose facility

(1)

A computational study of practical

issues arising in short-term

scheduling of a multipurpose facility

by

Zachariah Stevenson

A thesis

presented to the University of Waterloo in fulfillment of the

thesis requirement for the degree of Master of Mathematics

in

Combinatorics and Optimization

Waterloo, Ontario, Canada, 2019

(2)

I hereby declare that I am the sole author of this thesis. This is a true copy of the thesis, including any required final revisions, as accepted by my examiners.

(3)

Abstract

This thesis focuses on two important considerations when solving short term scheduling problems for multipurpose facilities: deciding when rescheduling should be performed and choosing efficient time representations for the scheduling problems. This class of scheduling problems is of practical importance as it may be used for scheduling chemical production facilities, flexible manufacturing systems, and analytical services facilities, among others. In these cases, improving the efficiency of scheduling operations may lead to increased yield, or reduced makespan, resulting in greater profits or customer satisfaction. Therefore, ef-ficiently solving these problems is of great practical interest. One aspect of real world implementations of these problems is the presence of uncertainty, such as in the form of new jobs arriving, or a machine breaking down. In these cases, one may want or need to reschedule operations subject to the new disturbance. An investigation into how often to perform these reschedulings is addressed in the first part of the thesis. When formulating these problems, one must also choose a time representation for executing scheduling op-erations over. A dynamic approach is proposed in the second part of the thesis which we show can potentially yield substantial computational savings when scheduling over large instances.

The first part of this thesis addresses the question of when to reschedule operations for a facility that receives new jobs on a daily basis. Through computational experiments that vary plant parameters, such as the load and the capacity of a facility, we investigate the effects these parameters have on plant performance under periodic rescheduling. These experiments are carried out using real data from an industrial-scale facility. The results show that choosing a suitable rescheduling policy depends on some key plant parameters. In particular, by modifying various parameters of the facility, the performance ranking of the various rescheduling policies may be reversed compared to the results obtained with nominal parameter values. This highlights the need to consider both facility characteristics and what the crucial objective of the facility is when selecting a rescheduling policy.

The second part of this thesis deals with the issue of deciding which timepoints to in-clude in our model formulations. In general, adding more timepoints to the model will offer more flexibility to the solver and hence result in more accurate schedules. However, these extra timepoints will also increase the size of the model and accordingly the computational cost of solving the model. We propose an iterative framework to refine an initial coarse uniform discretization, by adding key timepoints that may be most beneficial, and remov-ing timepoints which are unnecessary from the model. This framework is compared against existing static discretizations using computational experiments on an analytical services facility. The results of these experiments demonstrate that when problems are sufficiently

(4)

large, our proposed dynamic method is able to achieve a better tradeoff between objective value and CPU time than the currently used discretizations in the literature.

(5)

Acknowledgements

The financial support provided by Natural Sciences and Engineering Research Council of Canada (NSERC), Ontario Centers for Excellence (OCE) and the industrial partner in the analytical services sector are gratefully acknowledged.

I would like to thank my supervisors Ricardo Fukasawa, and Luis Ricardez-Sandoval for their guidance and support.

I would also like to thank Joseph Cheriyan and Jochen K¨onemann for agreeing to read this thesis.

(6)

Dedication

(7)

List of Tables

2.1 Algorithm 1, Generate Time Layered Graph . . . 12

3.1 Descriptions of rescheduling policies considered. . . 24

3.2 Average performance factor (APF) values of each metric for instances with 5,000 starting samples and 500 arriving samples per day. . . 33

3.3 Problem size statistics for instances with a moderate job load. . . 34

3.4 APF differences comparison for instances starting with various numbers of samples and 500 new samples per day. . . 36

3.5 APF differences comparison for instances starting with 5,000 samples and various daily arrival loads. . . 37

3.6 Average makespan APF differences comparison between one quarter capac-ity and full capaccapac-ity instances. . . 39

4.1 Description of parameters used for the framework. . . 51

4.2 Algorithm 2, Get Instant Start Timepoints . . . 53

4.3 Algorithm 3, Get Overloaded Timepoints . . . 55

4.4 Algorithm 4, Get Dominated Timepoints . . . 58

4.5 Descriptions of iterative policies tested. . . 60

4.6 Sizes of instances in each category. . . 62

4.7 Number of instances considered for each iteration number. . . 70

4.8 Average number of variables and constraints per iteration, numbers reported in 1,000’s. . . 73

(11)

A.1 Normalized process parameters used during experiments. . . 85

C.1 Algorithm 5, Dynamic Timepoint Framework . . . 105

C.2 Algorithm 6, Update Solution . . . 106

C.3 Algorithm 7, Helper Methods . . . 107

(12)

List of Figures

2.1 A simplified version of the process network used for experiments. The let-tered boxes represent processes and the arrows denote that a path uses these processes (from tail to head) . . . 9 2.2 An example of how an underlying graph G with travel function τ, and

timepoint sets ε produces the time layered graphG∗. . . 13 2.3 Various timepoint discretizations that may be used. . . 19 3.1 Above is the scheduling horizon before partitioning. Below is a partition of

scheduling sub-horizons that we may actually solve. . . 23 3.2 Performance profile comparing job completion among rescheduling policies

for instances starting with 5,000 samples and 500 samples arriving each day. 31 3.3 Performance profile comparing average job makespan among rescheduling

policies for instances starting with 5,000 samples and 500 samples arriving each day. . . 31 3.4 Performance profile comparing job completion among rescheduling policies

for instances with one eighth the original capacity. . . 38 3.5 Proportion of jobs on time for one month lead times and instances with one

eighth the original capacity. . . 40 4.1 An example of a time layered graph. . . 44 4.2 A flowchart outlining the dynamic timepoint framework. . . 49 4.3 A figure demonstrating under what conditions we add new instant start

timepoints. . . 54 4.4 A figure demonstrating under what conditions we add new overloaded

(13)

time-4.5 A figure demonstrating under what conditions we mark timepoints as

dom-inated, for removal. . . 57

4.6 Results for small instances. . . 64

4.7 Results for medium instances. . . 66

4.8 Results for large instances. . . 68

4.9 The average number of timepoints added, removed, and their difference between iterations over each policy. . . 71

4.10 Per iteration timepoint differences for medium sized instances. . . 72

4.11 Average objective value improvements and time taken per iteration. . . 74

B.1 Proportion of jobs on time for one day lead times and instances starting with 5,000 samples and 500 samples arriving each day. . . 93

B.2 Proportion of jobs on time for one week lead times and instances starting with 5,000 samples and 500 samples arriving each day. . . 93

B.3 Proportion of jobs on time for one month lead times and instances starting with 5,000 samples and 500 samples arriving each day. . . 94

(14)

B.12 Proportion of jobs on time for one month lead times and instances starting with 5,000 samples and 250 samples arriving each day. . . 98 B.13 Proportion of jobs on time for one day lead times and instances starting

with 5,000 samples and 1,000 samples arriving each day. . . 99 B.14 Proportion of jobs on time for one week lead times and instances starting

with 5,000 samples and 1,000 samples arriving each day. . . 99 B.15 Proportion of jobs on time for one month lead times and instances starting

with 5,000 samples and 1,000 samples arriving each day. . . 100 B.16 Performance profile comparing job completion among rescheduling policies

for instances with one half the original capacity starting with 5,000 samples and 500 samples arriving each day. . . 100 B.17 Performance profile comparing job completion among rescheduling policies

for instances with twice the original capacity starting with 5,000 samples and 500 samples arriving each day. . . 101 B.18 Performance profile comparing job completion among rescheduling policies

for instances with four times the original capacity starting with 5,000 sam-ples and 500 samsam-ples arriving each day. . . 101 B.19 Performance profile comparing job completion among rescheduling policies

for instances with eight times the original capacity starting with 5,000 sam-ples and 500 samsam-ples arriving each day. . . 102 B.20 Proportion of jobs on time for one week lead times and instances with one

eighth the original capacity starting with 5,000 samples and 500 samples arriving each day. . . 102 B.21 Proportion of jobs on time for one week lead times and instances with one

quarter the original capacity starting with 5,000 samples and 500 samples arriving each day. . . 103 B.22 Proportion of jobs on time for one month lead times and instances with one

quarter the original capacity starting with 5,000 samples and 500 samples arriving each day. . . 103

(15)

List of Algorithms

1 Generate Time Layered Graph . . . 12

2 Get Instant Start Timepoints . . . 53

3 Get Overloaded Timepoints . . . 55

4 Get Dominated Timepoints . . . 58

5 Dynamic Timepoint Framework . . . 105

6 Update Solution . . . 106

(16)

Chapter 1

Introduction

Scheduling is concerned with how and when to execute operations to optimize a chosen objective such as maximizing profits, or minimizing costs, subject to operational constraints such as deadlines that must be met, or available resource limitations. It is common practice for many industries to make use of scheduling as an optimization problem to guide their progress and meet various economic objectives [14, 29, 39, 40, 43]. Proper scheduling can greatly increase the efficiency of a production plant and therefore is of great practical importance. Scheduling operations over a relatively short period of time, such as a day, a shift or a week is referred to as short term scheduling. We are interested in scheduling in the context of the short term scheduling of a multipurpose plant in the analytical services sector.

The analytical services sector is focused on carrying out analyses on samples that are ordered by clients for various purposes, e.g. performing a nutritional analysis on a food item to create the nutritional facts panel before bringing the product to market, or performing air quality analyses to check for hazardous materials such as asbestos. Companies in the analytical services sector may receive on the order of thousands of samples on a daily basis to be processed at their facility and as such require a suitable method of scheduling operations.

A multipurpose plant is a facility which has a set of processes, such as machines or workers, that may carry out a variety of tasks, i.e. the plant may serve more than a single purpose, such as producing several different products. The problem of scheduling a multipurpose plant can be seen as a variant of the job shop scheduling problem [4, 32]. Jobs arrive at a multipurpose facility, and each job has a set of samples that comprise it and a sequence of processes that the samples must be processed by in order. This sequence

(17)

of processes is called thepath of a job. The goal is to generate a schedule for the facility, which dictates what samples to assign to which processes over the length of time that is to be scheduled such that an objective is optimized. This schedule must also abide by various operational constraints of the problem such as process resource limitations and material balance constraints.

Throughout this thesis, we model these scheduling problems as mixed integer linear programs (MILP), meaning that we restrict the objective function, and constraints of the model to be linear, and allow some variables to be integral. As such, there are already a number of developed techniques designed to solve these problems, such as branch-and-bound methods, and cutting-plane methods. We do not discuss integer programming or these solution methods here, but instead refer the reader to [6] for further information. There are several different MILP scheduling models that exist and one of the key classi-fications of these models is the time representation that is used [24]. For this reason, we discuss this topic in more detail below.

1.1

Time Representations

An important aspect to consider when modeling these scheduling problems is the time representation that is used for scheduling operations. The time representation determines when operations may be scheduled, and can play a large role in determining the com-putational cost of solving the model and the final solution quality [22, 24, 45]. We call each point in time where an operation may be scheduled atimepoint. There are two main classes of time representation: continuous time representation and discrete time represen-tation [13,42].

Continuous time representations allow events to happen at precise points in time during the scheduling horizon, with the selection of where these points should be placed being decided by the model [27, 36, 53]. Because the model is able to choose precisely where timepoints should be located, we may ensure that we obtain the best solutions using this representation [24]. However, one must provide the model a fixed number of timepoints to allocate as input. If the model is allowed to allocate too few timepoints, solution quality may decrease, however if the model is allowed to allocate many timepoints, CPU time may drastically increase. In general, selecting a suitable number of timepoints to allocate for the model can be difficult.

Discrete time models instead fix the timepoints at which scheduling decisions may be made to a subset of points during the scheduling horizon, a priori [21, 38]. We call the

(18)

set of timepoints that the schedule may use the time grid. The difficulty with this repre-sentation is in choosing a suitable time grid to provide the model. There is once again a tradeoff between how coarse or fine the discretization used is, the quality of the resulting schedule and the amount of CPU time required to solve the model. Despite the contin-uous time formulation allowing the model to use precise points in time, multiple works have shown that using a discrete time representation results in better performance than using a continuous time representation for scheduling multipurpose facilities [22, 26, 42]. Therefore, throughout this thesis we concern ourselves with models using a discrete time representation. Moreover, among discrete time representations, the non uniform discrete time representation has been shown to perform best for the scheduling problem considered in ths thesis [22], and so we use this time representation throughout our experiments. This will be discussed further in Chapter 2.

1.2

Rescheduling

Typically, works on scheduling have considered finding an optimal schedule in a static environment where all of the operating conditions are known with certainty throughout the scheduling horizon. While it is necessary to first understand scheduling in this context, in practice it may not always be realistic to assume that all of the information pertinent to generating an optimal schedule will be known in advance, and that no unexpected disruptions to the schedule will occur during operation [49]. In particular, an initially generated schedule can become infeasible or non-optimal because of uncertainties, such as a machine breaking down [2, 5,12,19, 25, 34, 37], the arrival of rush orders [2, 19,25], or actual processing times differing from expected processing times [25,31]. Furthermore, the arrival of new job orders are considered in this thesis and are an important consideration as they may change the optimal schedule and taking into account these new arrivals may improve plant performance.

One possible way to deal with uncertainties is to reschedule, that is, to re-optimize when disruptions occur or at specific (user-defined) time intervals. The decisions involved with rescheduling can be divided into two issues of “how-to” and “when-to” reschedule [35]. The “how-to” addresses how new schedules should be generated. Some examples include a full rescheduling of all operations or a partial rescheduling, where some operations that were scheduled previously remain fixed [35, 49]. We do not focus on how new schedules should be generated in this thesis and simply assume that when rescheduling is done a new schedule is generated from scratch. This was done so that we may ensure that newly generated schedules obtain the greatest performance given the available information,

(19)

assuming that the facility may pivot to the new schedules without performance loss. If subsequent schedules must be similar to current schedules, then a partial rescheduling of operations may be preferred.

Instead, we choose to focus on when to reschedule operations in the first part of this the-sis. There have been a number of works conducted over the last few decades investigating how rescheduling frequency affects schedule performance. There have been studies con-ducted in a variety of environments such as job shop scheduling [2,5,28,37,47,48], chem-ical production scheduling [15,20], material requirements planning [52], scheduling flexible manufacturing systems [19, 31, 34, 35], and scheduling hospital operations [17, 41, 50]. However, in most of these studies the plant and operating parameters (e.g. plant load or plant capacity) under consideration are fixed, and it is not discussed how the results and conclusions vary when these parameters are modified. Understanding the relationship between choosing when to reschedule and the operating parameters of a plant may be of practical importance for several reasons such as seasonal industries where demand may fluctuate greatly depending on the time of year, or facilities where the number of avail-able resources may change (e.g. purchasing additional machines or laying off workers). Indeed, the results show that under certain conditions, we (counterintuitively) find that less frequent rescheduling performs better than frequent rescheduling.

Aside from rescheduling, we may consider robust or stochastic programming as a method to mitigate the effects of these uncertainties on our schedules. Robust and stochas-tic programming aim to find schedules which perform well under the expected disruptions that may occur (stochastic) or subject to the worst case disruptions (robust). Since the uncertainty considered in this work is the arrival of new jobs for which not much infor-mation is known (e.g. number of samples, time of arrival, or path of the job) and there does not seem to be an accurate way of predicting this information, using these methods seems to be quite challenging. Due to these challenges and time limitations, these methods were not considered in this work but could be explored for future work. Regardless of this, we must first understand the relationship between when to reschedule and plant operating parameters in the simplest setting before exploring robust or stochastic methods and this thesis aims to address this gap.

1.3

Tailoring Time Grids

Given that the results concerning how often to reschedule show that in some cases less frequent rescheduling performs better than more frequent rescheduling, large models may be required for obtaining one’s desired scheduling performance. Therefore, the question

(20)

naturally arises: how do we solve these large scheduling problems more efficiently? This question prompts us to take a look at timepoint representations in more detail. In general, if we knew exactly which timepoints were needed to achieve the optimal solution obtained by using a continuous time representation, we would be able to greatly reduce the size of the model by using only these necessary timepoints. However, it is unlikely that we know this information beforehand, yet we must still choose a time grid to use for the model.

As mentioned previously, choosing which timepoints to include in the time grids is in general not obvious and can greatly impact the performance of the model. Furthermore, there have been a very limited number of works that have considered how to tailor time grids for individual problem instances [3, 45]. Here we mean aninstance of a problem to be a problem with given input data, as opposed to the general problem itself.

Velez and Maravelias show in [45] that they are able to generate non uniform time grids based on the instance input data such that the optimal solution obtained by using these time grids has equal objective value to the optimal solution obtained by using an arbitrarily fine uniform discretization. Furthermore, they show that this method of choosing non uniform time grids leads to a much smaller problem size than that obtained by using a “super-fine” uniform discretization. However, to ensure that this guarantee holds, their algorithm may include many timepoints making the resulting model very computationally taxing to solve, especially for large problem instances.

In [3], Boland et al. provide a method for iteratively refining the set of timepoints that they consider for solving the service network design problem. They take a different approach than that of Velez and Maravelias, by beginning with only a few timepoints initially and then determining where to add timepoints based on the obtained solution from solving a relaxation of their problem. They are able to show that their method will also terminate with an optimal solution whose objective value is equal to that obtained by using an arbitrarily fine uniform discretization. Moreover, they show that their method performs well in practice through a computational study.

One possible solution to determining what time grid to provide the model is to solve many instances of the scheduling problem of interest in an attempt to discern a suitable initial time grid based on the optimal schedules of these instances. This may be a time and labor intensive process however, and moreover may provide bad results when optimizing an instance which does not resemble the set of instances used to determine the time grid. Furthermore, this procedure would need to be done for each application individually. In-stead, the approach that we take in this work is to iteratively refine an initial discretization. By carefully choosing the initial discretization and timepoints to add between iterations, we are able to achieve a better tradeoff between solution quality and CPU time on large

(21)

problems than that obtained by using other time grids.

1.4

Contributions of the Thesis

As we have identified above several decisions that impact the quality of generated schedules and the computational difficulty of solving these models, we now outline the contributions of this thesis.

Firstly, a study investigating when to reschedule subject to varying plant parameters is carried out to address the gap in the literature. In this study we consider the rescheduling of a multipurpose facility in the analytical services sector that receives new jobs on a daily basis. Based on the results of the computational experiments, we identify some key parameters that influence how often rescheduling should be done. This study shows that care must be taken to consider not only the scheduling problem being solved, but also the operating conditions of a facility when deciding how often to reschedule. In particular, we find surprising results when the facility is starved for processing resources which can provide valuable insight into choosing a rescheduling scheme in real world scenarios.

Secondly, we present a generalized framework for iteratively refining time grids for scheduling multipurpose facilities. We propose several heuristics for deciding where to add and remove timepoints from the scheduling model’s time grid between iterations. The efficacy of this framework is evaluated through computational experiments comparing its performance against the currently used time grids for scheduling discrete time multipurpose plants in the literature. The results of these experiments show that our method may obtain significant performance improvements over the current time grids in use without a substantial increase in CPU time. Moreover, since the performance of the proposed framework remains relatively stable over a range of problem sizes in our experiments, this framework provides a stepping stone toward improving instance-agnostic methods for choosing time grids.

Note that we do not provide theorems and theoretical guarantees in this thesis. Rather, the focus is on developing heuristic approaches to our scheduling problem with empirical evidence obtained through computational experiments which demonstrate that our heuris-tics seem to perform well in our test cases.

(22)

1.5

Structure of the Thesis

The structure of this thesis is as follows. In Chapter 2 we discuss some necessary back-ground information on the work presented in Chapters3and 4in more detail. In Chapter 3we present our study on deciding when to reschedule subject to varying plant parameters. This includes extensive long term computational experiments to evaluate our reschedul-ing policies. Our work on iteratively refinreschedul-ing the set of timepoints to schedule over is presented in Chapter 4 which includes the proposed framework, our heuristics for select-ing timepoints, and computational experiments demonstratselect-ing the efficacy of our method. Concluding remarks and future work considerations are presented in Chapter5.

(23)

Chapter 2

Background and Literature Review

This chapter includes the necessary background information and gives context to the results of Chapters3and4. We begin by discussing the scheduling problem that is used throughout this thesis in section2.1. To help develop the model for our scheduling problem, we present the definition of time layered graphs in section 2.2. In section 2.3 we present the model that is used throughout our experiments. We then discuss various strategies that are used to determine when to do rescheduling in section 2.4. In section 2.5 we review the developments with respect to choosing discrete time representations.

2.1

Problem Description

We now discuss the scheduling problem used throughout this thesis in more detail. The problem under consideration is a variant of the job shop problem. A facility receives a set of jobs to process,I, and has access to a set of processes,V. Each job i∈I is made up of a discrete collection of samples, and a sequence of processes, Π(i), called a path, that must be performed (in the specified order) on the samples. Using this notation, we specify the

k’th process in the path of job ias Π(i, k) for k= 1, . . . ,|Π(i)|. Each processu∈V of the plant has a set of identical resources (e.g. machines or workers) that may perform a single operation on samples. Each of these resources u has a fixed capacity, κ(u), measured in terms of samples and a fixed processing time,τ(u). Furthermore, we letρ(u) represent the number of resources available for each process u. We assume that resources may not be interrupted once they have started processing (no pre-emption), and that each resource may process samples from many jobs simultaneously (batch mixing), as long as there is available capacity. Additionally, samples from a single job do not need to be processed together, they

(24)

Figure 2.1: A simplified version of the process network used for experiments. The lettered boxes represent processes and the arrows denote that a path uses these processes (from tail to head)

may be split into discrete batches and processed individually (batch splitting) as long as each individual sample passes through the job’s specified path in order. To obtain an idea of the type of network we use in this work, we include Figure2.1which presents a simplified version of the process network that was used in the experiments throughout this thesis. The network shown was obtained by considering all paths and processes such that the most common 70% of the paths in one month of historical data from a real analytical services facility are considered by this network. We refrain from including the actual network in its entirety because as its size makes it cumbersome to include.

We consider scheduling operations for H minutes from time S until time S+H. We refer to the interval [S, S+H] as the time horizon for the problem. Recall that previous works have shown that discrete time representations perform better than continuous time representations for scheduling multipurpose plants [22,26, 42], therefore we also choose to

(25)

timepointsε(u) ={ε(u, t) :t= 1, . . . ,|ε(u)|}, whereε(u, t)≥ε(u, t−1) ∀t = 2, . . . ,|ε(u)|. Since we schedule or reschedule operations over a facility that is already in operation, it is possible that not all processes and samples are available at the beginning of the horizon. Therefore, to account for this we include some additional input parameters that allow samples to arrive throughout the horizon, and process resources to be unavailable at various points during the horizon. To denote both the samples that arrive at the facility and samples that have not finished processing and are carried over from a previous horizon, we useα(i, k, t) to represent the number of samples for jobithat arrive at thek’th process in the path of i (Π(i, k)) at the t’th timepoint of process Π(i, k) (ε(Π(i, k), t)). Z(u, t) denotes the number of resources of processu that have been pre-allocated at time ε(u, t), e.g. a machine is scheduled to be taken down for maintenance, or a machine is still running a process that started before the beginning of the current scheduling horizon.

The goal is to generate a schedule (i.e. an assignment of samples to process resources and times) such that an objective of the facility is optimized (e.g. maximize throughput or minimize makespan) and the schedule is feasible. Namely, we require that we do not over allocate our process resources, we abide by path sequencing constraints (e.g. a sample cannot begin processing by a resource which it has not yet reached), and that resource capacity constraints are met. Note that the particular objective that is used will change throughout this thesis, so we do not specify what is used at this time.

2.2

Time Layered Graphs

We now present the definition of a time layered graph, which is needed to develop the scheduling model for the problem described in section 2.1. Time layered graphs may be useful when representing problems which have a network of states, and decisions must be made based on spatial locations in the graph and time, e.g. routing material between states and over a time horizon. The use of these graphs typically arises in transportation routing problems such as bus or flight routing [1, 3, 8, 11]. They augment the standard static network flow models by adding an extra dimension (time) allowing flows to change over time. This time component will be used in this work to model the scheduling of when to start batch processes in a multipurpose facility.

We assume that there is an underlying directed networkG= (V, A) where our node set

V is comprised of a set of “states” (e.g. physical locations such as stations or holding depots, machines or processes), and our directed arc set A indicates how we may transition from state to state. For each stateu, there is a discrete set of integer timepointsε(u), indicating

(26)

at which times we may leave stateu. We denote the k’th timepoint of ε(u) as ε(u, k). We denote the set of all sets of timepoints asε={ε(u) :u∈V}. Furthermore, we denote the next timepoint in the timepoint set of state u after or at time t as n(u, t) = min{t0 : t0 ∈

ε(u), t0 ≥ t} if it exists, otherwise ∞. At each point in time, t, we assume that there is an integer travel time associated with traveling from stateu, to statev, denoted τ(u, v, t). Note that restricting ourselves to integral points in time for timepoints and integer travel times is without loss of generality (as long as the original time data is rational) as we may discretize time as finely as needed.

With respect to any graphG= (V, A), we denote the set of arcs leaving a nodeq ∈V as

δ_G+(q), and the set of arcs enteringqasδ_G−(q). Similarly, we denote the set of nodes that can be reached by traversing a single arc from nodeq ∈V asN_G+(q) ={v ∈V :∃(q, v) ∈A}, and the set of nodes which can reach q by traversing a single edge as N_G−(q) = {v ∈ V :

∃(v, q)∈A}. When the context of which graph we are discussing is clear, we will omit the subscript to make the notation less cumbersome.

To obtain our time layered graphG∗ = (V∗, A∗) we perform the following construction. The set of nodesV∗ ={(u, t) :u∈V, t∈ε(u)}is the set of all pairs of states and timepoints for each given state. Arcs either start and end at two distinct states, representing the transition from one state to another, or start and end at the same state, representing staying in the same state. We denote the former set of arcs as A∗_L (“leaving arcs”), and use the next timepoint function n(v, t) and travel function τ(u, v, t) to add arcs from (u, t) to (v, n(v, t+τ(u, v, t))) for each neighbor v ∈N_G+(u). The latter set of arcs are denoted as A∗_H (“holding arcs”) we add arcs from (u, t) to (u, n(u, t+ 1)). The full set of arcs of

G∗ are A∗ = A∗_L∪A∗_H. The precise algorithm used to generate the time layered graph

G∗ from the underlying network Gand set of timepoints ε is given by algorithm Generate Time Layered Graphshown in table 2.1.

As an example, consider the graphG= ({A, B, C, D},{(A, B),(A, C),(B, D),(C, D)}), with travel function τ(A, B, t) = 2, τ(A, C, t) = τ(B, D, t) = τ(C, D, t) = 1 ∀t, and time-point sets ε(A) = {1,2,3}, ε(B) = {1,2,3}, ε(C) = {2,3}, ε(D) = {1,3}. Following the construction given by algorithm Generate Time Layered Graph, the graph G along with the resulting time layered graph G∗ are shown in Figure2.2.

In the proceeding discussions throughout this thesis, when we refer to a time layered graph we will assume that we also have access to the underlying graphG, travel functionτ

and timepoint setsε. Moreover, we will use Gto denote a graph with no time components and G∗ to denote a time layered graph obtained from G (with travel function τ and timepoint sets ε).

(27)

Table 2.1: Algorithm 1, Generate Time Layered Graph

Algorithm 1 Generate Time Layered Graph

1: function _{Build Graph}(G, ε, τ) 2: V∗ ← Build Node Set(G, ε)

3: A∗ ← Build Arc Set(G, ε, τ)

4: returnG∗ = (V∗, A∗) 5: end function

6: function Build Node Set(G, ε)

7: V∗ ← ∅ 8: for all u∈V do 9: for all t∈ε(u) do 10: V∗ ←V∗∪ {(u, t)} 11: end for 12: end for 13: returnV∗ 14: end function

15: function Build Arc Set(G, ε, τ)

16: A∗_L, A∗_H ← ∅ 17: for all u∈V do 18: for all t∈ε(u) do 19: if n(u, t+ 1) <∞ then 20: A∗_H ←A∗∪((u, t),(u, n(u, t+ 1))) . Staying at state u 21: end if 22: for all v ∈N+(u) do 23: if n(v, t+τ(u, v, t))<∞ then 24: A∗_L ←A∗∪ {((u, t),(v, n(v, t+τ(u, v, t))))} . Going from u tov at time t 25: end if 26: end for 27: end for 28: end for 29: returnA∗_L∪A∗_H 30: end function

(28)

A B C D 2 1 1 1 A,1 B,1 D,1 A,2 B,2 C,2 A,3 B,3 C,3 D,3 G G∗ τ(A, B, t) = 2, τ(A, C, t) = τ(B, D, t) =τ(C, D, t) = 1 ε(A) =ε(B) ={1,2,3}, ε(C) ={2,3}, ε(D) ={1,3}

Figure 2.2: An example of how an underlying graphGwith travel functionτ, and timepoint sets ε produces the time layered graph G∗.

(29)

2.3

Scheduling Model

Using the notion of time layered graphs from section2.2and the problem description given in section 2.1, we may proceed to present the complete model formulation below. Note that the names used for input data when describing the problem previously will be reused below.

Begin by constructing the graph G= (V, A) as follows. Let the set of nodes be the set of processes of the facility, and add an arc to A from process u to process v if and only if there is a job i ∈ I, k ∈ {2, . . . ,|Π(i)|} such that Π(i, k−1) = u, Π(i, k) = v. Let the set of timepoints ε correspond to those given as input for each process. For defining the travel function τ of the time layered graph, we use the processing times of each process, i.e. τ(u, v, t) = τ(u)∀u∈V, v ∈N_G+(u), t∈ε(u). With this information, we may construct the time layered graphG∗ = (V∗, A∗) as described in section 2.2.

For every job i, every process Π(i, k) in the path of job i, and timepoint t for process Π(i, k) we have an integer decision variablex(i, k, t) which denotes the number of samples of jobithat begin processing on process Π(i, k) at timeε(Π(i, k), t). Similarly, we letw(i, k, t) be the number of samples of jobithat can be processed on process Π(i, k) but instead wait at timeε(Π(i, k), t). For every process u and every timepoint t= 1, . . . ,|ε(u)| we have an integer decision variable y(u, t) which denotes the number of resources of process u that begin processing samples at time ε(u, t). Note that the x and w variables correspond to flows on the corresponding arcs inG∗.

Two additional sets are needed to complete the model. The first set is Θ1(i, k, t) = {t0 =

1, . . . ,|ε(Π(i, k−1))|:ε(Π(i, k), t−1)< ε(Π(i, k−1), t0) +τ(Π(i, k−1)) ≤ε(Π(i, k), t)}. Θ1(i, k, t) is the set of timepoints t0 such that if process Π(i, k−1) starts at t0, then it will

end in the interval (ε(Π(i, k), t−1), ε(Π(i, k), t)]. To put this set into the context of time layered graphs, Θ1(i, k, t) is the set of timepointst0 such that a variable x(i, k, t0) will have t as its head. The second set is Θ2(u, t) ={t0 = 1, . . . ,|ε(u)| : ε(u, t) < ε(u, t0) +τ(u) ≤ ε(u, t) +τ(u)}. Θ2(u, t) is the set of timepoints t0 for process u such that if process u

started processing att0, then the process would still be running at time ε(u, t).

We now show the complete model formulation, given by problem (P1). The model takes the form of a Flexible Discrete-Time Formulation; for a more in depth discussion of the model along with computational experiments comparing its performance to the continuous

(30)

time version, we refer the reader to the original work it appeared in [22]. max x,w,y X i∈I |Π(i)| X k=1 |ε(Π(i,k))| X t=1 f(i, k, t)x(i, k, t)−X u∈V |ε(u)| X t=1 c(u, t)y(u, t) (P1) s.t. x(i, k, t) +w(i, k, t)−w(i, k, t−1) − X t0_∈_Θ 1(i,k,t) x(i, k−1, t0) = α(i, k, t), ∀i∈I, k= 2, . . . ,|Π(i)|, (1) t= 2, . . . ,|ε(Π(i, k))| x(i,1, t) +w(i,1, t)−w(i,1, t−1) = α(i,1, t), ∀i∈I, t= 2, . . . ,|ε(Π(i,1))| (2) x(i, k,1) = 0, ∀i∈I, k= 1, . . . ,|Π(i)| (3) w(i, k,1) = α(i, k,1), ∀i∈I, k= 1, . . . ,|Π(i)| (4) X i∈I,k0₌₁_,...,_|_Π(_i₎_|_:Π(_i,k0₎₌_u x(i, k0, t) ≤ κ(u)y(u, t), ∀u∈V, t= 1, . . . ,|ε(u)| (5) X t0_∈_Θ 2(u,t) y(u, t0) ≤ ρ(u)−Z(u, t), ∀u∈V, t= 1, . . . ,|ε(u)| (6) x(i, k, t), w(i, k, t) ≥ 0, ∀i∈I, k= 1, . . . ,|Π(i)|, (7) t= 1, . . . ,|ε(Π(i, k))| y(u, t) ≥ 0, ∀u∈V, t= 1, . . . ,|ε(u)| (8) x, w, y integral, (9)

The constraints given by (1) and (2) above are flow conservation constraints on each node of the time layered graph. They ensure that at every point in time for each process in the path of each job (i.e. for every node in the time layered graph), every sample that is available at this point either waits at the current process or is processed. Note that for constraints (1) we have only a single arc leaving the vertex since we have flow constraints for each job i and therefore there is only one arc of A∗_L which may be used (due to path sequencing constraints). Constraints (3) ensure that at the first timepoint, no samples are processed, however note that this is without loss of generality as we may define a second timepoint with the same time as the first timepoint. Constraints (4) set the number of samples that are waiting at the beginning of the horizon based on any samples that arrive at the beginning of the horizon, and any samples that were waiting at the end of the previous horizon. Constraints (5) ensure that enough machines are allocated to meet the proposed schedule. Constraints (6) enforce that we do not allocate more machines than we have available. Constraints (7) - (9) enforce that our variables are non-negative, and integral.

(31)

starting process resources. This was done by summing over x(i, k, t) for each job i, each process Π(i, k) in the path of jobiand each timepoint t∈ε(Π(i, k)) and subtracting from the objective each time a processuis used at timet ∈ε(u). This was selected to incentivize the processing of samples even if it was not possible to finish processing them during the time horizonH to ensure that progress is made on finishing jobs. f(i, k, t) in (P1) is used to represent the per sample value of processing the k’th process in job i’s path at time

ε(Π(i, k), t) and c(u, t) is the per machine cost of starting process u at time ε(u, t). The specific choices off and c vary between the two studies presented in Chapters 3and 4, so we discuss them in these chapters respectively.

Note that (P1) has been presented elsewhere [22, 30] and in these works the time layered graphs were not explicitly constructed. However, time layered graphs were used implicitly for the development of (P1) in these works.

2.4

When to Reschedule

There are various methods that have been proposed for when to trigger reschedulings. “When-to” rescheduling policies can be categorized as fixed periodic, variable periodic, event-driven, and hybrid [35, 49]. Fixed periodic policies invoke rescheduling at equal time intervals, whereasvariable periodic policies reschedule not based on the time the last rescheduling was done, but instead based on the qualities of the system. For example, rescheduling may be triggered once the difference between the actual schedule and the planned schedule exceeds some allowed tolerance. Event-driven policies instead focus on the disruptive events considered by the model and rescheduling is performed whenever a disruptive event occurs. Furthermore,hybrid policies use periodic rescheduling in conjunc-tion with event-driven rescheduling when some key events occur, typically events which will cause a greater disruption to the schedule such as a machine breakdown or a rush order arrival [5,19]. For more information about process rescheduling, we refer the reader to [49] for a thorough review of the subject.

As mentioned previously in Chapter 1, there have been numerous studies conducted on rescheduling in a range of environments. Despite these efforts, a general agreement on how rescheduling frequency affects performance has not been conclusive in the literature. Some works suggest that both scheduling too frequently and not frequently enough result in decreased performance [15, 19]. On the other hand, other studies suggest that one should reschedule as frequently as possible [28,31,37], although relative benefits may drop off after some critical point [5, 34, 35]. Hozak and Hill discussed these differences in [18]. They identified some modelling choices that may help explain why the conclusions have

(32)

been mixed, such as how instability is modelled, the assumptions used for demands and productions, and not considering human factors. Irrespective of these differing conclusions, it is clear that the performance of different rescheduling frequencies will vary, and hence studying this tradeoff is of interest from a practical standpoint.

The study we conduct on when to reschedule focuses only on fixed periodic policies. Since the disturbances we consider are not highly disruptive to the plant operation, i.e. new jobs arriving will not make the current schedule infeasible, we do not expect to gain much by triggering immediate reschedules which dissuades us from using an event-driven or hybrid policy. Moreover, there does not seem to be more or less important times of the day to schedule, so using equally spaced timepoints appears to be reasonable. If more serious disruptions were considered, investigating a more complex rescheduling policy could be beneficial to account for the disruptions and is considered as possible future work.

2.5

Time Grids for Discrete Time Representations

Recall that discrete time representations refer to when a time grid (a set of timepoints) is given as input to the scheduling model dictating at what points in time the model may choose to make scheduling decisions. Moreover, there is a tradeoff between how many timepoints are included in the time grid, the CPU cost of solving the model, and the quality of the solution obtained by solving the model [22]. Therefore, the choice of time grid that is supplied to the model can greatly influence the performance characteristics of solving the problem.

The most common choice of time grid is to use a uniform discretization (UD) with some fixed timestep ∆ between points. In fact, until recently, all works on scheduling mul-tipurpose facilities using a discrete time representation did so using a uniform discrete time grid [44]. For uniform discretizations, the timestep may be adjusted to be smaller if more precision in the timepoints is needed, or larger if timepoint precision is less of an issue or CPU solving times are too large. However, the main drawback of this discretization scheme is that the granularity of the discretization is constant both over the scheduling horizon and among all processes in the facility. This can be wasteful if one knows beforehand that few or no timepoints are necessary during some interval of time during the scheduling horizon, or if it is known in advance that only a few scheduling decisions will be made for a certain process during the scheduling horizon. Conversely, if one wants to increase the granularity of the time grid during an interval of time, or allow a single process to have more scheduling decisions, then many more timepoints will be added to the time grid than

(33)

A solution to this problem is to consider non uniform discrete (NUD) time grids. NUD time grids assign a (possibly different) set of timepoints for each process such that schedul-ing decisions for a processpmay only occur at timepoints on the time grid of processp[44]. This generalization allows us to overcome the issues discussed previously by adjusting the granularity of the time grid for each process at various points throughout the scheduling horizon. By more carefully selecting where to include timepoints, one may obtain a better tradeoff between CPU time and solution quality than that obtained by using a uniform discretization [22, 44]. Velez and Maravelias [45] showed that using the multi-grid model with their choice of timepoints was guaranteed to produce the optimal solution obtained by using a sufficiently fine global uniform discretization. It has also been shown that using multiple time grids can be suitable for scheduling large scale applications [22, 46].

Figure 2.3 demonstrates the difference between uniform discretizations, non uniform discretizations using constant timesteps, and non uniform discretizations using arbitrary timepoints over a time horizon [0, H] where each x marks indicate the presence of a time-point.

However, guaranteeing that the optimal solution (solution obtained by using an arbi-trarily fine time grid) is not cutoff by using multiple time grids may still result in the use of many timepoints and therefore large problems. The non uniform discrete M (NUDM) discretization is one such discretization which does not guarantee that the returned solu-tion is optimal. The NUDM discretization uses the minimum of M and the processing time of a process as the timestep for each process’ time grid. This discretization aims to provide timepoints that are not too far apart for processes which have long processing times by selecting an appropriately sizedM, and to allow processes with short processing times to begin processing again immediately after finishing a previous run. For the same problem considered in this thesis, the NUD60 discretization (M = 60 minutes) was shown in [22] to have a better tradeoff between schedule performance and CPU solving time than the other uniform discretizations that were tested. Therefore, we will refer back to this discretization several times throughout Chapters 3 and 4. Nevertheless, using a NUDM

discretization may still suffer from the problem of having many extra timepoints where they are not needed, especially if the considered time horizon is long, or there are many processes with short processing times.

Despite the positive results surrounding using multiple discrete time grids, the pool of works using this method is still very shallow [3, 22, 33, 44, 45, 46]. As alluded to before, choosing a suitable discretization can depend on factors such as the properties of the facility and the length of the scheduling horizon. However, most of these works determine the discretization for their problem either experimentally or by using a time grid which ensures that the optimal solution is not cut off and fix this. The work of Boland et al.

(34)

∆ ∆ ∆ ∆

0 H

same step size ∆ for each processp

(a) A uniform discretization, each time grid is the same and timepoints are evenly spaced through-out. ∆1 ∆1 ∆1 ∆1 ∆2 ∆2 ∆2 ∆2 ∆2 ∆2 ∆2 ∆2 .. . ∆n ∆n 0 H 0 H 0 H

step size ∆1 for process p1

step size ∆2 for process p2

step size ∆n for process pn

(b) A non uniform discretization, each time grid is evenly spaced, however spacing varies between grids. .. . 0 H 0 H 0 H

arbitrary time grid for each process p

(c) A non uniform discretization, each time grid has arbitrarily spaced timepoints.

(35)

[3] is an exception which does not use a fixed discretization chosen beforehand. Boland et al. [3] employed an iterative method to refine their discretization for the continuous time service network design problem (CTSNDP). They begin by constructing a relaxation to CTSNDP using a carefully chosen time layered graph whose arcs are shorter than the actual travel times for their problem. After solving their relaxation, either the solution may be converted to a solution for CTSNDP, in which case the solution is optimal, or they identify at least one arc to lengthen in their relaxation and repeat this process. They were able to prove that their method terminates with the optimal solution obtained by using a continuous time representation and showed positive results using computational experiments. However, part of their proof of optimality for their method uses a fact which does not hold true in our setting. We attempted to modify their method and proof to fit our setting, but were unable to do so. Nonetheless, their method provided inspiration for the computational work presented in Chapter4 (even though there is no proof that it will result in the optimal schedule). This work aims to propose a new way of refining the time grids for scheduling problems iteratively, contributing to the lack of such methods using non uniform discrete time representations in the literature.

(36)

Chapter 3

Study on Rescheduling Frequency

In this chapter, we perform an investigation on the effects plant parameters play on de-termining when to reschedule operations. As discussed in Chapter 1 and section 2.4, understanding how often one should reschedule under various facility operational condi-tions has practical importance and has not been well studied. To study the performance of different rescheduling policies on a facility that receives new job orders throughout the day, we must compare the long term performance of the facility as short term performance differences may be negligible. To address this issue, we use the rolling horizon framework which we present in section 3.1. This framework is used to breakup a horizon that may be impractical to schedule over because of its length into several manageably sized sub-horizons that can be scheduled over in a reasonable amount of time. In section 3.2 we present the various rescheduling policies that were tested in our experiments. Section 3.3 details the various metrics which were used to evaluate a policy’s performance. In section 3.4we discuss the model parameters that were used for our experiments and the design of our experiments. Section 3.5 presents the results of the experiments and a discussion on the results, leading to some recommendations on choosing a suitable rescheduling policy based on the properties of the production environment. A summary of the chapter is given in section 3.6.

We want to note that the work in this chapter was submitted for publication. Z. Steven-son, R. Fukasawa, L. Ricardez-Sandoval, “Evaluating periodic rescheduling policies using a rolling horizon framework in an industrial-scale multipurpose plant”. This manuscript was co-authored by myself, and my supervisors, Dr. Fukasawa and Dr. Ricardez-Sandoval and was submitted to the Journal of Scheduling published by Springer on October 25, 2018.

(37)

3.1

Rolling Horizon Routine

A rolling horizon routine was used with the model (P1) presented in section2.3to simulate the operation of the facility over long periods of time (e.g. months). Decomposing the scheduling horizon into several smaller, contiguous time horizons is necessary as scheduling over the entire horizon at once would be computationally intractable. Furthermore, when scheduling operations in practice for a facility whose future arrivals are not known in advance, and over an indeterminate amount of time, the operator must implicitly use a rolling horizon strategy to schedule operations. The choice of how often to reschedule operations and how long the horizons should be will impact when new job arrivals are considered by the model, the computational cost of scheduling, and the quality of the actual implemented schedule. For these reasons, it is important to gain insight on the tradeoffs of using different policies so that an operator can make an informed decision when choosing how to reschedule operations in practice.

The routine can be thought of as partitioning the entire horizon that needs to be sched-uled into smaller sub-horizons and then solving each of these sub-horizons sequentially. Let Γ denote the time horizon that needs to be scheduled, and denote the i’th sub-horizon by Γi for some partitioning of Γ into n sub-horizons, see figure3.1. We start by setting i= 1

and the state of the facility as having an initial set of jobs arriving at time S and all machines empty. We then solve the model (P1) over the sub-horizon Γi to generate a

schedule Schedi. Denote the set of jobs that arrive at the facility during sub-horizon Γi

asαi. The state of the facility is updated using Schedi and αi to reflect the current jobs

and the current machine usage at the beginning of sub-horizon Γi+1. After updating the

state of the facility, we then check if there are other sub-horizons to schedule over. If there are, then we increment i and repeat the process. If we have scheduled over all of the sub-horizons, then we stop and concatenating (Sched1, . . ., Schedn) gives us a feasible

schedule for the entire horizon Γ. Note that this process involves creating and solving a model (P1) for each sub-horizon to obtain the corresponding schedule.

After generating a scheduleSchediand considering arrivalsαifor sub-horizon Γi, several

operations must be performed to update the state of the facility for the following sub-horizon. These operations are done to maintain consistency of the facility between horizons and we describe them next. Jobs which arrive during the sub-horizon Γi have their arrival

times pushed back to the start of sub-horizon Γi+1 since we may not consider these jobs

during the current horizon but want the model to be able to schedule them at the beginning of the next sub-horizon. Note that we push these samples back because we schedule each sub-horizon once using the information available at the beginning of the sub-horizon. Samples which arrived at the facility prior to sub-horizon Γi are handled according to

(38)

S

+

H

S

+

H

Γ

1

Γ

2

Γ

3

. . .

Γ

n

Figure 3.1: Above is the scheduling horizon before partitioning. Below is a partition of scheduling sub-horizons that we may actually solve.

the following rules. Consider a variable x(i0, k, t) > 0 which is scheduled during Γi. If

this variable corresponds to samples that are actively being processed at the end of Γi

(i.e. ε(Π(i0, k), t) +τ(Π(i0, k)) ∈ Γi+1), then a corresponding arrival (α(i0, k + 1, t0)) for

these samples is created in Γi+1 for the next process in their path, Π(i0, k+ 1), at time ε(Π(i0, k), t) +τ(Π(i0, k)) (e.g. when the samples will finish being processed by Π(i0, k)). Similarly, consider a variable w(i0, k, t) > 0 which is scheduled during Γi, such that t is

the last timepoint of process Π(i0, k). In this case, a corresponding arrival (α(i0, k, t0)) is created in Γi+1for the same process they were waiting for, Π(i0, k), at the beginning of Γi+1.

Note that these two cases cover all of the samples scheduled during Γi as each sample is

either being processed at the end of the horizon, or is waiting to be processed. Any process resources that are running at the end of Γi (i.e. y(u, t) > 0, ε(u, t) +τ(u) ∈ Γi+1), are

accounted for by adding y(u, t) to the Z(u, t0) variables in Γi+1 for all timepoints t0 ∈ε(u)

such that t0 < ε(u, t) +τ(u).

This procedure allows us to generate a schedule which spans Γ by solving smaller sub-problems when Γ is prohibitively large to schedule all at once. However, it is worth noting that even without considering new arrivals, this procedure is a heuristic with respect to scheduling over the entire horizon. Each sub-schedule Schedi may be optimal with respect

to its corresponding sub-horizon, but the concatenated schedule (Sched1, . . .,Schedn) will

not necessarily be optimal with respect to Γ due to the myopic nature of scheduling over each sub-horizon individually.

(39)

Table 3.1: Descriptions of rescheduling policies considered.

ID Description

4P

Schedule the current day’s operations at the beginning of every day and revise the remainder of the day’s

schedule 3 times during the day at equal intervals 2P

Schedule the current day’s operations at the beginning of every day, then revise the second half of the schedule

halfway through the day

S Schedule the current day’s operations at the beginning of every day

3D Schedule the next three days of plant operation at the beginning of every third day

5D Schedule the next five days of plant operation at the beginning of every fifth day

3.2

Rescheduling Policies

We now describe the rescheduling policies that were considered in this study. Recall that we consider only fixed periodic rescheduling policies during this study for the reasons discussed in section 2.4. Table 3.1 gives a summary of the rescheduling policies considered in this work.

As shown in Table 3.1, policies “4P”, and “2P”, which can be thought of as “4 Parts”, and “2 Parts”, both schedule operations more than once per day at equal intervals. For example, if we consider scheduling operations for twenty four hours per day with the “4P” policy, then we will first generate a schedule for the next twenty four hours at the beginning of the day. We will follow this schedule for the first six hours, and then a new schedule will be generated for the following eighteen hours of the day. We will then generate a schedule for the remaining twelve hours after twelve hours and similarly for the last six hours after eighteen hours. These rescheduling policies emulate the operation of a facility that is concerned with the short term, day to day operations and wishes to reschedule frequently based on new job arrivals. The reason we do these reschedulings is because any new jobs that arrive during the first six hours may not be scheduled at the beginning of the day as they have not yet arrived at the facility, however by rescheduling after six hours, we may generate a new schedule for the remainder of the day that considers these new arrivals. The “2P” policy uses a similar strategy, but only schedules operations twice, once at the start of the day and again halfway through the day.

(40)

The “S” policy, referred to as “Single”, generates a single schedule for the current day at the beginning of the day and will follow it, ignoring new job arrivals until a new schedule is generated at the beginning of the following day. This policy simulates a facility that is concerned with day to day operations but will not disrupt or modify the current schedule. The “3D”, and “5D” policies which can be thought of as “3 Days”, and “5 Days”, schedule operations for the next three and five days, respectively. During this time, these policies behave like the “S” policy, ignoring new job arrivals until the next time operations are rescheduled. For this reason, in the worst case scenario when scheduling with the “5D” policy, the model may not be aware of a job which arrives at the facility until five days after it initially arrived. These policies simulate a facility that is more concerned with schedule stability, rather than reacting quickly based on the newest job arrivals.

These period lengths were chosen for testing so that we may test a wide range of policies and also policies which may be typically used in practice. For instance, the “5D” policy which corresponds to scheduling on a weekly basis, and the “S” policy which corresponds to scheduling once per day are both natural candidates for rescheduling. The “4P” policy was chosen to obtain information about how rescheduling very frequently would perform and the “2P” and “3D” policies were chosen to test policies which fell between the “S” policy and the other two extremes.

These policies may also be related to the rolling horizon framework discussed in section 3.1. The “5D” policy corresponds to using sub-horizon lengths of 120 hours for each Γi.

Similarly, the “3D” and “S” policies correspond to sub-horizon lengths of 72 hours and 24 hours respectively. The “2P” and “4P” policies differ however, as discussed above, these policies schedule the remainder of the current day at equal intervals. Therefore, the “4P” policy corresponds to using sub-horizons of length 24, 18, 12, and 6 hours to schedule each day. The “2P” policy operates similarly with sub-horizons of length 24 hours and 12 hours each day.

3.3

Performance Metrics

To compare the performance of the various policies considered in this study, we use job completion, average job makespan, and proportion of jobs on time. We begin by presenting the formulation of these metrics, before discussing them below.

Letarr(i) be the arrival time of job i, f in(i) be the time that the last sample of job i

finishes processing,jobs(t) = {i:arr(i)≤t}be the set of jobs that arrive before or at time

(41)

Then job completion at timet, average job makespan at time t, and proportion of jobs on time at timet with lead times of d minutes were defined as follows:

completion(t) = P i∈jobs(t)comp(i, t) |jobs(t)| (3.1) avg makespan(t) = P

i∈jobs(t):comp(i,t)=1f in(i)−arr(i)

|{i∈jobs(t) :comp(i, t) = 1}| (3.2)

on time(d, t) = |{i∈jobs(t) :comp(i, t) = 1, f in(i)−arr(i)≤d}|

|jobs(t)| (3.3)

For comparing policies using these metrics, we use the value measured at the end of the final scheduling horizon. Since we do not require that all jobs finish processing during the corresponding scheduling horizon, for measuring average job makespan we consider only those jobs that have finished processing at the end of the time horizon. Job completion at time t was defined as the proportion of jobs that finished processing all samples out of all the jobs that have arrived at the facility between the beginning of the first horizon and t. Makespan was taken to be the difference in minutes between when the final sample finished processing for a given job and when that job initially arrived at the plant, and was only considered for jobs that have finished processing. Proportion of jobs on time with respect to some lead time d was defined as the number of jobs that finished within the lead time

d out of all jobs that had arrived before time t.

3.4

Design of Experiments

In this section we go over the details relating to how the experiments were carried out for this study. We begin by describing the facility that was considered in more detail. As discussed in section 2.3, the plant used for our experiments is based on a multipurpose industrial-scale analytical services facility. Due to confidentiality agreements, we cannot disclose detailed data. The facility is rather large with nearly 200 distinct processes, each of which may have multiple identical machines. During a thirty day timespan, the facility received jobs comprising of over 150 unique paths, using approximately 100 unique processes. Over this timespan, they received several hundred jobs comprising of more than 20,000 samples. This large volume of jobs leads to large formulations when using long horizon lengths in the rolling horizon routine described in section 3.1. The capacities and processing times of the individual processes vary greatly. The largest capacity among all

(42)

processes is over 1,300 times the size of the smallest capacity, similarly the processing times of the processes vary from a few minutes to several days. In AppendixA, we present normalized values for capacity, processing time, and number of resources for each process. These qualities differentiate the plant studied from the simpler and smaller facilities found in other rescheduling studies [15,37, 48]. Although our experiments use a plant based on the facility of our industrial partner, the model defined in Section2.3is a general job shop formulation that may be used for other industrial applications that require a multipurpose plant. Therefore, the same methodology and experiments may be performed using other applications of multipurpose plants.

The following choices for parameter values for the model (P1) were used throughout the experiments. The time grid given to the model, ε, was chosen to be the NUD60 discretization used in [22] as it was shown to have a good tradeoff between solving time and solution quality for this problem, compared to the other discretizations tested. Re-call that for the NUD60 time discretization, each process u has an associated timestep ∆(u) = min{60, τ(u)}and the timepoints for process uare ε(u) = {S, S+ ∆(u), . . . , S+ (bH/∆(u)c)∆(u), S+H}. This choice of timepoints allows processes which have short pro-cessing times to have fine granularity, and also allows us to be flexible with the scheduling of long processes by including a timepoint each hour.

We will now discuss the choice of objective function used for our experiments. We compare the performance of the various policies based on job throughput, average job makespan, and proportion of jobs on time, over the scheduling horizon as described in section 3.3. However, we do not optimize these metrics directly because of the inherent difficulties associated both with optimizing multiple and conflicting objectives, and the length of some job paths being longer than the lengths of the subhorizons used. For instance, suppose job throughput was our main objective and hence the objective function only provided incentive to processing the last process in each job’s path. If we consider a job whose path length is longer than the length of the subhorizon, then the model would have no incentive for processing the job through earlier processes in its path and potentially no progress would be made on the job. Instead of optimizing these metrics directly, we chose the values for the objective function parameters of model (P1) to be the following:

f(i, k, t) = 1 + |ε_|(Π(_ε_(Π(i,k_i,k))₎₎|−_|t k P|Π(i)| m=1 m , ∀i∈I, k= 1, . . . ,|Π(i)|, t= 1, . . . ,|ε(Π(i, k))| c(u, t) = 0.001, ∀u∈V, t = 1, . . . ,|ε(u)|

(43)

the horizon. The rationale behind these decisions was that, by prioritizing samples that were closer to being finished we would push currently open jobs toward completion before starting new jobs. Furthermore, if a schedule could be shifted in time we would prefer it be executed as early as possible so that resources may be left unused to accommodate for possible job arrivals in the future. This was accomplished by assigning more weight to processing samples earlier in the horizon. We also assign a cost for using resources so that optimal schedules will allocate process resources if and only if the schedule assigns samples to be run on those resources. These decisions were done in an attempt to obtain attractive solutions (measured in terms of job throughput, job makespan, and proportion of jobs on time), in the rolling horizon framew

A computational study of practical issues arising in short-term scheduling of a multipurpose facility