Computers & Industrial Engineering 90 (2015) 281–291

Contents lists available at ScienceDirect

Computers & Industrial Engineering

journal homepage: www.elsevier.com/locate/caie

Optimal opportunistic indirect grouping of preventive replacements

in multicomponent systems
Eldon A. Gunn, Claver Diallo ⇑
Department of Industrial Engineering, Dalhousie University, 5269 Morris Street, PO Box 15000, Halifax, NS B3H-4R2, Canada

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.

1. Introduction values are beyond their control. These periodicities have to be

Many multicomponent systems used in industrial applications
requiring high reliability such as air transportation, military
equipment, high-pace production systems are usually required to
undergo preventive replacements (PR) of key components or sub-
systems at repeating intervals often specified in terms of operating
hours before any major failure can occur. Due to the contribution
of these components or subsystems to the overall system reliabil-
ity, each is required to be replaced within a very strict replacement
window. Failure to do so can result in the grounding of the fleet or
equipment by regulatory authorities. It is very common for these
components to have replacement windows with different periodic-
ities or component lives. Because, there is generally a very high
fixed cost to bring such systems to the repair facilities and have
them opened to carry out the replacements of components, it is
often more economical to conduct opportunistic replacements of
other components that are within their replacement window. For
the owners of such equipments, the periodicities of preventive
maintenance (PM) actions are already set and changes to these
⇑ Corresponding author.
E-mail addresses: eldon.gunn@dal.ca (E.A. Gunn), claver.diallo@dal.ca (C. Diallo).
strictly followed. The sole margin of action resides in the possibil-
ity of carrying out a replacement ahead of it scheduled time when
another replacement falls within its window of replacement.
Components are said to be economically dependent if the cost
of replacing several components jointly in a system is less than
the sum of the cost of several separate replacements of the same
components (see Cho & Parlar (1991)). For these economically
dependent components the opportunistic replacement policy is
usually found to be optimal. Given the high fixed teardown cost,
it is reasonable to assume that combining two or multiple replace-
ments will yield substantial savings. However, moving forward the
PR of a component (opportunistic replacement) to have it jointly
performed with another replacement will change the replacements
dates of subsequent replacements and possibly prevent a naturally
occurring opportunistic replacement from taking place (see Fig. 1).
Parts (a) and (b) of Fig. 1 show the replacements instants of two
components with periodicities T 1 and T 2 . Part (c) displays the
superposition of the replacement instants of both components.
There is a naturally occurring grouping of PM actions at instant
5T 1 which is the same as instant 4T 2 . Part (d) of Fig. 1 depicts
the effect of carrying out the first replacement of the second com-
ponent at instant T 1 . Advancing the replacement of component 2,

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
Fig. 1. Example of PM grouping for a two-component problem.
undoes the naturally occurring grouping that were to happen at
time 4T 2 . Therefore, a myopic grouping of maintenance activities
that considers short-term gains (shortsighted policy) is not guaran-
teed to work. All possible actions and their effects over the
planning horizon have to be considered.
In the literature devoted to the modeling and optimization of
maintenance activities for multicomponent systems, many papers
have dealt with the determination of optimal opportunistic
replacements: Sethi (1977), L’Ecuyer and Haurie (1983),
Kececioglu and Sun (1995), Grigoriev, van de Klundert, and
Spieksma (2006), Zhou, Xi, and Lee (2009), Laggoune,
Chateauneuf, and Aissani (2010), Moghaddam and Usher (2011),
Tambe, Mohite, and Kulkarni (2013), and Vu, Do, Barros, and
Bérenguer (2015). The multicomponent models are classified by
Cho and Parlar (1991) based on the dependence/interaction
between the components and yield three types of dependence:
economic, structural and stochastic. Recent reviews on multicom-
ponent systems maintenance can be found in Nicolai and Dekker
(2008), Nowakowski and Werbika (2009) and Ab-Samat and
Kamaruddin (2014). Nowakowski and Werbika (2009) proposed
several schemes to classify these multicomponent models into
groups including the opportunistic models group. Since then, many
variants of opportunistic models have appeared covering a variety
of PM actions, corrective actions, perfect or imperfect maintenance,
performance measures, maintenance costs, solutions methods and
applications. For example, Laggoune, Chateauneuf, and Aissani
(2009) proposed an approach to determine a PM plan for a
multi-component series system subjected to random failures,
where the cost rate is minimized under general lifetime distribu-
tion. In Laggoune et al. (2010), the authors extended their previous
model to handle small size failure data samples by applying the
Bootstrap technique. Moghaddam and Usher (2011) developed a
multiobjective optimization model to determine the optimal pre-
ventive maintenance and replacement schedules in a repairable
multi-component system under three possible actions: mainte-
nance, replacement, or do nothing. A plan of actions for each
component in the system is determined while minimizing the total
cost and maximizing overall system reliability simultaneously over
the planning horizon. A generational genetic algorithm and a sim-
ulated annealing metaheuristics are designed to solve the obtained
mathematical model. Zhou, Lu, and Xi (2010) proposed an
opportunistic preventive maintenance policy for multi-unit series
systems based on dynamic programming which maximizes the
short-term cumulative opportunistic maintenance cost savings.
Tambe et al. (2013) presented an approach for opportunistic main-
tenance decision making for a multi-component system at planned
as well as unplanned opportunities. The authors then applied their
model to a real-life case study of a high pressure die casting
machine. Gustavsson, Patriksson, Stromberg, Wojciechowski, and
Onnheim (2014) introduced the preventive maintenance schedul-
ing problem with interval costs, which is used to schedule PM of
the components of a system over a finite and discretized time hori-
zon. Their model and solutions methods are applied to three cases:
maintenance of rail grinding, scheduling component replacements
in aircraft engines, and components replacement in wind mills in a
wind farm. Do Van, Barros, Bérenguer, Bouvard, and Brissaud
(2013) presented a dynamic grouping maintenance strategy for
multicomponent systems with positive economic dependence.
Chang (2014) developed three optimal PM policies for systems
subject to random working times and minimal repairs. Nguyen,
Do, and Grall (2015) developed a novel predictive maintenance
policy with multi-level decision-making for multicomponent
systems with complex structure.
More recently, with advances in degradation modeling (see Ye
& Xie (2015) for a review), models have appeared that use the
degradation information to guide the selection of components to
be opportunistically replaced. Bian and Gebraeel (2014) pro-
posed a stochastic modeling framework to characterize the inter-
actions between the degradation processes of interdependent
components. Liu, Xu, Xie, and Kuo (2014) developed a two-phase
approach to optimize the PM policy for a system with continuously
degrading components. Zhang and Zeng (2015a, 2015b) dealt with
the modeling of deterioration state space partitioning methods for
the opportunistic maintenance modeling of identical multi-unit
systems with economic dependence. Xia, Jin, Xi, and Ni (2015)
developed a novel production-driven opportunistic maintenance
strategy considering both machine degradation and the character-
istics of batch production.
According to Dekker, Wildeman, and Van Der Duyn Schouten
(1997), components subject to PM actions can be grouped to
jointly undergo PM actions in order to save on teardown (set-up,
preparation) costs. The models dealing with the grouping of PM
are split in two classes: the fixed group models where all compo-
nents are always jointly maintained and the optimization over
groups models in which several groups are optimally generated.
Dekker et al. (1997) presents an extensive coverage of the both
groups of models. The optimization over groups models are further
divided in two classes: direct grouping where the components are
partitioned into a number of fixed groups which are always main-
tained together and the indirect grouping where the groups are not
fixed over time, but are formed indirectly when the maintenance of
different components coincide.
In this paper, we propose a new model for grouping PM actions
for multiple major components/subsystems with windows of
replacement not exceeding their mandatory replacement periodic-
ities. This is a problem commonly encountered in the maintenance
of fleets of high reliability systems used for air transportation,
naval, mining, oil & gas, and military operations. The proposed
model was used to solve a maintenance grouping problem for a
company contracted to maintain engines used in the aerospace
industry. The cost of removing a helicopter or aircraft from the
flight schedule and sending it to the contractor for the duration
of the maintenance activities is significantly higher than the cost
of several of the major components to be replaced. These highly
reliable systems have high level of redundancy where individual
parts can fail without major components or subsystems failing.
For these systems, failed parts are replaced at the earliest conve-
nient time (overnight, next scheduled stop or landing, etc.) without
affecting the overall age of subsystems/major components
(minimal repair). Therefore, the grouping problem is only con-
cerned with the PM actions and does not include corrective
actions. The PM actions are carried out on groups of subsystems
for which manufacturers or regulators have set mandatory replace-
ment periodicities not to be exceeded.
 E.A. Gunn, C. Diallo / Computers & Industrial Engineering 90 (2015) 281–291
