Addressing storage time restrictions in the S-graph scheduling framework

Abstract

Storage planning and utilization are among the most important considerations of practical batch process scheduling. Modeling the available storage options appropriately can be crucial in order to find practically applicable solutions with the best objective value. In general, there are two main limitations on storage: capacity and time. This paper focuses on the latter and investigates different techniques to tackle limited storage time within the S-graph framework. The S-graph framework is a collection of combinatorial algorithms and a directed graph based model that has been introduced three decades ago and has been under development ever since. In this work, several options for addressing storage time limitations within the framework were implemented and tested for efficiency. The empirical results over a huge number of tests have unequivocally favored one of the approaches, which will be applied in later developments.

1 Introduction and literature review

In real life scheduling problems different rules may be present regarding the storage of intermediate materials between consecutive tasks. Constraints can be concerned with the capacity and the time limit of the storage operation. For capacity, we can distinguish three main policies, unlimited- (UIS), finite- (FIS) and no intermediate storage (NIS) policy. Similarly, there are three common policies for limiting the time the intermediate material spends in storage, unlimited- (UW), limited- (LW) and zero-wait (ZW) policy.

Limited-wait storage policy often occurs in industry because of some time-sensitive physical or chemical properties of materials, e.g. temperature. This duration is usually specific to the material, i.e., different materials in the facility may have different limits. From the mathematical point of view, the starting time of the second task cannot be bigger than the completion time of the first task plus the allowed time limit. The ZW policy (or no-wait policy) is a specific case of the limited-wait strategy where the time limit is zero. In this case, the intermediates have to be processed in the next task without any delay. The completion time of the first task must be equal to the starting time of the second task. In the case of UW policy, there is no upper bound on the starting time of the receiving task for an intermediate posed by the completion time of the producing one.

Similarly to storage time limits, the storage capacity in the facility may differ for each intermediate material in the production. Note that if batch sizes are fixed a priori, and each intermediate is generated only once in the production, FIS policy reverts to either UIS or NIS based on the capacity of the storage. In some situations materials may also share the same storage unit (CIS, common intermediate storage policy). This option often raises additional challenges in planning such as appropriate cleaning.

In this paper we focus on the combination of NIS/UIS and UW/LW storage policies.

The first scheduling problems with no-wait constraints were published in the 70’s, for example, Callahan (1971) presented a steel industry problem, and Salvador (1973) described an algorithm for a nylon polymerization flow. A lot of research papers have been published since then. Hall and Sriskandarajah (1996) and Allahverdi (2016) provided review papers about shop scheduling problems (flow shop, job shop, open shop) with no-wait constraints. These two reviews covered more than 400 publications which appeared between 1970 and 2016.

While shop scheduling and various aspects of the planning of batch processes have already been investigated for a couple of decades, the scheduling of industrial batch processes gained heightened interest in the 90’s among engineers and optimization experts. Since then, researchers have presented numerous methods to solve problems (Méndez et al. 2006; Hegyháti and Friedler 2010; Allahverdi et al. 2018). Most papers proposed a Mixed Integer Linear Programming (MILP) model of the scheduling problem and solved it with a general-purpose solver like CPLEX. The main advantages of these approaches are their flexibility and extensibility but they also have disadvantages. Shaik and Floudas (2009) showed that the developed approaches may lead to suboptimal solutions, moreover, Ferrer-Nadal et al. (2008) and Hegyháti et al. (2009) reported that even infeasible schedules can be reported as optimal. Another group of solution methods is based on directed graphs and specialized branch-and-bound algorithms. The first graph-based approach ways presented by Balas (1969) who showed a backtracking algorithm using disjunctive graphs. Sanmartí et al. (2002) published the S-graph framework and D’Ariano et al. (2007) showed a similar alternative graph and mathematical methodology. A third notable direction in batch process scheduling is based on the state space enumeration of the production facility by either Linear Priced Timed Automata (Schoppmeyer et al. 2012) or Timed Place Petri Nets (Ghaeli et al. 2005). Using metaheuristics to find a good solution in a reliable time is a common approach nowadays because of the NP-hard nature of batch process scheduling. Some notable contributions of this sort involve genetic programming (Nguyen et al. 2019; Park et al. 2018), set partitioning (Grenouilleau et al. 2019) or ant colony optimization (Zhang and Wong 2018).

Lots of batch plants do not allow intermediate storage, nevertheless, problems with NIS and mixed wait policies have received less attention than those with UIS/UW. There are some papers containing MILP models (Jung et al. 1994; Liu and Karimi 2008; Gicquel et al. 2012) but most of the publications use heuristics to solve problems featuring ZW or LW policies. Moon et al. (1996) presented a MILP model for multiproduct batch plants with ZW policy using a heuristic preprocessing step to solve it. Condotta and Shakhlevich (2012) proposed a tabu search based algorithm to solve two-stage job shop problems where a single machine is available for each job and has a certain time interval between the two stages. An et al. (2016) examined a two-machine flow shop scheduling problem with LW policy and developed a B&B algorithm which uses heuristics to accelerate the search. Zhou et al. (2018) showed a swarm optimization based algorithm to solve a battery production plant where there is a LW policy before the formation process.

Limited-wait storage policy often appears in case studies of specific problem classes, which made it necessary to extend the capabilities of the S-graph framework in this direction, too. The first proposed method relied on arcs with interval weights (Hegyháti et al. 2011) and a modified feasibility function. There are, however, several other ways to address this feature, which were also briefly investigated (Hegyháti 2015).

The goal of this paper is twofold. First, it aims to provide a comprehensive review and description of approaches that are available to tackle this task, either published or unpublished. Secondly, it provides the results of an extensive empirical comparison to reveal the technique that proves to be the most efficient in practice. The approaches are expatiated on scheduling problems whose production constraints adhere to Flexible Job Shop rules, which are often referred to as Multipurpose Recipes in the chemical batch process scheduling literature. The objective is the minimization of makespan, processing steps are non-preemtive, and any combination of UIS/NIS and UW/LW policies may apply to each intermediate material. The empirical tests were carried out on this specific class of scheduling problems, however, it has to be noted, that the the presented approaches are not limited by these constraints, and they may be applied for much wider classes of scheduling problems, that the S-graph framework can address otherwise.

