MACRo 2015- 5th International Conference on Recent Achievements in
Mechatronics, Automation, Computer Science and Robotics
Throughput Maximization with S-graph Framework
using Global Branching Tree
Tibor HOLCZINGER1, Ákos OROSZ2
1 Department
of System and Computer Science, Faculty of Information Technology,
Pannon University, Veszprém, e-mail: [email protected]
2 Department of System and Computer Science, Faculty of Information Technology,
Pannon University, Veszprém, e-mail: [email protected]
Manuscript received January 12, 2015, revised February 9, 2015.
Abstract: Majozi and Friedler [3] developed the first approach for throughput
maximization, which has no need for the optimal number of time points a-priori. The
feasibility of a sequence of subproblems is examined with guided search driven S-graph
based approach. Although, the approach has proved to be efficient for several problems
[1], it can be developed further to increase the size of addressable cases.
In the original approach, a branching tree is generated for each subproblem
separately, even though these trees can have significantly large overlaps. The presented
approach exploits this redundancy to reduce the computational needs for industrial scale
problems.
Keywords: Batch processes, scheduling, throughput maximization, global
branching tree, S-graph.
1. Problem statement
The problem aimed in this paper can be summarized as follows. Given, the
task network (recipe) for each product, the set of potential equipment units for
each task, the cost data and the time horizon of interest. The objective is to
determine a schedule that has the highest throughput or revenue for all the
products involved.
In all the problems in this paper no intermediate storage (NIS) policy has
been taken into account. It means there are no storage units between tasks, so
the intermediate material must be stored within the equipment unit
manufacturing the material till the consecutive equipment unit of the next stage
becomes available.
201
10.1515/macro-2015-0020
Unauthenticated
Download Date | 6/17/17 11:35 AM
202
T. Holczinger, A. Orosz
2. S-graph representation
In this section the sufficient details of the S-graph also will be given. The
detailed mathematical formulation for the S-graph framework has been
presented by Sanmartí et al. [4].
An S-graph is a weighted directed graph which has two types of arcs, the
recipe-arcs and schedule-arcs. Specific types of S-graphs are defined for
representing a recipe (recipe-graph) and a solution (schedule-graph).
In a recipe-graph each task and each product are represented by a node (tasknode and product-node, respectively). Recipe-arcs show the order of nodes of
consecutive tasks in the recipe, where the weight of the arc is the smallest
processing times of the tasks. In case of multiple batches, task-nodes, productnodes, and recipe-arcs are multiplied appropriately. Fig. 1 shows the recipegraph of production of two products (A and B), where product B is produced in
three consecutive steps and four tasks are needed to generate product A.
Figure 1: Example of a recipe-graph.
A schedule-graph describes a solution of a scheduling problem. In a solution,
each task must be assigned to an equipment unit, and a total ordering must be
defined for the tasks scheduled to the same equipment. S-graph is called a
schedule-graph if all tasks have been scheduled by taking into account the
equipment-task assignments. Fig. 2 shows a schedule-graph of recipe-graph of
Fig. 1. By a branch and bound algorithm, the optimal schedule can be
effectively generated.
There are two important advantages of the S-graph framework which can be
used for throughput maximization. First, it can effectively generate a feasible
solution of a given number of batches under a fixed time horizon. Moreover,
using dynamic programming techniques, the algorithm can provide results from
the previous feasibility test to the next test phase, so the solution time can be
improved.
Unauthenticated
Download Date | 6/17/17 11:35 AM
Throughput maximization with S-graph framework using global branching tree
203
Figure 2: A schedule-graph of recipe-graph from Fig. 1.
3. Throughput algorithm using a sequence of feasibility tests
The base idea of solving throughput maximization problems with the Sgraph framework has been published by Majozi and Friedler [3]. The algorithm
uses a feasibility tests in each step, which is a modified version of the S-graph
based makespan minimization algorithm. The feasibility test only decides
whether the problem can be solved in a given time horizon, i.e. it tries to
generate a feasible solution.
The algorithm build a discrete search space based on the number of batches
of each product. This search space can be represented by a coordinate system
with the number of dimensions equal to the number of products. The elements
of the search space are subproblems, which are instances of the scheduling
problem with fixed batch numbers. For example in case of two products, the
search space is shown in Fig. 3, where subproblems are denoted by points.
From now, the subproblems will be denoted by tuples, where the elements of
a tuple are the number of batches of the products (in alphabetic order). For
example the subproblem, where two batches of product A and one batch of
product B is to be produced, is denoted by (2,1).
Figure 3: Search space representation for two products.
Unauthenticated
Download Date | 6/17/17 11:35 AM
204
T. Holczinger, A. Orosz
If a subproblem is infeasible, then a part of the search space can be excluded
from further investigation, because a subproblem with equal or more batches
from each product cannot be manufactured in shorter time. For example, if
subproblem (3,5) is infeasible, then subproblems (3,6), (3,7), ..., (4,5), (4,6), ...,
(5,5), (5,6), ... are also infeasible. The final search space can be seen in Fig. 4,
where the infeasible nodes are crossed and the vertical and horizontal lines
denote the cuts of the search space.
Figure 4: Search space representation for two products, with infeasibility cuts.
4. Global branching tree
This section will show that the previously presented approach performs
redundant computations. Moreover a new optimization technique will be
presented, which can eliminate this redundancy.
4.1. Disadvantages of independent feasibility tests
The original S-graph based throughput maximization method performs
independent feasibility tests which technique has some disadvantages. For
demonstration, let us introduce a small example. In the example two products
(A and B) are produced through two consecutive steps according to recipe given
in Table 1. The aim is to optimize the total revenue for 8 hours.
Table 1: Recipe of two products.
Task
1
2
Eq.
E1
E3
Product A
Time (h)
2
4
Eq.
E2
E1
Product B
Time (h)
3
2
Using the original method, several S-graphs (subproblems) have to be
examined. In the first subproblem only one batch from product A is to be
Unauthenticated
Download Date | 6/17/17 11:35 AM
Throughput maximization with S-graph framework using global branching tree
205
produced. To check its feasibility, for both tasks an equipment unit are to be
assigned which takes two steps and no scheduling decision is required. The
branching tree of this feasibility test are given in Fig. 5. In the root of the tree
(grey node) no tasks are scheduled. After the first branch, one task is scheduled,
leading to a partial schedule (white node). After the second branch, all tasks are
scheduled, and a feasible solution of the subproblem is found (double lined
node).
Figure 5: Branching tree of the example given in Table 1 with one batch for product A.
To generate the optimal solution, the algorithm has to examine seven
subproblems. The branching strategy of the feasibility test can greatly affect the
number of branches, because finding a feasible schedule stops the search. Table
2 shows, how many branching steps are required to determine the feasibility of
a subproblem. In the best case, the branching strategy can find a feasible
solution for the first try using only the necessary number of steps. In the worst
case, the test generates all other nodes of the search tree before finding a
feasible solution. In case of infeasible subproblems, the algorithm examines the
whole branching tree, so the best case and the worst case are the same.
Table 2: Number of branches for the subproblems.
Subproblem (A,B)
(1,0)
(0,1)
(2,0)
(1,1)
(0,2)
(3,0)
(2,1)
Sum
Worst case
2
2
7
5
4
14
11
45
Best case
2
2
4
4
4
14
6
36
To better understanding let’s take subproblems (2,0) and (3,0) as an
example. Fig. 6 shows the corresponding branching trees. The meanings of
grey, white and double lined nodes are the same as in the previous branching
tree. If during the branch and bound algorithm, a schedule with circular
Unauthenticated
Download Date | 6/17/17 11:35 AM
206
T. Holczinger, A. Orosz
precedencies (represented by a directed cycle in the S-graph) is generated, the
corresponding schedule is infeasible (crossed nodes). Moreover since the
problem has a time horizon, any feasible schedule with longer manufacturing
time is also considered infeasible subproblem (hatched nodes).
The branching tree of subproblem (2,0) contains nine nodes (needs eight
branches) two of them are feasible schedules. In the worst case, the algorithm
performs 6 branches (second column of Table 2), and finds a solution for the
seventh one. In the best case, four branches are enough to get a feasible
schedule (third column of Table 2). Subproblem (3,0) does not have any
feasible schedule, so all fourteen nodes are to be generated (the worst and the
best cases are the same).
Figure 6: Branching trees of subproblems (2,0) and (3,0).
It can be clearly seen, that these branching trees have a common part,
especially the bigger one contains the other. It means, that the algorithm
performs redundant calculations, because the feasibility tests of the
subproblems are independent. This redundancy can be eliminated by building a
common tree, called global branching tree.
4.2. Optimization strategy
All branching trees of the subproblems can be combined into one large
branching tree, shown in Fig. 7. The branching tree of subproblem (2,0)
contains the branching tree of subproblem (1,0). In the global tree, the part
labeled by (2,0) denotes the branches examined for subproblem (2,0), but not
Unauthenticated
Download Date | 6/17/17 11:35 AM
Throughput maximization with S-graph framework using global branching tree
207
for subproblem (1,0). It can be seen, that the total number of branches required
to generate the branching tree is only 28, while with feasibility tests the
algorithms needs at least 36 branches in the best case (45 branches on worst
case).
The feasibility of a subproblem depends on the feasibility of its ancestor
subproblems. From this point we say a subproblem is a parent of an other
subproblem if they differ only in one batch number, and in the child it is bigger
by one. For example subproblem (1,2) is a parent of (2,2) and (1,3), moreover
its parents are (1,1) and (0,2).
Figure 7: Global branching tree of the example given in Table 1.
This parent/child definition allows that a subproblem can have multiple
children and multiple parents, however in a tree each node must have exactly
one parent (except the root). For each subproblem the algorithm has to select
one parent and the selection rule can greatly influence the effectiveness of the
algorithm.
For a subproblem there can be multiple possibilities for generating its
branching tree. If the branching method for subproblem (1,1) first schedules the
tasks of product B, than of product A, the branching tree shown in Fig. 7 is
generated. If it starts with the tasks of product A, the branching tree would be
different, as shown in Fig. 8. Since both subproblems (1,0) and (0,1) are parents
of subproblem (1,1), the algorithm must select exactly one of them, form which
Unauthenticated
Download Date | 6/17/17 11:35 AM
208
T. Holczinger, A. Orosz
the branching tree of (1,1) will be generated. The selection rule can greatly
influence the effectiveness of the algorithm.
In case of branching tree of Fig. 7, the lexicographically first parent has been
chosen as the parent for each subproblem. Choosing the lexicographically last
parent for each subproblem results the branching tree seen in Fig. 8, which
consists of 29 branching steps. The number of branching steps are slightly
increased from 28 to 29, although the difference can be bigger for bigger
problems. Further parent selection strategies are not presented in this work.
Figure 8: Another global branching tree of the example given in Table 1.
The parent selection strategy does not determine the algorithm fully. The
order of the examination of subproblems has a huge role as well, because the
infeasibility of a subproblem yields the infeasibility of all of its descendant
subproblems. Considering the branching tree in Fig. 7, although subproblem
(2,1) has feasible solutions, the algorithm does not examine subproblem (3,1).
Though in the branching tree subproblem (3,1) is not a child of subproblem
(3,0) (because of the parent selection strategy), the definition of parent/child
relation provides that the infeasibility of (3,0) yields the infeasibility of (3,1).
To ensure this cut in the branching tree, the feasibility of subproblem (3,0) must
be examined beforehand. Also, for the same reason, there is no need to examine
Unauthenticated
Download Date | 6/17/17 11:35 AM
Throughput maximization with S-graph framework using global branching tree
209
subproblem (2,2) if the algorithm examines subproblem (2,0) earlier and it is
infeasible.
5. Illustrative example
In this section a literature example is presented to demonstrate the
performance of the global branching tree. The example is published by
Ierapetritou and Floudas [2]. Fig. 9 shows the flowsheet of the literature
example. The example involves a heater, a separator and two reactors. Each of
the reactors can perform 3 reactions, i.e. reaction 1, 2 and 3. The reactions take
2, 2 and 1 hour, respectively. Heating takes 1 hour and the separation is 2 hours.
The process operates in a no intermediate storage (NIS) policy. The objective is
to maximize revenue for products 1 and 2.
Figure 9: Flowsheet for literature example.
The computational results are given in Table 3 for 14, 15 and 16 hours time
horizons. The necessary number of branches and the CPU time are highly
decreased using global branching tree.
Table 3: Computational results for the illustrative example.
Time horizon
14
15
16
Separate branching trees
# of branches
CPU time (s)
1 229 117
3.706
6 524 679
21.593
56 815 742
199.802
Global branching tree
# of branches
CPU time (s)
53 335
0.573
124 587
1.156
323 241
2.914
Unauthenticated
Download Date | 6/17/17 11:35 AM
210
T. Holczinger, A. Orosz
6. Conclusion
In this work we have reduced the redundancy of the optimization strategy for
throughput maximization presented by Majozi and Friedler [3]. To demonstrate
the performance of the technique, a literature problem was used to compare to
the original method. However, the efficiency of the global branching tree has
been presented by examples, it has room for further accelerations.
Acknowledgements
This publication/research has been supported by the European Union and
Hungary and co-financed by the European Social Fund through the project
TÁMOP-4.2.2.C-11/1/KONV-2012-0004 - National Research Center for
Development and Market Introduction of Advanced Information and
Communication Technologies.
References
[1]
[2]
[3]
[4]
Holczinger, T., Majozi, T., Hegyhati, M., Friedler, F., “An automated algorithm for
throughput maximization under fixed time horizon in multipurpose batch plants: S-graph
approach”, presented at ESCAPE 17, Bucharest, Romania, May 27-30, 2007.
Ierapetritou, M. G., Floudas, C. A., “Effective continuous-time formulation for short-term
scheduling. Part 1. Multipurpose batch processes”, Ind. Eng. Chem. Res, 37, 4341-4359,
1998.
Majozi, T., Friedler, F., “Maximization of throughput in a multipurpose batch plant under
fixed time horizon: S-graph approach”, Ind. Eng. Chem. Res., 45, 6713-6720, 2006.
Sanmartí, E., Holczinger, T., Puigjaner, L., Friedler, F., “Combinatorial framework for
effective scheduling of multipurpose batch plants”, AIChE Journal, 48(11), 2557-2570,
2002.
Unauthenticated
Download Date | 6/17/17 11:35 AM