2. Problem definition
The following notation is used.
T finite maintenance planning horizon
n number of major components or subsystems in the
multicomponent system
c index of major components or subsystems,
c 2 f1; 2; . . . ; ng
K fixed teardown/setup cost for each preventive
replacement activity regardless of the number of
components/subsystems replaced
Sc current age or status of major component/subsystem c
Tc preventive maintenance replacement periodicity for
major component c
Ec start of the opportunistic preventive replacement window
for component c
Fc end of the opportunistic preventive replacement window
for component c
kc unit acquisition and replacement cost for component c
We consider a complex system with n major components or
subsystems. Each major component c requires PR with fixed peri-
odicity T c . At the beginning of the planning process, the current
age or status of component c is Sc . Sc = 0 means that the component
has just been replaced. Each component has an allowable early
replacement window defined by [Ec ; F c ]. Before Ec , the component
is not eligible for opportunistic grouping. Between F c and T c , the
component will certainly be replaced if an opportunity arises
(i.e., another component is due to be replaced). Between Ec and
F c , the component is eligible for an early replacement and the
model must decide if an opportunistic grouping will be made or
not. If a grouping is made and the component replaced, then a
new cycle begins again for the component (see Fig. 2). Note that
without any loss of generality, F c can be equal to T c which would
cause computation time to increase because of the increase in
the width of the allowable replacement window.
The problem is then to determine the optimal schedule of PR
that will minimize the total PM cost over a finite operation horizon
T. There is a fixed teardown (set-up) cost K for each PM activity
regardless of the number of components replaced. Each component
c costs kc to acquire and replace. This new model falls under the
indirect grouping class. It should be noted that we do not consider
subsystem or major component failures in this paper. This paper is
about opportunistic grouping of PM actions for highly reliable sys-
tems such as aircraft or helicopters with high level of redundancy
where individual parts can fail without major components or sub-
systems failing. For these systems, failed parts are replaced at the
earliest convenient time (overnight, next scheduled stop or land-
ing, etc.) without affecting the overall age of the multicomponent
system (minimal repair). The minimal repair cost is mainly due
to bringing the aircraft/helicopter in the hangar, troubleshooting,
finding and swapping the defective module, testing and releasing.
The cost of the modules/parts are not significant enough to affect
the total cost of the minimal repair so that it is considered constant
Fig. 2. Periodic PM with allowable opportunistic replacement window.
283
and is not included in the cost model to be optimized. On the other
hand, the PM replacements of subsystems/major components are
done at a subcontractors facilities where the aircraft/helicopter
stays much longer. These costs are very high and the downtime
are long therefore there is a need to opportunistically group some
of these replacements. The PM actions are carried out on groups of
subsystems for which manufacturers or regulators have set
mandatory replacement schedules.
The problem is modeled as a shortest path problem with
replacement cost as distance. Depending on the widths of the
replacement windows [Ec ; F c ] and the length of the exploitation
horizon T, the number of combinations (nodes) to evaluate
explodes and an efficient search method is devised to reduce the
search space, limit memory usage, reduce computation time and
guarantee optimality.
The paper is structured as follows. In Section 3, the formulation
of the problem as a shortest path problem is presented. In Section 4,
the modified label correcting algorithm used to optimally solve the
problem is presented. Section 5 is devoted to the discussion of
numerical results.
3. Problem formulation
We are given n components with PM periodicities T c where
c ¼ 1; 2; . . . ; n. The goal is to find the minimum-cost schedule of
PM actions over the horizon T with all replacements carried-out
within their required periodicities. To convert this problem to a
shortest path problem, we define a tree structure with nodes and
arcs. Each node is assigned an n-dimension vector of zeros (no
PM) and ones (PM) representing the replacement status of the
components at the time of a mandatory PM action. The cth element
of the n-dimension vector represents the PM action of component
c. There are two artificial nodes: a starting node, called node 0, rep-
resenting the top of the tree and a terminal node denoted F where
all preceding nodes connect with arc lengths of 0.
Any node in the tree, except the terminal node, has 2n  1
potential children nodes, each representing a possible combination
of PM decisions at the time of the earliest of the next mandatory
PM actions. The vector with all elements equal to 0 is not a practi-
cal replacement decision. Therefore, it is never created. Further-
more, each node has 2n  n effective children nodes. Among the
vectors representing the 2n  1 potential children nodes, there
are n unit vectors with only one element equal to 1 and n  1
elements equal to zero. Only one such unit vector represents a
valid replacement decision corresponding to the replacement of
the component with the nearest replacement time. Therefore, the
other n  1 unit vectors should not be generated. Hence, the
2n  n effective children nodes.
For illustration purposes, a simple example with two compo-
nents 1 and 2 is considered with the following parameters:
S1 ¼ 25; T 1 ¼ 25; E1 ¼ 15; F 1 ¼ 23; S2 ¼ 11; T 2 ¼ 22; E2 ¼ 10; F 2 ¼ 18,
and T ¼ 60. Fig. 3 depicts the replacement sequence of the example
for the first five nodes. The related costs are K ¼ 0:5; k1 ¼ 2, and
k2 ¼ 3 in some monetary unit.
When at node 0 and attempting to create the first 2 (22  2)
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
represent the jumping from one PM activity to the next scheduled
284 E.A. Gunn, C. Diallo / Computers & Industrial Engineering 90 (2015) 281–291
Fig. 3. A simple 2-component problem.
PM action, at which point components with overlapping allowable
replacement windows are considered for opportunistic grouping.
The length of an arc is equal to the total replacement cost
(set-up cost + variable costs) to carry out the PM actions of the
destination node.
Another feature added to the tree is the time labeling of the
nodes to keep track of the time instants at which the PM activities
defined in a node are carried out. When creating a child node, if the
time label of the child exceeds the planning horizon T, then the
child node is not created and the parent node is directly connected
to the terminal node with an arc of length 0. Each node features
vectors S and Sþ representing the age/status of the components
right before and right after the replacement actions, respectively.
When at parent node 2 and attempting to create the children
nodes 5 and 6, the earliest PM action is at time 11 for component
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
between node 2 and node 5 has an infinite length or cost because
component 1 cannot be opportunistically replaced along with
component 2 at time 11 as it is not within the allowable replace-
ment window of component 1. The complete tree for the example
is presented in Fig. 4.
A quick enumeration of all the paths shows that the shortest
path is 0-1-4-10-F (i.e., replace both components together at time
0, time 22 and then at time 44 for a total cost of 16.5). If the
components are replaced without the opportunistic grouping then
the total cost is 18. The path 0-2-6-12-22-29-30-F has length 18
and corresponds to the replacements without grouping.
If T is increased to 67, the shortest path is easily found to be
0-2-6-11-19-F (i.e., replace component 1 alone at time 0, replace
component 2 alone at time 11, replace both components at time
25, and replace both components again at time 47 for a total cost
of 17 compared to a total cost of 18 without grouping of PM actions).
This small example shows how the problem can be modeled as
a tree and solved with a shortest path method to yield significant
savings. It should be noted that 26 nodes were generated for this
2-component problem with T ¼ 60.
In the next section, we present a short argument for the choice
of the Depth-First Search (DFS) algorithm to solve the opportunis-
tic indirect grouping problem for a moderately large number of
components and longer planning horizon.
4. The modified label correcting algorithm
Bertsekas (2000) presents a series of shortest paths methods
and algorithms. A general type of shortest path algorithm is the
Label Correcting Algorithm which works by progressively finding
shorter paths from the origin node to every other node i, and
keeping the length of the current shortest path in a variable di
called label of node i. Initially, the origin node has a label of value
0 and all other nodes have labels of infinite value. The algorithm
maintains a list of nodes called OPEN which contains nodes that
 E.A. Gunn, C. Diallo / Computers & Industrial Engineering 90 (2015) 281–291