2 Motivational example

Limitations on the storage time can have significant effect on the objective function or, in some cases, even feasibility. In this section, a simple motivational example is presented to highlight this effect. The recipe for the example is shown in Fig. 1 in the form of a block diagram. The problem features three products, A, B, and C, each having a sequential production recipe with 3, 2, and 1 production steps, respectively. These steps can be carried out with 3 units and only a single unit is suitable for any task. It is also assumed that each intermediate can have dedicated storage units with sufficiently large capacity as the goal of this example is to focus on time limitations only.

Fig. 1

Motivational example

From the optimization point of view, the most relaxed case for storage time is the UW policy, thus, the optimal UW makespan provides a lower bound on the makespan for cases with more restricting policies. The UW optimal schedule is shown in Fig. 2 with the makespan of 13 h.

Fig. 2

Optimal schedule for the motivational example in case of UW policy

This schedule requires the intermediates in the production of A to be stored for 2 and 3 h, so this schedule is definitely not feasible if the storage time for all intermediates is limited to 2 h. Another schedule with different sequencing decision might still provide the same 13 h optimum but for this problem that is not the case. In the LW optimal schedule the sequencing decisions remain the same and makespan is increased to 14 h by delaying the tasks i1, i2 and i6 by 1 h, as shown in Fig. 3.

Fig. 3

Optimal schedule for the motivational example in case of LW policy with 2 h of maximal storage time

As UW is the most relaxed policy, ZW is the other end of the spectrum with being the most restrictive policy on storage timing. This also means that the optimal makespan with ZW policy provides an upper bound on the optimal makespan of 17 h as shown in Fig. 4. Note, that in this case, the sequencing decisions are also altered as the sequencing of the previous cases would result in a worse makespan of 18 h with ZW policy.

Fig. 4

Optimal schedule for the motivational example in case of ZW policy

This small example showed that time limitation on storage operations can affect the objective. As it will be shown in Sect. 6, it can also influence the computational needs of approaches to find the optimal solution, which was observed for MILP formulations for the cyclic scheduling of robotic cells (Papp et al. 2018).

3 Problem definition

Limited-wait storage policy can be present in a scheduling problem regardless of many other features of the problem, e.g., the objective function. In this paper, the proposed approaches are introduced (Sect. 5) and compared (Sect. 6) via makespan minimization problems. As the methods of the S-graph framework for maximizing throughput (Majozi and Friedler 2006; Holczinger et al. 2007) and other objectives (Holczinger et al. 2012, 2019) rely on makespan minimization as a subroutine, the approaches can be used in those methods without any or just minor alterations. The aim of this paper is to illustrate the approaches in their simplest form, i.e., any parameters which are independent from the limit on the storage time or constraint are disregarded. The inclusion of such aspects would only make the presentation in Sect. 5 more obscure without adding any scientific value.

In the investigated scheduling problem class the makespan has to be minimized for a given product quantity with the available equipment units of the facility. All of these units are assumed to be operated in batch mode and preemption is not allowed during production steps. The required production quantity is given as a number of batches for each product in consideration, i.e., batch sizes of each product are fixed a-priori. The processing steps of a product can have any non-cyclic dependency network and they are referred to as tasks in the rest of the paper. These networks are assumed to be disjoint and have a single task that produces the corresponding final product. Several units may be capable to carry out a task with possibly different processing times, however, task assignment has to be unique, i.e., in the final schedule a task has to be executed on exactly one unit.

Each dependency between tasks is associated with an intermediate material, which has to be stored until the consecutive task in the production is ready to be executed. Storage time may be limited and a dedicated storage unit is either available or not. In the latter case, the intermediate may be stored in the unit that is assigned to the task producing it. This storage in the processing unit contributes to the storage time of the intermediate and keeps the unit unavailable for other tasks. If a task produces several intermediates required by different tasks, these intermediates may be transferred to the assigned units of these subsequent tasks at different times. Storing of input intermediates of a task in the processing unit before executing it is not allowed and shared storage units are not considered. Products are assumed to be shipped as soon as they are produced, i.e., their storage is not a concern in the investigated problem class.

Naturally, feasible schedules have to adhere to the timing of production dependencies and a unit may not be assigned to more than one task at a time. The only timing parameter considered is the processing time, that is given for any suitable task-unit pair. Other timing related parameters, such as cleaning-, transfer-, changeover- and arrival times, due dates, etc. have no relation to how the presented approaches tackle storage time limitations. Addressing them can be done easily and independently in the S-graph framework, as presented in several papers in the literature (Adonyi et al. 2008; Hegyháti 2015; Holczinger et al. 2019), thus, they are disregarded in the rest of the paper.

3.1 Formal problem data

The input data is formally given by the following sets and parameters. In order to keep the notation as simple as possible, it is assumed—without the loss of generality—that only a single batch is to be produced from each product. This can be achieved simply by having sufficient number of copies of a product.¹ Moreover, several redundant set definitions are derived to further simplify later notations.

${{\mathcal {P}}}$:

is a finite set of products

${{\mathcal {I}}}_p$:

