Professional Documents
Culture Documents
a r t i c l e i n f o a b s t r a c t
Article history: For complex systems operating in critical environments, original equipment manufacturers, operators
Received 16 January 2015 and/or regulators often specify replacement intervals for major components before failure can occur.
Received in revised form 26 September 2015 The fixed costs to teardown the overall system can be an important constituent of the total costs.
Accepted 29 September 2015
Thus, when a preventive maintenance is scheduled to replace a given component, it may well be desirable
Available online 9 October 2015
to replace one or more other components that are within their replacement window (interval), so as to
avoid repeating the teardown costs in a short while. This paper presents a novel network tree formulation
Keywords:
of this opportunistic indirect grouping of periodic events problem. We show that, given a fixed time
Opportunistic grouping
Preventive replacements
horizon and a moderately large number of major components, the replacement optimization problem
Shortest path can be represented as a tree of possible replacement combinations. Although these trees can become
Multicomponent system enormous, we have developed a Python implementation of a depth-first shortest path algorithm that
can be very effective because many of the nodes of this tree do not need to be examined. Even when sev-
eral million nodes need to be examined, only a few of them, typically a few hundreds, need to be main-
tained in memory at any one time. For larger number of components and longer time horizons, the trees
can still become so large that it is impossible to examine it completely. In this case, the depth first search
still rapidly finds a sequence of improving solutions and can be a very good heuristic for the problem.
Ó 2015 Elsevier Ltd. All rights reserved.
http://dx.doi.org/10.1016/j.cie.2015.09.013
0360-8352/Ó 2015 Elsevier Ltd. All rights reserved.
282 E.A. Gunn, C. Diallo / Computers & Industrial Engineering 90 (2015) 281–291
2. Problem definition and is not included in the cost model to be optimized. On the other
hand, the PM replacements of subsystems/major components are
The following notation is used. done at a subcontractors facilities where the aircraft/helicopter
stays much longer. These costs are very high and the downtime
T finite maintenance planning horizon are long therefore there is a need to opportunistically group some
n number of major components or subsystems in the of these replacements. The PM actions are carried out on groups of
multicomponent system subsystems for which manufacturers or regulators have set
c index of major components or subsystems, mandatory replacement schedules.
c 2 f1; 2; . . . ; ng The problem is modeled as a shortest path problem with
K fixed teardown/setup cost for each preventive replacement cost as distance. Depending on the widths of the
replacement activity regardless of the number of replacement windows [Ec ; F c ] and the length of the exploitation
components/subsystems replaced horizon T, the number of combinations (nodes) to evaluate
Sc current age or status of major component/subsystem c explodes and an efficient search method is devised to reduce the
Tc preventive maintenance replacement periodicity for search space, limit memory usage, reduce computation time and
major component c guarantee optimality.
Ec start of the opportunistic preventive replacement window The paper is structured as follows. In Section 3, the formulation
for component c of the problem as a shortest path problem is presented. In Section 4,
Fc end of the opportunistic preventive replacement window the modified label correcting algorithm used to optimally solve the
for component c problem is presented. Section 5 is devoted to the discussion of
kc unit acquisition and replacement cost for component c numerical results.
3. Problem formulation
We consider a complex system with n major components or
subsystems. Each major component c requires PR with fixed peri- We are given n components with PM periodicities T c where
odicity T c . At the beginning of the planning process, the current c ¼ 1; 2; . . . ; n. The goal is to find the minimum-cost schedule of
age or status of component c is Sc . Sc = 0 means that the component PM actions over the horizon T with all replacements carried-out
has just been replaced. Each component has an allowable early within their required periodicities. To convert this problem to a
replacement window defined by [Ec ; F c ]. Before Ec , the component shortest path problem, we define a tree structure with nodes and
is not eligible for opportunistic grouping. Between F c and T c , the arcs. Each node is assigned an n-dimension vector of zeros (no
component will certainly be replaced if an opportunity arises PM) and ones (PM) representing the replacement status of the
(i.e., another component is due to be replaced). Between Ec and components at the time of a mandatory PM action. The cth element
F c , the component is eligible for an early replacement and the of the n-dimension vector represents the PM action of component
model must decide if an opportunistic grouping will be made or c. There are two artificial nodes: a starting node, called node 0, rep-
not. If a grouping is made and the component replaced, then a resenting the top of the tree and a terminal node denoted F where
new cycle begins again for the component (see Fig. 2). Note that all preceding nodes connect with arc lengths of 0.
without any loss of generality, F c can be equal to T c which would Any node in the tree, except the terminal node, has 2n 1
cause computation time to increase because of the increase in potential children nodes, each representing a possible combination
the width of the allowable replacement window. of PM decisions at the time of the earliest of the next mandatory
The problem is then to determine the optimal schedule of PR PM actions. The vector with all elements equal to 0 is not a practi-
that will minimize the total PM cost over a finite operation horizon cal replacement decision. Therefore, it is never created. Further-
T. There is a fixed teardown (set-up) cost K for each PM activity more, each node has 2n n effective children nodes. Among the
regardless of the number of components replaced. Each component vectors representing the 2n 1 potential children nodes, there
c costs kc to acquire and replace. This new model falls under the are n unit vectors with only one element equal to 1 and n 1
indirect grouping class. It should be noted that we do not consider elements equal to zero. Only one such unit vector represents a
subsystem or major component failures in this paper. This paper is valid replacement decision corresponding to the replacement of
about opportunistic grouping of PM actions for highly reliable sys- the component with the nearest replacement time. Therefore, the
tems such as aircraft or helicopters with high level of redundancy other n 1 unit vectors should not be generated. Hence, the
where individual parts can fail without major components or sub- 2n n effective children nodes.
systems failing. For these systems, failed parts are replaced at the For illustration purposes, a simple example with two compo-
earliest convenient time (overnight, next scheduled stop or land- nents 1 and 2 is considered with the following parameters:
ing, etc.) without affecting the overall age of the multicomponent S1 ¼ 25; T 1 ¼ 25; E1 ¼ 15; F 1 ¼ 23; S2 ¼ 11; T 2 ¼ 22; E2 ¼ 10; F 2 ¼ 18,
system (minimal repair). The minimal repair cost is mainly due and T ¼ 60. Fig. 3 depicts the replacement sequence of the example
to bringing the aircraft/helicopter in the hangar, troubleshooting, for the first five nodes. The related costs are K ¼ 0:5; k1 ¼ 2, and
finding and swapping the defective module, testing and releasing. k2 ¼ 3 in some monetary unit.
The cost of the modules/parts are not significant enough to affect When at node 0 and attempting to create the first 2 (22 2)
the total cost of the minimal repair so that it is considered constant children nodes 1 and 2, the earliest PM action is at time 0 for com-
ponent 1. Therefore, the nodes to be created are [1, 0] (node 2) and
[1, 1] (node 1) as illustrated in Fig. 3. Node 1 denoted by vector
[1, 1] represents the decision to have both components preven-
tively replaced. Node 2 denoted by vector [1, 0] represents the deci-
sion to have only the first component preventively replaced. See
that node [0, 1] is not created because, at time 0, the PM is due
on component 1 and not on component 2.
The complete tree for the example is presented in Fig. 4. Arcs
Fig. 2. Periodic PM with allowable opportunistic replacement window. represent the jumping from one PM activity to the next scheduled
284 E.A. Gunn, C. Diallo / Computers & Industrial Engineering 90 (2015) 281–291
PM action, at which point components with overlapping allowable the total cost is 18. The path 0-2-6-12-22-29-30-F has length 18
replacement windows are considered for opportunistic grouping. and corresponds to the replacements without grouping.
The length of an arc is equal to the total replacement cost If T is increased to 67, the shortest path is easily found to be
(set-up cost + variable costs) to carry out the PM actions of the 0-2-6-11-19-F (i.e., replace component 1 alone at time 0, replace
destination node. component 2 alone at time 11, replace both components at time
Another feature added to the tree is the time labeling of the 25, and replace both components again at time 47 for a total cost
nodes to keep track of the time instants at which the PM activities of 17 compared to a total cost of 18 without grouping of PM actions).
defined in a node are carried out. When creating a child node, if the This small example shows how the problem can be modeled as
time label of the child exceeds the planning horizon T, then the a tree and solved with a shortest path method to yield significant
child node is not created and the parent node is directly connected savings. It should be noted that 26 nodes were generated for this
to the terminal node with an arc of length 0. Each node features 2-component problem with T ¼ 60.
vectors S and Sþ representing the age/status of the components In the next section, we present a short argument for the choice
right before and right after the replacement actions, respectively. of the Depth-First Search (DFS) algorithm to solve the opportunis-
When at parent node 2 and attempting to create the children tic indirect grouping problem for a moderately large number of
nodes 5 and 6, the earliest PM action is at time 11 for component components and longer planning horizon.
2. Therefore, the nodes to be created are [0, 1] (node 6) and [1, 1]
(node 5). The length of the arc between node 2 and node 6 is the
sum of the teardown cost and the cost for component 2. The arc 4. The modified label correcting algorithm
between node 2 and node 5 has an infinite length or cost because
component 1 cannot be opportunistically replaced along with Bertsekas (2000) presents a series of shortest paths methods
component 2 at time 11 as it is not within the allowable replace- and algorithms. A general type of shortest path algorithm is the
ment window of component 1. The complete tree for the example Label Correcting Algorithm which works by progressively finding
is presented in Fig. 4. shorter paths from the origin node to every other node i, and
A quick enumeration of all the paths shows that the shortest keeping the length of the current shortest path in a variable di
path is 0-1-4-10-F (i.e., replace both components together at time called label of node i. Initially, the origin node has a label of value
0, time 22 and then at time 44 for a total cost of 16.5). If the 0 and all other nodes have labels of infinite value. The algorithm
components are replaced without the opportunistic grouping then maintains a list of nodes called OPEN which contains nodes that
E.A. Gunn, C. Diallo / Computers & Industrial Engineering 90 (2015) 281–291 285
are candidates for further consideration and possible inclusion in Given the large number of potential nodes to be examined and
the shortest path. Initially, OPEN contains the originating node the related high memory requirements, the DFS method is
(node 0 in our case). The steps of the label correcting algorithm selected. In our implementation, the initial value of UB is set to
are given below with aij being the arc length between nodes i the total replacement cost without grouping instead of 1 as sug-
and j, and UB is an upper bound of the shortest distance. gested by the basic Label Correcting Algorithm. Appendix A gives
the full details of the Python implementation.
Step 1: Remove node i from OPEN, and for each child j, execute Fig. 5 depicts the tree generated for the 2-component example
Step 2. using the algorithm described in Appendix A. A node with dashed
Step 2: If di þ aij < minfdj ; UBg, set dj ¼ di þ aij and set i to be the arc and dashed circle is a terminal node that is not created because
parent of j. In addition if j – F, place j in OPEN if it is not already the cost at that node is already greater than the best cost previ-
in OPEN, while if j ¼ F, set UB = dF ¼ di þ aiF . ously found. It can be seen that Fig. 5 contains far less nodes than
Step 3: If OPEN is empty, terminate; else go back to Step 1. Fig. 4: 17 nodes instead of 26. Another illustrative example with 4
components is presented in Appendix B.
Bertsekas (2000) also shows how the label correcting algorithm
gives rise to different shortest path methods based on how a node 5. Results and discussions
is removed from OPEN. Removing a node from OPEN using the
first-in/first-out policy yields the Breadth-First Search also known The DFS algorithm presented above was implemented in Python
as the Bellman-Ford method. Whereas, the last-in/first-out (LIFO) and run on a 2.99 GHz Window XP PC with 1.96 Gb of RAM. Several
policy yields the depth-first search (DFS) which has been proven experiments were then conducted to test the algorithm on a
to have low memory requirements. If a node is removed from moderate size problem, and then investigate the impact of the
OPEN based on the minimum value of its label, then the Dijkstra’s number of components on the savings achieved, and the effects
method is obtained Bertsekas (1998). of the length of the horizon T.
286 E.A. Gunn, C. Diallo / Computers & Industrial Engineering 90 (2015) 281–291
A dataset was obtained from a Canadian aerospace company. In Table 1, the values of F c were parameters set by the mainte-
For confidentiality reasons, the data has been anonymized to nance planning Department. The company that we worked with
obtain the input values used to run the numerical experiments. sets the value of F c as a fraction of T c (i.e., F c ¼ cc T c ). Typical values
A problem with 10 components was created from the dataset of cc are between 0.80 and 0.98. Alternatively, the value of cc can
(see Table 1) and run for T = 60 and K ¼ 1:6. The optimal schedule be set such that the cost of loss of lifetime due to early replacement
of groupings was obtained after 2484 s for a total cost of $67.5 is significantly smaller than the fixed teardown cost K. This is
where the schedule without grouping costs $88.3 representing equivalent to saying that the cost of loss of lifetime due to early
23.55% in savings. Even when 7,496,370 nodes were generated replacement is less or equal to a proportion a of the fixed teardown
only a maximum of 221 nodes where kept at any given time in cost K. Then, we have:
memory, a testimony to the advantage of the DFS algorithm.
Note that integer values are used for the periodicities. If some or kc
ðT c F c Þ 6 aK
all periodicities are non-integer values, a conversion to integers Tc
values has to be done. It is usually easy to find a multiplier to K
transform non-integer values into integers. 1 a 6 cc
kc
Table 1
So when the cost of the component is close to K, the mainte-
Preventive replacement data.
nance planner can set F c very close to T c . On the other hand, when
Component c Ec Fc Tc kc Sc kc is small compared to K, the maintenance planner can set F c far
1 15 23 25 1.5 25 from T c .
2 10 18 22 3.0 11 A second set of test problems was created from the dataset by
3 30 40 45 2.2 35 generating groups of n components using the first n components
4 30 40 43 3.4 23
5 25 35 38 4.0 32
of Table 1 and varying the exploitation horizon from 50 to 350 time
6 15 25 28 3.2 17 units. The results are displayed in Table 2. Each run of the
7 27 34 37 2.7 14 algorithm was limited to a maximum of 25 million nodes.
8 16 25 26 2.9 24 Calculations were not attempted for problems that were known
9 23 30 33 2.5 17
to generate more than 25 million nodes based on previous runs
10 32 40 42 3.7 35
with smaller T.
E.A. Gunn, C. Diallo / Computers & Industrial Engineering 90 (2015) 281–291 287
Table 2 Table 3
Savings (%) achieved by the proposed grouping method. Eight component heuristic runs.
K ¼ 3:2. The initial cost without opportunistic replacement was interesting to model the impact of imperfect PM actions and
362.8. After 488,657 nodes, this had been reduced to 295.40. How- analyze their impact on the sequence of future replacements.
ever when this was allowed to run to 20,000,000 nodes; three other
improving solutions were found, the last at node 9,246,334 having a Acknowledgements
value of 290.70. In the case of problem 10.3, when allowed to run for
30 million nodes, new solutions were found at node 3,790,429 The authors would like to thank the anonymous referees and
($693.6), node 5,632,774 ($693.5), node 12,895,687($690.3), the Associate Editors for their useful comments and suggestions.
12,944,932 ($687.3). This run, which took about 17000 s as opposed This research work was supported by the Natural Sciences and
to the 110 s to do 200,000 nodes, saved less than two teardowns Engineering Research Council of Canada (NSERC) under Grant
over the 350 time units. Even more interesting, is the fact that the CRDPJ-436347.
first decision made at time 0 was the same, namely replace compo-
nents 1 and 6. Furthermore, if we run problem 10.3 with a time hori-
zon of 100 instead of 350, generating 200,000 nodes, we again make Appendix A. Python implementation
the same time 0 decision of replacing components 1 and 6. This
raises yet another point worth considering. Just because we find The implementation is in a quite simple Python program that is
better solutions over the entire time horizon by running the algo- available from the authors. The explanation below is meant to be
rithm much longer, this does not mean that the decision made at general enough that someone who is not a Python programmer
time 0 is different. In a practical situation, one would only imple- can understand it. However, we use the Python indent convention
ment the decision at time 0 and wait until the system was next in in which a change in indentation represents the end of a loop or
the maintenance shop to recompute a new replacement schedule. conditional test. The four main sets used are:
Although an exhaustive study of this phenomenon is beyond the
scope of this paper, it does suggest that using this approach in what C – a set of components,
amounts to a model predictive control mode, where a reasonable A – a set of actions,
time horizon is run for a reasonable computational effort to get a N – a set of nodes,
good first decision, may well be productive. OPEN – a set of open nodes remaining to be processed.
consider only the components replaced in this action. Some of the and when we Pop a node from OPEN they are taken off the top of
actions in A may not make sense, either physically given the nature the stack (i.e., OPEN is a LIFO queue).
of the equipment, or from a total cost perspective. If these can be The algorithm can then be stated as given below.
identified, these actions should be eliminated from A and this will
again reduce the complexity of the search process. In the results Step (0): Initialize.
reported in this paper, we have not attempted to reduce A. It is Set BestCost = cost with no
convenient to assume that the actions a 2 A are ordered by cost. opportunistic replacement.
It is also useful to compute MinCstAction, the minimum cost a. Create nodes nT and n1 and insert
cst for all a 2 A. in OPEN.
The set N is the set of all possible nodes in the search tree. The Set Nnodes = 1.
nodes in N are generated as they are needed and deleted as they Step (1): If Nnodes = MaxNodes STOP. (note 1)
are no longer needed. The Python dictionary structure is a Otherwise:
convenient way to manage N with the node number used as the Pop node n from OPEN.
dictionary index. The nodes n 2 N have: If node n = 2 then STOP
Set nodesAdded = FALSE
n.num – the node number of this node Step (2): For all a in eA[n]:
n.pred – the predecessor of this node cost = n.cst + a.cst
n.time – the time at which this node is if cost P BestCost then BREAK (note 2)
reached (before taking action) delT = min{a.tm, min{c.lft–n.
n.cst – the total cost to reach this node status[c] 8c with a.vect[c] = 0}}
(before taking action) if n.tm + delT < MaxTime then:
n.nStatus – a vector indicating the number of if cost < BestCost (note 3)
hours used by each component MinCostAction then
n.children – the set of children nodes of this Create a new node nChild
action in N with
Nnodes = Nnodes + 1
nodesAdded = TRUE
nChild.num = Nnodes
The n.num are created as each node is created as number of nChild.pred = n
existing nodes plus 1. Each node has a unique predecessor node nChild.time = n.tm + delT
n.pred. This node corresponds to the node from which the last nChild.cst = cost
action was created that led to this node. The time n.time is the time For all c in C: (note 4)
that this node is reached. At n.time, at least one of the components if a.vect[c] = 1, nChild.
has reached its lifetime and must be replaced. The cost n.cst is the nStatus[c] = delT
total cost since the beginning to reach node n but does not include if a.vect[c] = 0, nChild.
the cost of any actions to be taken at node n. The n.nStatus nStatus[c] = delT + n.nSTatus[c]
indicates the current operating time for each of the components nChild.children = empty
when node n is reached. For at least one of the elements c of Add node nChild to n.
n.nStatus[c] = c.lft must be satisfied. For each node, when it is Children
initially created its set of children is empty. There are two special else:
nodes in N. The node n1 has n1.num = 1, n1.pred = 1, n1.time = 0 BestCost = cost (note 5)
and n1:cst ¼ 0. The status vector n1.nStatus[c] = c.status for all nodesAdded = True
c 2 C. The set n1.children is initially empty. The other node, nT delNode(nT)
plays the role of the terminal node in the tree. Initially, it has nT. Recreate node 2 with:
num = 2, nT.pred = 1, nT.time = MaxTime and nT.cst = BestCost. nT.cst = BestCost
The status vector nT.nStatus[c] is null and the set nT.children is nT.pred = n
empty. MaxTime is the time that the overall maintenance add nT to n.children
planning process has to cover and BestCost is the best cost found Step (3): If nodesAdded = TRUE then (note 6)
to date for covering this period MaxTime. Initially BestCost Push all of the nodes in n.children
is set as the cost of covering this period with no opportunistic (except nT if it is a child)
replacement. to OPEN in reverse order of their
An important concept is eA[n], the set of eligible actions that creation.
can be taken for a node n 2 N. An action a 2 A is in eA[n] if: else:
delNode(n) (note 7)
(i) for all c in C such that n.nStatus[c] = c.lft, a.vect[c] = 1 Go to Step (1).
(ii) for all c in C such that n.nStatus[c] 6 c.wMin, a.vect[c] = 0
(iii) for all c in C such that n.nStatus[c] P c.wMin, a.vect[c] = 1.
Thus, for an action a to be eligible, it must replace all the com- Note 1 indicates that if we reach step 1 after having generated
ponents that have reached their lifetime and any that have more than the total number of nodes allowed, the algorithm stops.
exceeded the max window (wMax) and not replace any compo- In this case, the algorithm is a heuristic only with the best known
nents that have not yet reached the minimum window (wMin). cost recorded in node nT. If on the other hand the Stop occurs
In our implementation, the set eA[n] is ordered by cost, inheriting because the only node in OPEN is the artificial node nT, the tree
the cost order of A. has been exhausted and the algorithm is exact.
In order to implement the DFS, we maintain OPEN as a stack. If we reach a child node of node n (note 2) with the total cost
When we Push nodes to OPEN, they are put on the top of the stack already equal or more than the BestCost found to date, this node
290 E.A. Gunn, C. Diallo / Computers & Industrial Engineering 90 (2015) 281–291
cannot be part of the optimal path and we do not need to con- cNames = [‘c1’, ‘c2’, ‘c3’, ‘c4’]
sider this node further. Because the action set is ordered in cCosts = [1.5, 3, 2.2, 3.4]
increasing cost, any other potential child nodes that emanate from cLife = [25, 22, 45, 43]
node n will also be more expensive than BestCost and do not need cWmin = [15, 10, 30, 30]
to be generated and we can BREAK the action loop. Thus a lot of cWmax = [23, 18, 40, 40]
potential nodes in the depth first search tree are never even cStat = [25, 15, 42, 32]
generated.
If the action a results in a total time to the next node that is less The actions are shown below sorted by action cost. In addition
than the completion time (note 3), then at least one more action to the direct cost of action in terms of component cost, there is also
will be required to meet the total MaxTime requirement. Thus, a fixed cost of teardown of 2.2. The program treats this separately
even though the cost to this potential node is less than BestCost, and adds it to the a.cst shown below.
it has to be less than the BestCost plus the cost of at least one more Actions
action to be considered. If it passes this test then the action creates
a new node in N and is also added to the set of children of node n a (a.cst, a.tm, a.vect)
(note 4). 0 (1.5, 25, [1, 0, 0, 0])
If on the other hand the action a results in a new node with a 1 (2.2, 45, [0, 0, 1, 0])
time to reach it greater than MaxTime, then since the total cost 2 (3, 22, [0, 1, 0, 0])
of this action is less than BestCost (note 5) this is a new optimal 3 (3.4, 43, [0, 0, 0, 1])
path. In this case, we use the delNode(nT) procedure to delete 4 (3.7, 25, [1, 0, 1, 0])
the previous terminal node and recreate the terminal node as the 5 (4.5, 22, [1, 1, 0, 0])
child of node n resulting from action a. 6 (4.9, 25, [1, 0, 0, 1])
If any new nodes were added in the action loop (note 6), 7 (5.2, 22, [0, 1, 1, 0])
including the possible new terminal node nT, all these 8 (5.6, 43, [0, 0, 1, 1])
new nodes are then placed back in OPEN, except node nT 9 (6.4, 22, [0, 1, 0, 1])
which is already there. A procedure that we have used is to 10 (6.7, 22, [1, 1, 1, 0])
put them in OPEN in reverse order of their creation, this means 11 (7.1, 25, [1, 0, 1, 1])
that the last child put into OPEN, which will be the next node 12 (7.9, 22, [1, 1, 0, 1])
popped from open, is the cheapest of all the children of 13 (8.6, 22, [0, 1, 1, 1])
the current node n. Thus our implementation of the depth first 14 (10.1, 22, [1, 1, 1, 1])
search is a deepest and cheapest search. Obviously, other
options are possible. In the following when a new node is created we see the node #,
If no children were created for node n (note 7), then it is not a its parent, the action that created it, the new cost at the time
possible node to reach the terminal node. The delNode(n) proce- resulting from that node and action as well as the new time. The
dure is a key part of the code. It deletes the current node n from format here is Nnodes, parent, action, newCst, newTime. Whenever
both N and from the children of n.pred. If the set of children of n a new solution is found, we have Node, BestCost, action, the node
is empty, it then makes the node n.pred the current node n and from which that solution emanates, the new BestCost and the
calls itself again. This effectively implements the node deletion action taken to reach the end. Whenever we call the DelNode pro-
procedure discussed by Bertsekas (2000). This procedure is very cedure, the node being deleted is printed. The overall run is shown
effective in keeping the total number of nodes in N very small even below starting with the original calculation of the cost without
when the total number of generated nodes becomes large. Note opportune replacement.
also that the other place that delNode() is used is in the case of
finding a new path to the terminal node. Deleting this node and Total Cost without Opp. Replacement: 32.2
then recursively its predecessors as far as possible, means that Nnodes, parent, action, newCst, newTime 2 1 4 5.9 7
we no longer need to retain the part of the tree that leads to what Nnodes, parent, action, newCst, newTime 3 1 10 8.9 11
is no longer a possible optimal path. Nnodes, parent, action, newCst, newTime 4 1 11 9.3 7
As indicated above, it has been convenient to implement this Nnodes, parent, action, newCst, newTime 5 1 14 12.3 22
algorithm in Python. Using the Python dictionary structure for Nnodes, parent, action, newCst, newTime 6 2 2 11.1 11
the set of nodes means that one can add a new element merely Nnodes, parent, action, newCst, newTime 7 2 9 14.5 25
by defining a new index and letting that index refer to a new Nnodes, parent, action, newCst, newTime 8 6 3 16.7 25
object in the dictionary and even more importantly, it is very Nnodes, parent, action, newCst, newTime 9 8 0 20.4 29
easy to delete objects from the dictionary. The very easy class Nnodes, parent, action, newCst, newTime 10 8 5 23.4 45
definitions in Python are helpful as are the ability to use recur- Nnodes, parent, action, newCst, newTime 11 9 2 25.6 45
sions in creating actions and deleting nodes. Python is not New Solution Found, Node, BestCost, action 11 30.0 1
meant for speed so that the results discussed in the next section In delNode deleting node 10
should be seen as underestimates of what could be achieved in Nnodes, parent, action, newCst, newTime 12 7 0 18.2 29
C or C++. Nnodes, parent, action, newCst, newTime 13 7 5 21.2 45
Nnodes, parent, action, newCst, newTime 14 12 2 23.4 45
Appendix B. Illustration of node creation and deletion process In delNode deleting node 11
In delNode deleting node 9
The output below is directly taken from a run of the program In delNode deleting node 8
with print options turned on. This example is small enough that In delNode deleting node 6
the interested reader can draw the entire tree based on the New Solution Found, Node, BestCost, action 14 27.8 1
results shown below. The problem has only four components. In delNode deleting node 13
The component names, lifetimes, minimum replacement Nnodes, parent, action, newCst, newTime 15 3 3 14.5 22
window, maximum replacement window and initial status are Nnodes, parent, action, newCst, newTime 16 3 9 17.5 25
shown below. Nnodes, parent, action, newCst, newTime 17 15 2 19.7 25
E.A. Gunn, C. Diallo / Computers & Industrial Engineering 90 (2015) 281–291 291
Nnodes, parent, action, newCst, newTime 18 15 5 21.2 44 Bian, L., & Gebraeel, N. (2014). Stochastic modeling and real-time prognostics for
multi-component systems with degradation rate interactions. IIE Transactions,
Nnodes, parent, action, newCst, newTime 19 17 0 23.4 44
46, 470–482.
In delNode deleting node 19 Chang, C.-C. (2014). Optimum preventive maintenance policies for systems subject
In delNode deleting node 17 to random working times, replacement, and minimal repair. Computers &
In delNode deleting node 18 Industrial Engineering, 67, 185–194.
Cho, D. I., & Parlar, M. (1991). A survey of maintenance models for multi-unit
In delNode deleting node 15 systems. European Journal of Operational Research, 51, 1–23. http://dx.doi.org/
Nnodes, parent, action, newCst, newTime 20 16 0 21.2 33 10.1016/0377-2217(91)90141-H.
In delNode deleting node 20 Dekker, R., Wildeman, R. E., & Van Der Duyn Schouten, F. A. (1997). A review of
multi-component maintenance models with economic dependence.
In delNode deleting node 16 Mathematical Methods of Operations Research, 45, 411–435.
In delNode deleting node 3 Do Van, P., Barros, A., Bérenguer, C., Bouvard, K., & Brissaud, F. (2013). Dynamic
Nnodes, parent, action, newCst, newTime 21 4 2 14.5 25 grouping maintenance with time limited opportunities. Reliability Engineering &
System Safety, 120, 51–59.
Nnodes, parent, action, newCst, newTime 22 21 0 18.2 29 Grigoriev, A., van de Klundert, J., & Spieksma, F. C. (2006). Modeling and solving the
Nnodes, parent, action, newCst, newTime 23 21 5 21.2 43 periodic maintenance problem. European Journal of Operational Research, 172,
Nnodes, parent, action, newCst, newTime 24 22 2 23.4 43 783–797.
Gustavsson, E., Patriksson, M., Stromberg, A.-B., Wojciechowski, A., & Onnheim, M.
In delNode deleting node 24 (2014). Preventive maintenance scheduling of multi-component systems with
In delNode deleting node 22 interval costs. Computers & Industrial Engineering, 76, 390–400.
In delNode deleting node 23 Kececioglu, D., & Sun, F.-B. (1995). A general discrete-time dynamic programming
model for the opportunistic replacement policy and its application to ball-
In delNode deleting node 21
bearing systems. Reliability Engineering & System Safety, 47, 175–185. http://dx.
In delNode deleting node 4 doi.org/10.1016/0951-8320(94)00047-R.
Nnodes, parent, action, newCst, newTime 25 5 2 17.5 25 Laggoune, R., Chateauneuf, A., & Aissani, D. (2009). Opportunistic policy for optimal
Nnodes, parent, action, newCst, newTime 26 5 5 19.0 43 preventive maintenance of a multi-component system in continuous operating
units. Computers & Chemical Engineering, 33, 1499–1510.
Nnodes, parent, action, newCst, newTime 27 25 0 21.2 43 Laggoune, R., Chateauneuf, A., & Aissani, D. (2010). Impact of few failure data on the
In delNode deleting node 27 opportunistic replacement policy for multi-component systems. Reliability
In delNode deleting node 25 Engineering & System Safety, 95, 108–119.
L’Ecuyer, P., & Haurie, A. (1983). Preventive replacement for multicomponent
In delNode deleting node 26 systems: An opportunistic discrete-time dynamic programming model. IEEE
In delNode deleting node 5 Transactions on Reliability, R-32, 117–118. http://dx.doi.org/10.1109/
TR.1983.5221494.
Liu, B., Xu, Z., Xie, M., & Kuo, W. (2014). A value-based preventive maintenance
The solution is shown below in the form node, [child action]. policy for multi-component system with continuously degrading components.
The node that is the predecessor of the terminal node 2 is 14 Reliability Engineering & System Safety, 132, 83–89.
reached by the action 1, node 14 was reached from 12 by action Moghaddam, K. S., & Usher, J. S. (2011). A new multi-objective optimization model
for preventive maintenance and replacement scheduling of multi-component
2, node 12 was reached from 7 by action 0, node 7 was reached systems. Engineering Optimization, 43, 701–719.
from 2 by action 9, and node 2 was reached from 1 by action 4. Nguyen, K.-A., Do, P., & Grall, A. (2015). Multi-level predictive maintenance for
Nnodes, BestCost: 27 27.8 multi-component systems. Reliability Engineering & System Safety, 144, 83–94.
Nicolai, R. P., & Dekker, R. (2008). Optimal maintenance of multi-component
systems: A review. In K. A. H. Kobbacy & D. N. P. Murthy (Eds.), Complex system
14 [(2, 1)] maintenance handbook springer series in reliability engineering (pp. 263–286).
12 [(14, 2)] London: Springer.
7 [(12, 0)] Nowakowski, T., & Werbika, S. (2009). On problems of multicomponent system
maintenance modelling. International Journal of Automation and Computing, 6,
2 [(7, 9)] 364–378.
1 [(2, 4)] Sethi, D. (1977). Opportunistic replacement policies. In Tsokos & Shimi (Eds.), The
Current length of NodeDict: 6 theory and applications of reliability (pp. 433–447). Academic Press.
Tambe, P. P., Mohite, S., & Kulkarni, M. S. (2013). Optimization of opportunistic
Maximum Length of NodeDict: 14 maintenance of a multi component system considering the effect of failures on
Elapsed Time = 0.219618 s quality and production schedule: A case study. International Journal of Advanced
Manufacturing Technology, 69, 1743–1756.
Vu, H. C., Do, P., Barros, A., & Bérenguer, C. (2015). Maintenance planning and
Note that even though the tree had 4 levels not counting the ini- dynamic grouping for multi-component systems with positive and negative
tial node and the terminal node, and thus potentially 154 = 50,625 economic dependencies. IMA Journal of Management Mathematics, 23, 145–170.
Xia, T., Jin, X., Xi, L., & Ni, J. (2015). Production-driven opportunistic maintenance for
nodes in total, the various considerations in the depth first search
batch production based on mamapb scheduling. European Journal of Operational
algorithm resulted in only 27 nodes ever being generated, with Research, 240, 781–790.
only 14 ever in the tree at any one time. Most of these 14 happened Ye, Z.-S., & Xie, M. (2015). Stochastic modelling and analysis of degradation for
early; 11 nodes were generated to find the first solution and only highly reliable products. Applied Stochastic Models in Business and Industry, 31,
16–32.
one deleted in that period. From then on, the deletion process kept Zhang, X., & Zeng, J. (2015a). Deterioration state space partitioning method for
the tree very small. In big problems, this relatively small active tree opportunistic maintenance modelling of identical multi-unit systems.
size is even more dominant. International Journal of Production Research, 53, 2100–2118.
Zhang, X., & Zeng, J. (2015b). A general modeling method for opportunistic
maintenance modeling of multi-unit systems. Reliability Engineering & System
References Safety, 140, 176–190.
Zhou, X., Lu, Z., & Xi, L. (2010). A dynamic opportunistic preventive maintenance
Ab-Samat, H., & Kamaruddin, S. (2014). Opportunistic maintenance (om) as a new policy for multi-unit series systems with intermediate buffers. International
advancement in maintenance approaches. Journal of Quality in Maintenance Journal of Industrial and Systems Engineering, 6, 276–288.
Engineering, 20, 98–121. Zhou, X., Xi, L., & Lee, J. (2009). Opportunistic preventive maintenance scheduling
Bertsekas, D. P. (1998). Network optimization: Continuous and discrete models. for a multi-unit series system based on dynamic programming. International
Belmont, MA: Athena Scientific. Journal of Production Economics, 118, 361–366.
Bertsekas, D. P. (2000). Dynamic programming and optimal control (2nd ed.).
Belmont, Massachusetts: Athena Scientic.