Fig. 4. Shortest path formulation for a 2-component problem.
are candidates for further consideration and possible inclusion in
the shortest path. Initially, OPEN contains the originating node
(node 0 in our case). The steps of the label correcting algorithm
are given below with aij being the arc length between nodes i
and j, and UB is an upper bound of the shortest distance.
Step 1: Remove node i from OPEN, and for each child j, execute
Step 2.
Step 2: If di þ aij < minfdj ; UBg, set dj ¼ di þ aij and set i to be the
parent of j. In addition if j – F, place j in OPEN if it is not already
in OPEN, while if j ¼ F, set UB = dF ¼ di þ aiF .
Step 3: If OPEN is empty, terminate; else go back to Step 1.
Bertsekas (2000) also shows how the label correcting algorithm
gives rise to different shortest path methods based on how a node
is removed from OPEN. Removing a node from OPEN using the
first-in/first-out policy yields the Breadth-First Search also known
as the Bellman-Ford method. Whereas, the last-in/first-out (LIFO)
policy yields the depth-first search (DFS) which has been proven
to have low memory requirements. If a node is removed from
OPEN based on the minimum value of its label, then the Dijkstra’s
method is obtained Bertsekas (1998).
285
Given the large number of potential nodes to be examined and
the related high memory requirements, the DFS method is
selected. In our implementation, the initial value of UB is set to
the total replacement cost without grouping instead of 1 as sug-
gested by the basic Label Correcting Algorithm. Appendix A gives
the full details of the Python implementation.
Fig. 5 depicts the tree generated for the 2-component example
using the algorithm described in Appendix A. A node with dashed
arc and dashed circle is a terminal node that is not created because
the cost at that node is already greater than the best cost previ-
ously found. It can be seen that Fig. 5 contains far less nodes than
Fig. 4: 17 nodes instead of 26. Another illustrative example with 4
components is presented in Appendix B.
5. Results and discussions
The DFS algorithm presented above was implemented in Python
and run on a 2.99 GHz Window XP PC with 1.96 Gb of RAM. Several
experiments were then conducted to test the algorithm on a
moderate size problem, and then investigate the impact of the
number of components on the savings achieved, and the effects
of the length of the horizon T.
286 E.A. Gunn, C. Diallo / Computers & Industrial Engineering 90 (2015) 281–291