is the finite set of tasks needed to be carried out to produce a single batch of product $p\in {{\mathcal {P}}}$, where ${{\mathcal {I}}}_p \cap {{\mathcal {I}}}_{p'} = \emptyset$ if $p\ne p'$

${{\mathcal {I}}}$:

$=\bigcup _{p\in {{\mathcal {P}}}}{{\mathcal {I}}}_p$ is a derived notation for the set of all tasks, of all products

${{\mathcal {I}}}^-_i$:

$\subset {{\mathcal {I}}}_p$ is the finite set of tasks that are a prerequisite of task $i\in {{\mathcal {I}}}_p$, $p\in {{\mathcal {P}}}$

${{\mathcal {I}}}^+_i$:

$=\{i^+\in {{\mathcal {I}}}_p \mid i \in {{\mathcal {I}}}^-_{i^+}\}$ is a derived notation for the finite set of tasks that depend on task $i\in {{\mathcal {I}}}_p$, $p\in {{\mathcal {P}}}$

$i^*_p$:

$\in {{\mathcal {I}}}_p$ is the task that produces the final product, the only task $i\in I_p$ for which ${{\mathcal {I}}}^+_i = \emptyset$

${{\mathcal {S}}}$:

$=\{(i,i^+) \mid i\in {{\mathcal {I}}}^-_{i^+}$,$i^+\in {{\mathcal {I}}}\}$ is a derived notation used for the finite set of intermediates that may need storage, represented by the pair of tasks that produce and consume it

${{\mathcal {S}}}^{LW}$:

$\subseteq {{\mathcal {S}}}$ is the set of intermediates that have limitations on their storage time

$st^{max}_{i,i^+}$:

$\in [0, \infty [$ is the upper time limit on storing the intermediate between the tasks $(i,i^+)\in {{\mathcal {S}}}^{LW}$

${{\mathcal {S}}}^{UW}$:

$= {{\mathcal {S}}}\setminus {{\mathcal {S}}}^{LW}$ is a derived notation for the set of intermediates that have no limitation on their storage time

${{\mathcal {S}}}^ {UIS}$:

$\subseteq {{\mathcal {S}}}$ is the set of intermediates that have dedicated storage unit

${{\mathcal {S}}}^{NIS}$:

$= {{\mathcal {S}}}\setminus {{\mathcal {S}}}^{UIS}$ is a derived notation for the set of intermediates that have no dedicated storage unit

${{\mathcal {J}}}$:

is the finite set of processing units available in the facility

${{\mathcal {J}}}_i$:

is the non-empty finite set of units that can carry out the task $i\in {{\mathcal {I}}}$

${{\mathcal {I}}}_j$:

$=\{i \in {{\mathcal {I}}}\mid j\in {{\mathcal {J}}}_i\}$ is a derived notation for the finite set of tasks that can be carried out by the unit $j\in {{\mathcal {J}}}$

$pt_{i,j}$:

$\in [0, \infty [$ is the processing time of task $i\in {{\mathcal {I}}}$ in unit $j\in {{\mathcal {J}}}_i$

To help in understanding the notations, an illustrative example is presented. Figure 5 shows the recipe of this example, which is a modified version of the motivational example of Sect. 2. It also contains 3 products (A, B, C), and products A and B has the same tasks like in the motivation example but task i1 can be performed by 2 processing units in 4 h. Furthermore, the recipe of product C has 4 tasks and it is not sequential. Task i6 generates 2 intermediates and task i9 has 2 prerequisite tasks (i7, i8). Moreover, task i6 can be performed by two units (j1, j2) and the processing time of task i6 is 8 and 9 h using j1 and j2, respectively. Figure 5 does not contain the storage information of the system. There are different storage policies for production of different products. The policies are NIS/LW with 2 h limit, NIS/ZW, and UIS/UW, for the production of A, B and C, respectively. The formal problem data of this illustrative example is summarized in Table 1.

Fig. 5

Illustrative example

Table 1 Formal description of the illustrative example shown in Fig. 5

3.2 Formal solution

A solution to the scheduling problem of this class can be given as a mapping from ${{\mathcal {I}}}$ to triples: $i \mapsto (J_i, T^{s}_i,T^{r}_i)$, where

$J_i\in {{\mathcal {J}}}_i$:

is the unit assigned to task i

$T^{s}_i$:

is the time when $J_i$ receives all input intermediates (if any), and starts executing the task i

$T^{r}_i$:

is the time when the last output material of i is removed from $J_i$, and it is released for executing other tasks

For simpler notation below, $T^{f}_i = T^{s}_i + pt_{i,J_i}$ is introduced as the finishing time of task i in $J_i$.

With these notations, the requirements of a feasible solution can be expressed as:

• 1. A unit can only be released from a task after the task is finished, i.e., for all $i\in {{\mathcal {I}}}$: $T^{r}_i \ge T^{f}_i$

• 2. A unit can only work on one task at any given time, i.e., for all $i,i' \in {{\mathcal {I}}}$, $i\ne i'$ and $J_i = J_{i'}$: $\left]T^{s}_i,T^{r}_i\right[ \cap \left]T^{s}_{i'},T^{r}_{i'}\right[ = \emptyset$

• 3. Production dependencies must be adhered to, i.e., for all $(i,i^+)\in {{\mathcal {S}}}$: $T^{s}_{i^+} \ge T^{f}_i$

• 4. Intermediate materials without dedicated units must be stored in the processing units, i.e, for all $(i,i^+)\in {{\mathcal {S}}}^{NIS}$: $T^{r}_i \ge T^{s}_{i^+}$

• 5. Intermediate materials with limited storage time must not be stored longer than allowed, i.e., for all $(i,i^+)\in {{\mathcal {S}}}^{LW}$: $T^{s}_{i^+} \le T^{f}_i + st^{max}_{i,i^+}$

The goal of optimization is to provide a mapping $i \mapsto (J_i, T^{s}_i,T^{r}_i)$ in such a way that it satisfies the conditions above and $\max _{i\in {{\mathcal {I}}}}T^{r}_{i}$ is minimal.

Note, that these conditions only separate the feasible schedules from the infeasible ones. Depending on the objective function, however, some set of schedules can be excluded a priori if the remaining set of solutions is guaranteed to have at least one optimal.

As an example, by intuition, there is no point in keeping a unit occupied after all of the produced intermediates are transferred. Formally, $T^{r}_i$ should be at most $\max _{(i,i^+)\in {{\mathcal {S}}}} T^{s}_{i^+}$, and for the final tasks $T^{r}_{i^*_p} = T^{f}_{i^*_p}$. If the objective function, makespan minimization in this case, does not benefit from such idle behavior of the units, then schedules with such idleness can be correctly disregarded from the search space.

Similarly, if there is a dedicated storage to store an intermediate, storing in the processing unit is unreasonable. Even if the unit is free in the optimal schedule, the search space can be reduced by excluding such solutions and finding the one, where the intermediate was immediately transferred to the storage and the unit released. Note, that for example, having a cost for storage units, or the introduction of transfer times would make this reduction incorrect. However, the features of the proposed problem class ensure that this reduction is safe.

Following these observations it is clear that after these reductions the solutions could be reformulated as a mapping $i \mapsto (J_i, T^{s}_i)$ and similarly to $T^{f}_i$, $T^{r}_i$ becomes only a derived value:

$$\begin{aligned} T^{r}_i = \left\{ \begin{array}{ll} \max \limits _{(i,i^+)\in {{\mathcal {S}}}^{NIS} } T^{s}_{i^+} &{}\quad \text{ if there is at least one } i^+\in {{\mathcal {I}}}^+_i \text{ so that } (i,i^+)\in {{\mathcal {S}}}^{NIS} \\ T^{f}_{i} &{}\quad \text{ otherwise } \end{array}\right. \end{aligned}$$

4 Brief introduction to the S-graph framework

The S-graph framework was introduced by Sanmartí et al. (2002) to solve makespan minimization problems for batch processes with fixed batch sizes, precedential recipe and UIS or NIS storage policy. The proposed approach relies on a directed graph model, the S-graph, and the algorithms that perform various operations on such graphs or a set of such graphs.

In the S-graph model of a problem, called recipe-graph, a node is assigned to each task and to each product, later referred to as task-nodes and product-nodes, respectively. Directed arcs express a) the dependencies between tasks and b) the connection between the products and the tasks that produce them. Such a directed arc is called recipe-arc and has a weight that is the minimal possible processing time of the task it sources from. An example is shown in Fig. 6.

Fig. 6

Example: recipe-graph

In this example, 3 products, A, B and C are produced. The production of A requires execution of three consecutive tasks, task i1, i2 and i3, respectively. Task $i_1$ can be performed by either unit $j_1$ or $j_2$, $i_2$ can be performed only by unit $j_3$ and there are two units ($j_2$, $j_4$) available for task $i_3$. The production of B contains two consecutive tasks and product C has parallel tasks in the recipe.

Note, that the recipe-graph itself does not encode all the information of the scheduling problem, e.g., the processing times for different assignments, but the set of suitable units is usually indicated in the recipe-graph below the name of the task. For example the processing time of task $i_1$ of the example in Fig. 6 is 3 but it is not visible whether it belongs to unit $j_1$, $j_2$ or both of them.

The formal definition of a recipe-graph is a triple, $(N,A_1,\emptyset )$, where

N:

$= N^T \cup N^P$ is the set of nodes, where

• $N^T = \{n^T_i \mid i\in {{\mathcal {I}}}\}$

• $N^P = \{n^P_{p} \mid p\in {{\mathcal {P}}}\}$

• $A_1 = \{(n^T_i,n^T_{i^+},\min _{j \in {{\mathcal {J}}}_i}pt_{i,j}) \mid (i,i^+)\in {{\mathcal {S}}}\} \cup \{(n^T_{i^*_p},n^P_{p},\min _{j \in {{\mathcal {J}}}_{i^*_p}}pt_{{i^*_p},j}) \mid p\in {{\mathcal {P}}}\}$

is the set of recipe-arcs

In the graph model, each node inherently relates to the timing of an event. For task nodes, it is the starting time of the task, and for the product nodes it is the time the product is ready and shipped. In other words, $n^T_i$ relates to $T^s_i$, and $n^P_{p}$ to $T^r_{i^*_p}$. Moreover, the arcs in $A_1$ express some of the conditions on the timing of these events that are necessary for a feasible solution as discussed in the Sect. 3.

The published algorithms of the S-graph framework use the problem data to construct this recipe-graph and perform various operations to find the optimal schedule. The decisions made during this process are modeled in the graph by adding additional directed arcs, called schedule-arcs, and changing the weights of recipe-arcs if a unit assignment is made. The S-graph representing one schedule of the problem in Fig. 6 is shown in Fig. 7 where unit $j_2$ has changeover time (2 units) between tasks $i_3$ and $i_8$. This graph is called a schedule-graph and its mathematical model is the $(N,A_1,A_2)$ triplet, where $A_2$ represents the schedule-arcs which are denoted by blue arcs.

Fig. 7

A schedule-graph of recipe-graph in Fig. 6

The details about how the algorithms explore the possible schedules are presented in Sanmartí et al. (2002). Just like the recipe-arcs, the schedule-arcs also express timing conditions on the events associated with the task- and product-nodes. The rules for inserting a schedule-arc is discussed in detail in Sect. 5.

In a solution, the longest path leading to a node determines the timing of its associated event. In Fig. 8 this is indicated by bold, italic numbers for each node, and the longest path is shown with bold arcs for product-node B. Based on these, the Gantt chart of the solution can be plotted easily as shown in Fig. 9.

Fig. 8

The longest path of schedule-graph in Fig. 7

Fig. 9

The Gantt diagram of solution in Fig. 8

The S-graph model detects infeasible schedules by finding a cycle in the graph.

5 Modeling approaches for limited storage time

As mentioned in Sect. 4, the arcs express timing differences and the longest path to a vertex is the timing of the associated event (starting of a task for a task-node, or shipping of a (by)product for a product-node). There are a few branching techniques for different problem classes published in the S-graph framework (Sanmartí et al. 2002; Adonyi et al. 2007; Ősz and Hegyháti 2018), but all of them rely on expressing scheduling decisions via the schedule-arcs. Regardless of the branching technique, the insertion of schedule-arcs is triggered by making the decision, that task i will be carried out before task $i'$ in the same unit $J_i=J_{i'}$.

This decision immediately implies that $T^{s}_{i'}$ must be at least $T^{f}_{i}=T^{s}_{i}+pt_{i,J_i}$ to satisfy rule 2 of a feasible solution. This can easily be expressed by an arc leading from $n^T_i$ to $n^T_{i'}$ with the weight of $pt_{i,J_i}$. This type of arc is often referred to as an UIS arc as it is enough to express necessary conditions (rule 1 and 2) if i is the final task or all the outputs of task i are materials with dedicated storage since that implies $T^r_i=T^f_i$.

Task i, however, may have several outputs without storage, i.e, $\{ i^+ \in {{\mathcal {I}}}^+_i \mid (i,i^+)\in {{\mathcal {S}}}^{NIS} \} \ne \emptyset$. For each of these tasks, $i^+$, their execution must start before $J_i=J_{i'}$ can be released from task i and starts working on $i'$. In other words, $T^{s}_{i'} \ge T^{r}_{i} \ge T^s_{i^+}$ for all $i^+ \in {{\mathcal {I}}}^+_i$, $(i,i^+)\in {{\mathcal {S}}}^{NIS}$. This can be expressed by several 0-weighted arcs leading from $n^T_{i^+}$ to $n^T_{i'}$, which are often called NIS arcs.

Note, that for most of the branching algorithms the unit assignment decision on a task is made together with a sequencing decision. The decision to assign unit $J_i$ to i is modeled by updating all recipe-arcs starting from i to have the weight of $pt_{i,J_i}$ instead of $\min _{j \in {{\mathcal {J}}}_i}pt_{i,j}$.

Since there is a recipe-arc leading from $n^T_i$ to $n^T_{i^+}$ with the weight of $pt_{i,J_i}$, the UIS arc is rendered redundant if at least one NIS arc is inserted. Regardless, an illustration is given in Fig. 10, where 2 of the 3 intermediates produced by $i_5$ do not have a storage (inputs of tasks $i_7$ and $i_8$), and the unit $j_2$ will perform task $i_{12}$ later than $i_5$. Since $pt_{i_5,j_2}=5$, if there is a path (not including $i_5$) to $i_7$ or $i_8$, that is at least 5 units longer than the one leading to $i_5$ (in the example it is 9 units longer to $i_7$), the 0 weighted NIS arc from $n^T_{i_7}$ or $n^T_{i_8}$ will express a stronger lower limit on $T^{s}_{i_{12}}$.

Fig. 10

Redundant UIS arc

These arcs can sufficiently express requirements 1-4 of a feasible solution from Sect. 3. Rule 5 requires, that $T^{s}_{i^+} \le T^{f}_i + st^{max}_{i,i^+}$ for all $(i,i^+)\in {{\mathcal {S}}}^{LW}$. In each branching step it has to be checked, whether such a constraint is violated or not. For this purpose, several alternative approaches are available that will be discussed in the following sections.

5.1 Negatively weighted LW arcs

$T^{s}_{i^+} \le T^{f}_i + st^{max}_{i,i^+}$ can be reformulated as $T^{f}_{i} \ge T^{s}_{i^+} - st^{max}_{i,i^+}$ and by using $T^f_i=T^s_i+pt_{i,J_i}$:

$$\begin{aligned} T^s_i \ge T^s_{i^+}-st^{max}_{i,i^+}-pt_{i,J_i} \end{aligned}$$

This constraint can be expressed by adding an arc from $n^T_{i^+}$ to $n^T_i$ with the negative weight of $-st^{max}_{i,i^+}-pt_{i,J_i}$. This type of arcs will be referred to as LW arcs. Since $J_i$ is not known in the beginning, instead of $pt_{i,J_i}$, $\max _{j\in {{\mathcal {J}}}_i} pt_{i,j}$ is used until the selection is made. The branching functions do not need any further alterations. The bounding function, however, needs adjustments. In the S-graph framework, the bounding function serves two purposes: giving a lower bound on the makespan of the solutions included in that subproblem and detecting infeasibilities. The default and most often used bounding function is the longest path algorithm, which in the original case also reports infeasibility by finding directed cycles. By introducing the aforementioned LW arcs, even the recipe-graph, the root of the B&B tree also has cycles. The bounding function has to be altered not to report these cycles and still provide the longest path in the graph.

Similarly to the original case, a cycle with positive length still means infeasibility and has to be reported. A cycle with negative total weight is acceptable, does not influence the longest path and need not to be reported. Cycles with 0 total length can be twofold: if it consists of NIS arcs, it indicates an infeasibility called cross-transfer (Hegyháti et al. 2009; Ferrer-Nadal et al. 2008), otherwise if it has LW arcs in it, it only indicates zero waiting for intermediates.

Although the longest path in this graph can still be found efficiently, in the implementation, the longest paths between vertices of the S-graphs are cached in a difference bound matrix (Dill 1990). The DBM is a $|N|\times |N|$ matrix, where the kth cell in the lth row contains the longest path from the lth vertex to the kth. This matrix provides a constant time access to any longest path and can easily be updated if a new assignment or sequencing decision is made.

This approach will be referred to as the NWA approach later.

5.2 Simple LP model

Another approach is to completely replace the bounding procedure with an LP model, which expresses the constraints of the recipe and the scheduling decisions made so far. In this LP model, there would be $|{{\mathcal {I}}}|+|{{\mathcal {P}}}|+1$ non-negative continuous variables, one for the starting time of each task, $x_i$, one for the shipping time of each product, $x_p$, and one for the makespan, that is to be minimized, $M\!S$. In other words, a continuous x variable will be assigned to each node of the S-graph. To make descriptions simpler, notations $x_i$ and $x_{n^T_i}$ will be used interchangeably, and similarly, $x_p$ and $x_{n^P_p}$ will refer to the same variable.

The model would consist of 3 types of constraints. For each arc $(n,n',w_{n,n'})$ in the S-graph, a constraint in the form of $x_{n'} \ge x_n + w_{n,n'}$ is added to the LP model, regardless of the type of the arc (schedule or recipe), or the connected nodes (task or product). For each intermediate, $(i,i^+)\in {{\mathcal {S}}}^{LW}$ with LW policy, a constraint in the form of $x_{i^+}\le x_i + \max _{j\in {{\mathcal {J}}}_i}pt_{i,j} + st^{max}_{i,i^+}$ is added, if the unit assignment for i has not yet been made. Otherwise, the constraint would take the form $x_{i^+}\le x_i + pt_{i,J_i} + st^{max}_{i,i^+}$. For each product, $p\in P$, $M\!S\ge x_p$ is added.

The solution of this LP model provides a proper bound for the makespan and the subproblem is infeasible if there is no solution to it.

The model can also be extended with a $M\!S \le {M\!S}^{cb}$ constraint, where ${M\!S}^{cb}$ is the best found makespan, i.e., the upper bound in the overall B&B procedure. In this case, an infeasible LP model does not necessarily indicate an infeasible branch, only a suboptimal one, which needs to be pruned regardless. Adding this constraint keeps the LP solver from optimizing a bound already known to be worse than a solution found previously.

In this approach, the second type of constraints is equivalent to the LW arcs of the previous approach. In this sense, if the previous approach is cached with a DBM, there is no algorithmic benefit of using this LP model as it will not provide better bounds but definitely uses more computation to end up with the same result. Thus, this approach is more like a baseline for the more complicated LP bounding functions described in the next section and will be referred to as the SLP approach.

5.3 Relaxed MILP model

To compensate the additional computational burden of constructing and solving an LP model for bounding, the solution should provide tighter bounds. This could be achieved by a more complex LP model that is based on the relaxation of a general precedence based MILP formulation. The general idea is to keep an MILP model in sync with the decisions made in the S-graph B&B algorithm, i.e., if some decisions are made in the B&B tree, those decisions are implemented in the MILP model by fixing the value of key binary variables. Then, the bounding procedure would be the solution of the relaxed version of this MILP model. Since this model has assignment and sequencing decisions yet to be made in a relaxed form, there is a hope for providing better bounds than the previous simple LP model.

These models generally employ continuous variables $ST_{i},CT_{i}$ for the start and completion of task $i\in {{\mathcal {I}}}$, binary variables $Y_{i,j}$ for the assignment of unit $j\in {{\mathcal {J}}}_i$ to task $i\in {{\mathcal {I}}}$. Binary sequencing variables can be of the form $X_{i,i'}$ for tasks $i,i'\in {{\mathcal {I}}}$, $i\ne i'$ that may be assigned to the same unit, i.e., ${{\mathcal {J}}}_i \cap {{\mathcal {J}}}_{i'}\ne \emptyset$, or directly specified for each unit $j\in {{\mathcal {J}}}_i \cap {{\mathcal {J}}}_{i'}$ as $X_{i,j,i'}$. Moreover, an additional continuous variable, $M\!S$ is used for the objective function.

There are several ways how these models can be formulated as it will be discussed at the end of the section. The general procedure for these approaches starts with generating the MILP model for the root of the S-graph B&B tree. Then, when a child subproblem is generated, the MILP model is updated with the decision made.

Precedence based models and S-graph have nearly identical search space as both methodologies address the scheduling problem as assignment and sequencing decisions and derive timing from those, as opposed to time slot and time point based models, which consider assignment and timing as the major decisions and derive sequencing based on those. As a result, a decision in the S-graph B&B tree can easily be expressed with setting some binary variables of a precedence based model. For example, when the Equipment-based B&B algorithm makes a decision to set i as the next task for the unit j, this decision could be reflected as setting:

• $Y_{i,j}$ to 1

• $Y_{i,j'}$ to 0 for all $j'\in {{\mathcal {J}}}_i\setminus \{j\}$

• $X_{i',i}$ to 1 and $X_{i,i'}$ to 0 for all $i'\in {{\mathcal {I}}}_j$ that has been assigned to j previously

• $X_{i,i'}$ and $X_{i',i}$ to 0, if $i'$ is already assigned to a different unit or $j\not \in {{\mathcal {J}}}_{i'}$

There are two ways, how this update can be implemented: either a copy of the MILP model is made and the alterations are done there, or only a single MILP model is kept in memory and only the individual lower and upper bounds for the binary variables are copied and updated. The latter approach requires less memory usage and copy operations.

Moreover, the solution of the LP problem of the child subproblem may be accelerated by using the solution of the parent node as the initial basis for the dual simplex method.

5.3.1 Shared parts of considered MILP models

The considered three MILP models share most of the constraints, only the ones related to sequencing may differ.

The first three constraints express the timing considerations of the production recipe:

$$\begin{aligned} CT_i&= {} ST_i + \sum _{j\in {{\mathcal {J}}}_i} pt_{i,j}\cdot Y_{i,j} \quad \forall i\in {{\mathcal {I}}}\end{aligned}$$

(1)

$$\begin{aligned} ST_{i^+}& \ge {} CT_i \quad \forall (i,i^+)\in {{\mathcal {S}}}\end{aligned}$$

(2)

$$\begin{aligned} ST_{i^+}\le & {} CT_i + st^{max}_{i,i^+} \quad \forall (i,i^+)\in {{\mathcal {S}}}\end{aligned}$$

(3)

The next constraint ensures that exactly one unit is selected for each task:

$$\begin{aligned} \sum _{j\in {{\mathcal {J}}}_i}Y_{i,j} = 1 \quad \forall i\in {{\mathcal {I}}}\end{aligned}$$

(4)

The constraints for the objective variable, $M\!S$, are as follows:

$$\begin{aligned} M\!S& \ge {} CT_i \quad \forall i\in {{\mathcal {I}}}\end{aligned}$$

(5)

$$\begin{aligned} M\!S\le & {M\!S}^{cb} \end{aligned}$$

(6)

Each of the three MILP models have these constraints as a basis, and they are extended with the ones detailed below.

5.3.2 RLP1: three index precedence model

The first selected MILP model employs $X_{i,j,i'}$ variables defined for all $i,i'\in {{\mathcal {I}}}, i\ne i',j\in {{\mathcal {J}}}_i \cap {{\mathcal {J}}}_{i'}$. $X_{i,j,i'}=1$ if and only if both i and $i'$ are assigned to unit j, which performs i before $i'$. In all other cases, i.e., if the order is the other way around, or at least one of them is not assigned to unit j, the variable should take the value of 0.

The effects of sequencing decisions are expressed by the following two constraints:

$$\begin{aligned} ST_{i'}&\ge {} CT_i - M \cdot \left( 1 - X_{i,j,i'}\right) \nonumber \\&\quad \forall i,i'\in {{\mathcal {I}}}, i\ne i',j \in {{\mathcal {J}}}_i \cap {{\mathcal {J}}}_{i'}, \not \exists (i,i^+)\in {{\mathcal {S}}}^{NIS} \end{aligned}$$

(7)

$$\begin{aligned} ST_{i'}&\ge {} ST_{i^+} - M \cdot \left( 1 - X_{i,j,i'}\right) \nonumber \\&\quad \forall (i,i^+) \in {{\mathcal {S}}}^{NIS} ,i'\in {{\mathcal {I}}}\setminus \{i,i^+\},j\in {{\mathcal {J}}}_i \cap {{\mathcal {J}}}_{i'} \end{aligned}$$

(8)

Technical constraints that ensure the proper relation between sequencing and assignment variables:

$$\begin{aligned}&X_{i,j,i'}+X_{i',j,i}\ge Y_{i,j} + Y_{i',j} - 1 \quad \forall i,i'\in {{\mathcal {I}}}, i\ne i',j\in {{\mathcal {J}}}_i \cap {{\mathcal {J}}}_{i'} \end{aligned}$$

(9)

$$\begin{aligned}&X_{i,j,i'}+X_{i',j,i}\le Y_{i,j} \quad \forall i,i'\in {{\mathcal {I}}}, i\ne i',j\in {{\mathcal {J}}}_i \cap {{\mathcal {J}}}_{i'} \end{aligned}$$

(10)

5.3.3 RLP2: two index precedence model

The second MILP model employs sequencing variables with two indices, i.e., $X_{i,i'}$ defined for all $i,i'\in {{\mathcal {I}}}, i\ne i',{{\mathcal {J}}}_i \cap {{\mathcal {J}}}_{i'}\ne \emptyset$. The general difference is that only one sequencing variable is made for each possibly overlapping task pair instead of a separate one for each unit where it can happen. $X_{i,i'}=1$ if both i and $i'$ are assigned to the same unit, whichever it may be, and i is performed before $i'$. In all other cases, the variable is allowed to take any value.

The following two constraints express sequencing:

$$\begin{aligned} ST_{i'}& \ge {} CT_i - M \cdot \left( 1 - X_{i,i'}\right) \nonumber \\&\quad \forall i,i'\in {{\mathcal {I}}}, i\ne i',{{\mathcal {J}}}_i \cap {{\mathcal {J}}}_{i'}\ne \emptyset , \not \exists (i,i^+)\in {{\mathcal {S}}}^{NIS} \end{aligned}$$

(11)

$$\begin{aligned} ST_{i'}& \ge {} ST_{i^+} - M \cdot \left( 1 - X_{i,i'}\right) \nonumber \\&\quad \forall (i,i^+) \in {{\mathcal {S}}}^{NIS} ,i'\in {{\mathcal {I}}}\setminus \{i,i^+\}, {{\mathcal {J}}}_i \cap {{\mathcal {J}}}_{i'}\ne \emptyset \end{aligned}$$

(12)

Note that these constraints are not generated for all of the possible conflicting units.

There is only one technical constraint:

$$\begin{aligned} X_{i,i'}+X_{i',i}\ge Y_{i,j} + Y_{i',j} - 1 \quad \forall i,i'\in {{\mathcal {I}}}, i\ne i', j\in {{\mathcal {J}}}_i \cap {{\mathcal {J}}}_{i'} \end{aligned}$$

(13)

5.3.4 RLP3: two index precedence model variant

The third model that was implemented is a slightly modified version of the second one. It also employs the $X_{i,i'}$ variables but their meaning is altered. $X_{i,i'}=1$ if and only if i is started earlier than $i'$ regardless of their assigned units.²

A technical constraint to ensure this is:

$$\begin{aligned} X_{i,i'}+X_{i',i}=1\quad \forall i,i'\in {{\mathcal {I}}}, i\ne i', {{\mathcal {J}}}_i \cap {{\mathcal {J}}}_{i'}\ne \emptyset \end{aligned}$$

(14)

Sequencing is then expressed via the following constraints generated for all of the possible conflicting units, just in the case for the first model:

$$\begin{aligned} ST_{i'}& \ge {} CT_i - M \cdot \left( 3 - Y_{i,j} - Y_{i',j} - X_{i,i'}\right) \nonumber \\&\quad \forall i,i'\in {{\mathcal {I}}}, i\ne i',j\in {{\mathcal {J}}}_i \cap {{\mathcal {J}}}_{i'}, \not \exists (i,i^+)\in {{\mathcal {S}}}^{NIS} \end{aligned}$$

(15)

$$\begin{aligned} ST_{i'}& \ge {} ST_{i^+} - M \cdot \left( 3 - Y_{i,j} - Y_{i',j} - X_{i,i'}\right) \nonumber \\&\quad \forall (i,i^+) \in {{\mathcal {S}}}^{NIS} ,i'\in {{\mathcal {I}}}\setminus \{i,i^+\},j\in {{\mathcal {J}}}_i \cap {{\mathcal {J}}}_{i'} \end{aligned}$$

(16)

The key advantage of this model is, that constraint (14) allows to reduce the number of sequencing variables by half. Since $X_{i,i'}+X_{i',i}=1$ for all i and $i'$ that can share a unit, in essence, only one of those variables are “free” and the other is “fixed” or “derived” from the former one. This means, that one of those variables can be replaced with a simple linear expression of the other, e.g.: $X_{i,i'}=(1-X_{i',i})$, in all of the constraints where it appears.

5.4 Other techniques

During our investigation, several other ideas came up and were implemented. Two of them are briefly introduced below. These ideas were later disregarded, as they turned out to be algorithmically inferior compared to the negatively weighted LW arc approach (Hegyháti 2015).

5.4.1 Recursive search

Instead of inserting the negatively weighted arcs into the graph and altering the bounding procedure, S-graph could still reflect the UW case and use the original bounding function. In order to find LW/ZW infeasibilities, a recursive search algorithm could be used, which tests, whether there is a forced upper bound on the starting time of a task, that is lower than another forced lower bound.

This approach provides less tight bounds and requires additional attention at leaf nodes to evaluate the makespan.

5.4.2 Conversion to ZW and external graph

In the case of $st^{max}_{i,i^+}=0$, the intermediate between i and $i^+$ cannot be stored at all and must be processed immediately. This renders the difference between the starting times of i and $i^+$ fixed. This also means, if $i^+$ is forced to start later due to unit scheduling, so does i.

To tackle ZW cases, one can build an auxiliary graph, whose nodes represent these strongly connected vertex sets. New decisions not only insert arcs in the S-graph but to this auxiliary graph as well. Non-negative directed cycles will indicate infeasible solutions.

Problems with more general, LW constraints can be converted to equivalent problems with ZW and UW vertices only (Hegyháti et al. 2011).

6 Empirical results

The performance of the proposed approach was tested on several examples, which have been introduced by Liu and Karimi (2007). They examined multistage multiproduct batch plants with nonidentical parallel units and generated 13 problems. In this type of plants the products are processed sequentially with the same order of stages and more than one unit is available for each stage (task). The processing times of the tasks in the examples are given in Tables 2, 3, 4, 5, 6 and 7. E.g. Table 3 shows that in example E2, 9 products have to be produced in 2 steps, where the first task can be performed by unit 1 or 2 and the second task by unit 3, 4 or 5.

Table 2 Processing times [tu] of tasks for examples E1 (products 1..11) and E7 (products 1..9)

Table 3 Processing times [tu] of tasks for examples E2 (products 1..9) and E8 (products 1..10)

Table 4 Processing times [tu] of tasks for examples E3 (products 1..8) and E9 (products 1..9)

Table 5 Processing times [tu] of tasks for examples E4 (products 1..7) and E10 (products 1..9)

Table 6 Processing times [tu] of tasks for examples E5 (products 1..8), E11 (products 1..9) and E13 (products 1..10)

Table 7 Processing times [tu] of tasks for examples E6 (products 1..5) and E12 (products 1..6)

Liu and Karimi (2007) assumed unlimited intermediate storage and unlimited wait (UIS/UW) policy and later they also examined the NIS/ZW case solving the same examples (Liu and Karimi 2008). In this paper all examples were solved with UIS/UW, UIS/ZW, NIS/UW and NIS/ZW policies and got the same optimum for all cases.

The tests were run on an Intel Core i5-660 3.33 GHz CPU with 4 GB RAM with 3600 s time limit. In the tables the following notations are used for the methods:

• UW: UIS/NIS UW with the original S-graph framework for reference (Sanmartí et al. 2002)

• NEG: negative arcs approach (Sect. 5.1)

• SLP: simple LP bound (Sect. 5.2)

• RLP{1,2,3}{c,s}: bounding with relaxed MILP models (Sect. 5.3)

  • c: copy the model when branching and start from the parent solution (SLP also works like this)

  • s: use a shared singleton LP model

The CPU time of the program was limited to 3600 s, after this time the algorithm was stopped and the current best solution is presented. Tables 8, 9, 10, 11 show the objective values (tu) and the CPU times (s) of the algorithms to solve the 13 examples. In UW case, UIS algorithm cannot find the optimum of examples E10 and E11 but for other examples the CPU times of UIS and NIS are close to each other. In ZW case, the negative arc algorithm was always the fastest with the same speed as UW/NIS algorithm.

Table 8 Objective values [tu] for NIS policy (bold value means non optimal solution)

Table 9 CPU times [s] for NIS policy (bold value means the time limit was reached)

Table 10 Objective values [tu] for UIS policy (bold value means non optimal solution)

Table 11 CPU times [s] for UIS policy (bold value means the time limit was reached)

The previous examples were multiproduct problems, where products visit the same stages in the same order. However, the presented methods can solve the more general multipurpose case, where the stage order can be arbitrary for each product. To investigate the effect of the recipe type on the performance, multipurpose examples have been generated from the previous problems by reversing the stage order of the first 4 products in each instance. UIS policy was assumed at each stage. It can be seen from the test results that the methods perform similarly for multipurpose examples as it was seen in the multiproduct case (Tables 12, 13).

Table 12 Objective values [tu] for multipurpose examples (bold value means non optimal solution)

Table 13 CPU times [s] for multipurpose examples (bold value means the time limit was reached)

Liu and Karimi (2008) presented a hybrid plant example, where both NIS, UIS, UW, and ZW policies occur throughout the recipe. In the example there are 4 stages, and there is NIS/UW policy between tasks 1 and 2, NIS/ZW after task 2, and UIS/UW between tasks 3 and 4. The processing times of the tasks are given in Table 14. The minimal makespan is 361 tu, which was found by all methods. The CPU times of the algorithms are given in Table 15.

Table 14 Processing times [tu] of tasks for the hybrid example

Table 15 CPU times [s] for the hybrid example

7 Concluding remarks

There are plenty of advantages and disadvantages between approaches based on general purpose solvers (e.g., MILP optimizers) and those relying on customized models and algorithms. One clear benefit of the latter can be the ability to change and tune the inner workings of the optimization algorithms more easily. This paper follows that principle, and examined several different options for modeling limited-wait storage policy in the S-graph framework. These approaches were all implemented and tested extensively. The results clearly showed the superiority of the negative-weighted arc approach in most of the cases in terms of efficiency.

This unambiguous result is favored for future work as developments tackling more complex problems can build on top of this technique and have the certainty that this subtask is addressed in the best possible way.