Fig. 5. Our DFS algorithm applied to the 2-component example.

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.

Number of T Problem 8.1 Problem 8.2

components
50 80 100 150 200 250 300 350 K = 3.2 and T = 200 K = 2.2 and T = 350
Node # Total cost Savings (%) Node # Total cost Savings (%)
2 0.0 20.7 13.8 15.9 14.6 11.9 14.6 15.4
3 8.3 21.7 10.4 18.0 17.6 15.9 18.3 18.3 0 303.7 0.0 0 438.5 0.0
4 13.2 23.9 14.6 19.4 19.5 17.6 20.5a – 240 263.4 13.3 385 390.2 11.0
5 18.0 22.0 15.6 18.3 18.5 17.3a – – 250 260.2 14.3 418 388.0 11.5
6 18.4 20.3 16.9 14.5a – – – – 293 257.2 15.3 700 385.8 12.0
7 16.7 20.1 19.3 16.9a – – – – 348 257.0 15.4 4035 383.6 12.5
8 19.8 20.7 21.4a – – – – – 1192 256.7 15.5 48,111 381.4 13.0
9 19.7 18.2a – – – – – – 1638 253.8 16.4 2,282,596 379.2 13.5
10 19.5 – – – – – – – 4732 253.5 16.5 5,901,801 377.0 14.0
4809 253.3 16.6
– Calculations not attempted. 5184 250.6 17.5
a
Calculations interrupted after 25 million nodes and best solution reported. 10,976 249.3 17.9
12,926 249.1 18.0
34,379 247.4 18.5
For the instance of the problem considered, savings between 8% 197,075 244.4 19.5
and 23.9% are achieved with a fixed teardown cost at about the 238,040 244.2 19.6
356,667 243.9 19.7
same level as the cheapest component. In real problems, the tear-
516,597 243.6 19.8
down costs are usually higher meaning that substantially higher 5,158,550 241.2 20.6
savings can be obtained. It is difficult to draw general conclusions 14,745,259 241.0 20.7
from the specific numerical results obtained here but general
trends can be inferred. As the number of components increase,
the savings also increase as many potential allowable opportunis-
Table 4
tic PM ranges arise at the time of a scheduled PM. Another general Ten component heuristic runs.
trend is that the savings tend to increase as the exploitation hori-
Problem 10.1 Problem 10.2
zon increases and then stabilize after a while as the replacement
patterns start to repeat. K = 2.2 and T = 200 K = 2.2 and T = 350
Node # Total cost Savings (%) Node # Total cost Savings (%)
For the larger problems, such as 8–10 components, and more
than 100 time periods, it is obviously unrealistic to attempt to 0 306.8 0.0 0 534.5 0.0
500 273.9 10.7 730 470.8 11.9
solve the problem exactly. However, the algorithm can be used
504 271.7 11.4 928 468.6 12.3
as an effective heuristic by stopping its execution at a relatively 531 270.9 11.7 1045 466.4 12.7
small number of nodes (MaxNodes in Step 1) such as 200,000 or 551 268.7 12.4 2174 464.2 13.2
1,000,000. The running time for the algorithm with 10 compo- 6167 267.3 12.9 87,886 461.2 13.7
nents, T = 350 time periods MaxNodes = 200,000 is approximately 11,587 266.5 13.1 1,269,623 458.8 14.2
22,453 265.1 13.6
45 s. With MaxNodes = 1,000,000 it is approximately 245 s. Run-
56,751 264.3 13.9
times are effectively linear in MaxNodes. Two features of the DFS 86,129 262.8 14.3
make it a good heuristic. First, it rapidly finds feasible solutions. 687,090 260.6 15.1
Second, the actions that create the children are ordered in increas-
ing cost in the set eA and then pushed to the OPEN heap in reverse
order of their creation in Step 3. They are removed in least cost Table 5
order when removed from OPEN in Step 1. Thus, the search can Ten component heuristic runs with higher teardown costs.
be characterized as ‘deep and cheap.’ Problem 10.3 Problem 10.4
Tables 3–5 illustrate the heuristic performance on some larger
K = 6.2 and T = 350 K = 10.5 and T = 350
problems. Table 3 depicts every new improving solution found in Node # Total cost Savings (%) Node # Total cost Savings (%)
the algorithm and the node number at which it was found for
0 922.5 0.0 0 1339.6 0.00
two 8-component problems. In the first, Problem 8.1, the fixed 730 730.8 20.8 730 1010.3 24.58
teardown cost K was set at 3.2, quite a bit higher than the value 864 724.6 21.5 857 999.8 25.37
of 1.2 used to generate the results in Table 2 and the horizon T 948 718.4 22.1 928 989.3 26.15
was set at 200. The algorithm was run on this problem for Max- 1415 712.2 22.8 1213 978.8 26.93
10,744 706.0 23.5 4473 968.3 27.72
Nodes = 20 million nodes. In the second case, Problem 8.2, the hori- 73,313 705.9 23.5 27,669 963.9 28.05
zon T was increased to 350 and the algorithm was actually run for 106,388 699.8 24.1 35,251 957.8 28.50
MaxNodes = 10 million nodes. Note that we quite quickly find 156,910 699.7 24.2 53,456 953.4 28.83
improved solutions from the starting case but that longer running 873,147 947.3 29.28
times do not lead to much additional improvement. If we had
stopped Problem 8.1 after 200,000 nodes we would have been
within 1% of the best solution found in 20 million nodes. Note that Table 5 gives two runs with the long horizon of 350 and much higher
this difference is approximately 1 teardown fixed cost in 200 value of K. K is set at 10.5 in problem 10.4 up from 6.2 in problem
periods. We see a similar performance in problem 8.2 where 5.9 10.3. Here we see much more dramatic savings over the base case.
million nodes produces an improvement of two teardowns over A large part of these savings are due to the very first feasible path
the solution found at node 48 111. identified at node 730 but additional savings are generated as the
In Table 4, we see similar performance for 10 component algorithm proceeds. Both of these cases were run for just 1 million
problems over horizons of 200 and 350. Problem 10.2 was actually nodes. These runs took approximately 10 min each. One should
run for 10 million nodes. The improvement found after 87,886 not assume that the solutions found in Tables 4 and 5 are optimal.
nodes again amounts to one teardown cost in 350 time periods. For example, we did a run with 10 components, T ¼ 200 and
288 E.A. Gunn, C. Diallo / Computers & Industrial Engineering 90 (2015) 281–291
K ¼ 3:2. The initial cost without opportunistic replacement was
362.8. After 488,657 nodes, this had been reduced to 295.40. How-
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
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
($693.6), node 5,632,774 ($693.5), node 12,895,687($690.3),
12,944,932 ($687.3). This run, which took about 17000 s as opposed
to the 110 s to do 200,000 nodes, saved less than two teardowns
over the 350 time units. Even more interesting, is the fact that the
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
the same time 0 decision of replacing components 1 and 6. This
raises yet another point worth considering. Just because we find
better solutions over the entire time horizon by running the algo-
rithm much longer, this does not mean that the decision made at
time 0 is different. In a practical situation, one would only imple-
ment the decision at time 0 and wait until the system was next in
the maintenance shop to recompute a new replacement schedule.
Although an exhaustive study of this phenomenon is beyond the
scope of this paper, it does suggest that using this approach in what
amounts to a model predictive control mode, where a reasonable
time horizon is run for a reasonable computational effort to get a
good first decision, may well be productive.
6. Conclusion
In this paper, we considered a set of components undergoing
PM activities with PM periodicities having allowable windows for
opportunistic grouping of PM actions. The goal was to find the
minimum-cost schedule of PM actions over the horizon T with all
replacements carried-out within their required periodicities. We
converted this problem to a shortest path problem by defining an
equivalent tree structure with nodes and arcs. We developed a
Python implementation of a DFS shortest path algorithm for this
problem and solved it for moderately large problems. The actual
shortest path tree may contain many millions of nodes, but
because of the cost pruning, most of these are never even
generated. When several million of nodes are generated only a
few of them, typically a few hundreds, needed to be maintained
in memory at any one time. For very large problems where several
tens or hundreds of millions of nodes would need to be generated,
stopping the algorithm after a relatively small number of nodes can
still provide an effective heuristic solution.
The method outlined in this maintenance problem can also be
adapted to solve the joint replenishment problem in inventory
control. The authors are also investigating the implementation of
various other label correcting algorithms to solve maintenance
grouping and scheduling problems. Given that shortest path
problems can be solved using dynamic programming (DP) formu-
lations, a future extension is the development of a DP formulation
for the opportunistic grouping problem presented in this paper. It
is expected that memory requirements will cause the DP formula-
tion to be applicable to extremely small problems and that the DFS
algorithm shown here would perform better.
Additionally, recent advances in the modeling of degradation
information and imperfect maintenance can be leveraged to build
opportunistic maintenance models that are reflective of real world
maintenance problems. For example, instead of leaving the defini-
tion of the opportunity window to the decision maker as done in
this paper, it can be defined based on the level of degradation expe-
rienced by the other components when one component is due for
PM. Furthermore, we assumed that all replacements are perfect
which is not always the case in real life situations. It would be
interesting to model the impact of imperfect PM actions and
analyze their impact on the sequence of future replacements.
Acknowledgements
The authors would like to thank the anonymous referees and
the Associate Editors for their useful comments and suggestions.
This research work was supported by the Natural Sciences and
Engineering Research Council of Canada (NSERC) under Grant
CRDPJ-436347.
Appendix A. Python implementation
The implementation is in a quite simple Python program that is
available from the authors. The explanation below is meant to be
general enough that someone who is not a Python programmer
can understand it. However, we use the Python indent convention
in which a change in indentation represents the end of a loop or
conditional test. The four main sets used are:
C – a set of components,
A – a set of actions,
N – a set of nodes,
OPEN – a set of open nodes remaining to be processed.
The set C is comprised of all the major components subject to
replacement. For each c 2 C, we have the following programming
variables:
c.nam – name of the component
c.cst – cost of the component (kc )
c.lft – lifetime of the component (T c )
c.wMin – minimum age at which the component can
be replaced (Ec )
c.wMax – maximum age after which component must
be replaced if the equipment is undergoing
replacement (F c )
c.status – status of the component in terms of the
number of time units elapsed.
Time units are measured in the same units as
lifetimes.
Obviously it is possible for c.wMin = 0 and c.wMax = c.lft for
every component, but if sensible choices can be made for these
windows of opportunity, it will reduce the complexity of the over-
all search tree.
The set A is the set of all possible maintenance actions. An
action corresponds to a decision to replace a certain subset of the
components. If there are n components in C then there are 2n  1
possible actions. We consider that at any decision point, at least
one component has reached its lifetime so that at least that compo-
nent must be replaced. The actions a 2 A have:
a.cst – total cost of taking that action
a.tm – the minimum lifetime over all those components
being replaced in the action
a.vect – 0–1 vector. If a.vect[c] = 1 then component c is
replaced in action a.
The a.cst includes the cost of the replacement components plus
overall fixed charges to teardown and complete the replacement.
The a.tm indicates the time of the next action required if we
 E.A. Gunn, C. Diallo / Computers & Industrial Engineering 90 (2015) 281–291 289

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-
ponents that have reached their lifetime and any that have
exceeded the max window (wMax) and not replace any compo-
nents that have not yet reached the minimum window (wMin).
In our implementation, the set eA[n] is ordered by cost, inheriting
the cost order of A.
In order to implement the DFS, we maintain OPEN as a stack.
When we Push nodes to OPEN, they are put on the top of the stack
Note 1 indicates that if we reach step 1 after having generated
more than the total number of nodes allowed, the algorithm stops.
In this case, the algorithm is a heuristic only with the best known
cost recorded in node nT. If on the other hand the Stop occurs
because the only node in OPEN is the artificial node nT, the tree
has been exhausted and the algorithm is exact.
If we reach a child node of node n (note 2) with the total cost
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.