Reliability Analysis of Dynamic Fault Tree Based on Binary Decision Diagrams for Explosive Vehicle

Abstract

Dynamic fault tree is often used to analyze system reliability. The Markov model is a commonly used method, which can accurately reflect the relationship between the state transition process and the dynamic logic gate transfer in the dynamic fault tree. When the complexity or scale of system is increasing, the Markov model encountered a problem of state space explosion leading to increase troubles. To solve the above problems, a modular approach is needed. Based on the modular approach, a hybrid fault module was researched in this paper. Firstly, the stackable fault subtree containing complex static/dynamic logic gate is transformed into four common combinational logic gates through preprocessing of the dynamic gate in the module. Then, the complexity of the model was reduced by incorporating four common combinational logic gates and using the binary decision graph to solve variable ordering in the calculation of failure probability of static subtree. Moreover, the calculating process of complex mixed logic gate fault tree can be simplified. An example of the ammonium nitrate/fuel explosive production system for BCZH-15 explosive vehicle was used to verify the feasibility of the presented method.

This is an open access article distributed under the Creative Commons Attribution License, which permits unrestricted use, distribution, and reproduction in any medium, provided the original work is properly cited.

1. Introduction

Fault tree analysis (FTA) is a common method for the reliability modeling and evaluating large safety-critical systems as discussed in [1, 2]. The classic fault tree is a static tool, and its primary objective is to improve the safety for the probabilistic safety assessment as discussed in [3, 4]. Dynamic fault tree is an extension of common fault tree, which adds many special logic gates to express the existing problems in specific systems. Mi et al. [5] studied system action of mechatronics systems through taking the advantages of the dynamic fault tree (DFT). Fault tree analysis is a risk assessment method widely used in the process industry. Yazdi et al. [6–8] improved the traditional fault tree analysis, mainly for the study of uncertainty handling in qualitative and quantitative risk assessment procedures. The Markov model is appropriate for modeling complex systems that have traits of timing, sequencing, repair, redundancy, and fault tolerance as discussed by Ericson [9]. However, the Markov model becomes unwieldy as the system size increases. It is difficult to construct and solve Markov models for the large systems as discussed in [10–12]. Li [13] used the Bayesian network method to avoid dealing with Markov state explosion problem. Li et al. [14–16] used multiple methods such as multisource information fusion and Bayesian networks in the process of studying the reliability of offshore wind turbines. Dugan et al. [17–19] utilized dynamic gates to discern independent dynamic subtrees and used the different Markov model for each subtree through the process of modularization. As discussed by Jiang et al. [20], in solving the problem of reliability analysis and analysis of dynamic systems, fuzzy set theory is used. Huang et al. [21] proposed an improved decomposition scheme, where the dynamic subtree can be further modularized (if there exist some independent subtrees). A huge fault tree may contain dynamic subtrees and static subtrees. Use the binary decision diagram (BDD) method to calculate the failure rate of the top event of the fault tree. BDD was applied to efficiently realize synthesis of reversible functions as discussed by Mathias Soeken et al. [22]. The modularization for large fault trees before analysis can improve computational efficiency. The approach of dynamic innovative fault tree (DIF tree) as discussed in [23] exploited the modularization by combining static and dynamic analysis. Ge et al. [24] analyzed DFT using improved the sequential binary decision diagram (SBDD) method. Bandyopadhyay et al. [25] improved a design technique, where BDDs are used to construct optical circuits.

However, after the modularization, the applicability of the model should be considered for relatively complex systems. Zhang et al. [26] proposed a generalized dynamic reliability model to calculate reliability of system under complex load. In dynamic systems, the semi-Markov process (SMP) was applied to solve the problem that the lifetime of components follows nonexponential distributions as discussed by Li et al. [27]. Abimbola et al. [28] presented a risk assessment methodology for analyzing the safety of critical components based on BN as discussed in [28]. This paper studies how to use modular methods to solve system reliability problems.

In recent years, the focus on field mixed explosive vehicle research has been performed to improve or design new electrical control systems to enhance the safety of equipment; to study the advantages of equipment in special geographic locations; to improve the blasting efficiency by changing the composition of the mixed explosive. There are only a few literatures on the reliability of the equipment, and only the reliability of the equipment can meet the operating requirements and can the safety, superiority, and efficiency of the equipment be demonstrated. With the dynamic characteristics becoming more and more obvious, it is urgent to evaluate equipment reliability considering the dynamic characteristics.

The remainder of the paper is organized as follows: Section 2 introduces division method of fault tree modular and illustrates how to preprocess the dynamic fault tree’s logical gates. Section 3 investigates the static subtree BDD theory solution method. The dynamic fault tree Markov theory solution method is described in Section 4. The proposed method was applied to calculate the reliability of the explosive production system for the BCZH-15 explosive vehicle in Section 5. Finally, the conclusion of the article is presented.

2. Fault Tree Modular Analysis Method

2.1. Modular Division for Fault Tree

Rauzy et al. [29] presented the fault tree depth traversal method, which can modularize the fault tree. This method is concise and highly effective to deal with fault tree modularization problem. The deep traversal node method is used to divide module for the fault tree, which is easy to discover modules and zone. The procedure is as follows:

(1) Calculate the traverse node for the fault tree and list the results

(2) Sort the root node, leaf nodes, and the intermediate nodes and perform depth-first leftmost traversal for them

(3) Collect the information of the internal event V for the third traversal node and collect the first and the last period of each subtime to provide strong evidence for modularizing the event.

Module division for the fault tree is shown in Figure 1, and the results are shown in Tables 1 and 2.

[figure omitted; refer to PDF]

Table 1

First traversal result.

S	1	2	3	4	5	6	7	8
V	T	M1	M2	M4	A1	A2	M4	M5
S	9	10	11	12	13	14	15	16
V	A3	A4	M5	M2	M3	M5	M6	A5
S	17	18	19	20	21	22
V	A6	M6	M3	M1	A7	T

Table 2

Final traversal result.

Module name	T	M1	M2	M3	M4	M5	M6
Min	2	3	4	8	5	9	16
Max	21	19	14	18	6	10	17
Y/N	Y	Y	N	N	Y	Y	Y

In Table 1, S indicates that the fault tree executes the left traversal node rule and then passes through the number of the node in turn, and V represents the name of each node in the fault tree. The sequence is given in Table 1.

Table 1 can summarize the target node numbers that each module can reach after executing the leftmost traversal node method, and then push out whether the modules are independent. In Table 2, Min is the node number that the module first arrives, and Max is the last module. Y means that the module is a separate module, and N means a nonindependent module. The division results are shown in Table 2.

From the operations given in Table 2, it can be concluded that the part of the fault tree modulo can be divided into T, M1, M4, M5, and M6.

2.2. Preprocessing of Logic Gate

After modularizing the fault tree, it is necessary to further determine the module state (dynamic or static). The BDD method is used to calculate the subtree for the static submodule. The Markov model is applied to mold for the dynamic submodule. Since the system is divided into small modules, state explosion problem will not occur during the model processing. Due to logic gate nesting, the static submodule may contain dynamic submodule after the module division in a complex fault tree. In this case, the corresponding algorithm cannot be applied to the fault tree submodule. Preprocessing of dynamic logic gate is required for the basic fault tree, and the complex hybrid dynamic logic gate is transformed into an easy solution model, which can greatly simplify the subsequent calculation.

2.2.1. Processing of Simple Logic Gate

Pretreatment of the logic gate includes the following: copretreatment of AND gate by OR gate, pretreatment of AND gate or PAND gate, pretreatment of two kinds of PAND gate stacking, and pretreatment of FDEP gate (Figures 2–5).

[figure omitted; refer to PDF]

The above is the basic preprocessing process of logic gates.

3. BDD Subtree Calculation

The BDD method is generally applied to solve the problem of the static fault tree. The BDD method plays a great role in promoting the analysis of the static subtree. The BDD method was proposed by the American scholar Akers in 1978, as discussed in [30]. The method can transform the fault tree into a BDD only containing bottom events. The advantage of the BDD method is that the fault tree can be analyzed only using Weibull function expression without depending on intermediate events. Based on the BDD, disjoint Weibull function can be written down directly, and the minimum cut set can be obtained for qualitative analysis. The calculating amount of the method is linearly related to the scale of the graph. Therefore, it is an effective way to solve the problem that the calculating amount of the traditional FTA method increases exponentially with the scale of the fault tree.

3.1. Static Fault Tree Transformation

In the BDD conversion process, the main operation is based on the if-then-else (ite) structure of the Shannon decomposition, shown in the following equations:$$\begin{array}{c}\text{(1)}& fX=x_i{f}_i+\overline{x_i}{f}_0,\text{(2)}& f_1=f_1{x}_1,x_2,\dots ,x_{i-1},1,x_{i+1},\dots ,x_n,f_0=f_0{x}_1,x_2,\dots ,x_{i-1},0,x_{i+1},\dots ,x_n,\end{array}$$where the parent node is $x_i$ and the child nodes are $f_0$ and $f_1$.

3.1.1. Validation

Simple coding and index ordering are performed using ite for a simple fault tree. The influence of different index sorting on BDD generation is analyzed.

The fault tree is shown in Figure 6. The following equations represent the relationships among events:$$\begin{array}{c}\text{(3)}& T=x_1+G_1,G_1=x_2\cdot x_3,\\ =ite{x}_2,\mathrm{1,0}\cdot ite{x}_3,\mathrm{1,0},\\ =ite{x}_2,ite{x}_3,\mathrm{1,0},0,\\ \text{(4)}& T=ite{x}_1,\mathrm{1,0}+ite{x}_2,ite{x}_3,\mathrm{1,0},0,=ite{x}_1,1,ite{x}_2,ite{x}_3,\mathrm{1,0},0.\end{array}$$

[figure omitted; refer to PDF]

The BDD conversion graph of the fault tree is drawn by the above relationship.

3.1.2. Impact Analysis of Variable Ordering Results

At present, the optimal ordering of BDD is still under study. The mainstream BDD optimization algorithms are precise sorting algorithm and dynamic heuristic algorithm. The optimal index ranking is shown in Figure 6). When the variable order becomes index ($x_2$) > index ($x_3$) > index ($x_1$), BDD would change (Figure 7).

[figure omitted; refer to PDF]

Since the different ordering, the original six sides change to twelve sides. The calculation process is increased from two sets of equations to four groups, and variable ordering is especially critical when dealing with more complex models. It is shown that a good variable ordering is related to the complexity of the BDD.

3.2. BDD Probability Calculation

After sorting the variables, the path pointing to 0 or 1 can be obtained, where the point 1 represents the top event occurring and the point 0 represents not occurring.

3.2.1. Calculation of Top Event Probability

Determining all paths point to 1, the path is recorded as $P_{i}i=\mathrm{1,2,3},\dots ,m$, where m is the number of paths. $P_i$ is shown in the following equation:$$\begin{array}{}\text{(5)}& P_i={\displaystyle \prod _{i=1}^{n_i}{x}_{ij}^{\text{'}}},x_{ij}^{\text{'}}\in x_{ij},\overline{x_{ij}},x_{ij}\in x_1,x_2,\dots ,x_n.\end{array}$$

Disjoint expressions of the fault tree can be represented as follows:$$\begin{array}{}\text{(6)}& PT=P{\displaystyle \sum _{i=1}^m{P}_i}={\displaystyle \sum _{j=1}^m{\displaystyle \prod _{j=1}^{n_i}{x}_{ij}^{\text{'}}}}.\end{array}$$

The probability of occurrence of the top event can be calculated using probability formula of the mutual exclusion event as below:$$\begin{array}{}\text{(7)}& PT=P{\displaystyle \sum _{i=1}^m{P}_i}={\displaystyle \sum _{j=1}^m{\displaystyle \prod _{j=1}^{n_i}P{x}_{ij}^{\text{'}}}.}\end{array}$$

The probability of failure of the bottom event can be expressed as $P{x}_{ij}$.

3.3. A Case of Study

The above content is verified by an example. A, B, C, D, and E are bottom events (Figure 8). The probability of failure of the bottom event is shown in Table 3.

[figure omitted; refer to PDF]

The probability of occurrence of module M2 is calculated based on the following BDD (Figure 9). Combined with failure probability of variables D and E, the probability of occurrence of module M2 can be obtained, which is 0.405.

After obtaining the probability of occurrence of the modules M1 and M2, probability of occurrence for M3 can be further calculated (Figure 10). The BDD model of the fault tree, defined as module M3, is a combination of M1, A3, and M2.

[figure omitted; refer to PDF]

Obtain the probability of M1, M2, and A, and the probability of M3 can be calculated as 0.657.

4. Solution of Markov Model by Dynamic Fault Tree

4.1. Markov Model Theory

Continuous-time Markov decision processes provide a very powerful mathematical framework to solve widely used decision problems, as discussed by Bartocci [31]. The process can be defined as the following random process:$$\begin{array}{c}\text{(8)}& Xt,t\in T,if\forall t_0<t_1<\dots t_n<t_{n+1}\in T,PX{t}_{n+1}\le x_{n+1}|X{t}_0=x_0,X{t}_1=x_1\dots X{t}_n=x_n,\\ =PX{t}_{n+1}\le x_{n+1}|X{t}_n=x_n,\end{array}$$where $A$ is a random variable event, which occurs before time $t_n$, and event $B$ is an event that occurs afterwards. The Markov chain is shown in the following equation:$$\begin{array}{c}\text{(9)}& PB|A,X{t}_n=x_n=PB|X{t}_n=x_n,PAB|X{t}_n=x_n=PA|X{t}_n=x_{n}PB|X{t}_n=x_n.\end{array}$$

The sequence is shown as follows:$$\begin{array}{c}\text{(10)}& P{X}_{n+1}=i_{n+1}|X_0=i_0,X_1=i_1\dots X_n=i_n,=P{X}_{n+1}=i_{n+1}|X_n=i_n.\end{array}$$

4.2. Markov and Dynamic Logic Gate Transformation

In order to make the fault tree model better deal with the sequential logical relationship between the parts in the dynamic system, Dugan et al. [17] proposed the dynamic gate to represent the dynamic working relationship of the system in 1992. The Markov chain can represent the conversion relationship between system states using graphics. This graphical structure provides a visual tool to solve problems. Dynamic fault trees (DFTs) introduce four basic (dynamic) gates: the priority AND (PAND), the sequence enforcing (SEQ), the standby or spare (SPARE), and the functional dependency (FDEP), as discussed by Dugan et al. [17]. The Markov transformation process of specific dynamic logic gates will be introduced.

4.2.1. Dynamic Logic Gate Transformation

The process of converting the four common dynamic logic gates into Markov chain will be described. The four common dynamic logic gates are PAND gate, SEQ, SPARE, and FDEP, and the relevant transition diagrams are shown in Figures 11–14.

[figure omitted; refer to PDF]

The fault tree can be divided into four basic modules S1, S2, S3, and S4. In module S1, there is a submodule C consisting of static logic gates, which can be divided into static module. Modules S2 and S3 are static modules. Module S4 is divided into dynamic submodule because its subtree root node is the spare parts gate.

5.2. Fault Tree Modular Calculation

According to BDD, its nodes are firstly divided. Sorting the bottom events uses a heuristic sorting method and defined the order $index{x}_1>index{x}_2>index{x}_3$. Get BDD (Figure 17).

[figure omitted; refer to PDF]

For the transformation of the static module S2, the above method should be used. First, the heuristic algorithm is applied to determine the subunit sequencing:$$\begin{array}{}\text{(19)}& index{x}_7>index{x}_8>index{x}_9>index{x}_{10}>index{x}_{11}>index{x}_{12}>index{x}_{13}.\end{array}$$

The BDD of module S2 is shown in Figure 18.

[figure omitted; refer to PDF]

Similarly, module S3 was converted into BDD, where the sorting is defined as$$\begin{array}{}\text{(20)}& index{x}_{15}>index{x}_{16}>index{x}_{17}>index{x}_{18}.\end{array}$$

The BDD of transformation is shown in Figure 19.

[figure omitted; refer to PDF]

The module S4 contains the submodules C4 and C5, where C5 is the spare part of C4. BDD was established to solve the probability of C4 (Figure 13). The order has no succession, and Markov chain is shown in Figure 20.

[figure omitted; refer to PDF]

The failure probability of parts in the bottom event is shown in Table 4. The following data sources are from the maintenance records of the BZ15 heavy-duty oil ammonia explosive vehicle and related experimental data in the factory.

Table 4

Bottom event failure probability.

Encoding	Event	Probability (${10}^{-4}{\text{h}}^{-1}$)
${\text{X}}_1$	Line interface failure	0.5
${\text{X}}_2$	Fuel flow-meter failure	0.4
${\text{X}}_3$	Sensitizer flow-meter failure	0.2
${\text{X}}_4$	Solenoid valve failure	0.3
${\text{X}}_5$	Connection line failure	0.2
${\text{X}}_6$	System display failure	0.1
${\text{X}}_7$	The leakage of fuel tank	0.1
${\text{X}}_8$	The leakage of oil pipe joints	0.5
${\text{X}}_9$	Oil pipe failure	0.1
${\text{X}}_{10}$	Oil filter element failure	0.8
${\text{X}}_{11}$	Oil-pressure meter failure	0.2
${\text{X}}_{12}$	One-way valve failure	0.2
${\text{X}}_{13}$	Stator failure	0.45
${\text{X}}_{14}$	Bearing failure	0.15
${\text{X}}_{15}$	Emulsion matrix pump failure	0.3
${\text{X}}_{16}$	Flexible pipe failure	0.7
${\text{X}}_{17}$	Flexible pipe joint failure	0.2
${\text{X}}_{18}$	Butterfly valve failure	0.4
${\text{X}}_{19}$	Sensitizer pump failure	0.1
${\text{X}}_{20}$	Water tube failure	0.5
${\text{X}}_{21}$	Sensitizer filter element failure	0.2
${\text{X}}_{22}$	Sensitizer tank failure	0.2

The probability of failure of each module at 1000 hours is obtained by the bottom event probability, as shown in Table 5.

Table 5

Failure probability of each module.

Encoding	Model	Probability
C	Fuel flow module	0.1008
S1	Flow display module	0.1537
S2	Tank module	0.2261
S3	Pump body module	0.1513
S4	Sensitizing agent system module	0.3333

After obtaining the data failure probability of each module, the data are further integrated to obtain failure probability of the top event.

According to the integration, the reliability of the system after one thousand hours of running time can be obtianed. The integration diagram is shown in Figure 21.

[figure omitted; refer to PDF]

Finally, combining the failure probability of each module to evaluate the system reliability and failure rate can be obtained as 0.6292 and 0.3708, respectively.

6. Discussion

The Markov model is usually used to solve the problem of dynamic fault tree. Complex systems are difficult to build using traditional Markov models. Due to the dynamic fault tree containing static subtrees, the BDD can be used to solve the problem of static subtree. The logic gate combination is simplified using the pretreatment method. For the simplified dynamic fault tree [32–35], BDD is used to solve the problem. The complexity of the solution is closely related to the construction of the binary decision graph model. The complexity of model construction is affected by the ordering of variables. The complex structure of the fault tree is improved, and the difficulty of sorting the BDD variables is reduced by preprocessing the logic gate. Taking the subtree N1 in Figure 16 as an example, the FDEP gate is connected under the OR gate. If the variables are sorted directly without preprocessing, it is difficult to reasonably sort due to the various sorting of dynamic logic gate. The preprocessed module is shown in Figure 17. The preprocessed module S1 only contains two kinds of static gates. Sorting the variables is becoming easier, and difficulty of solving is reduced. The binary decision method can be directly used to solve the solution, and the result is as shown in Table 5. Using this method, the failure probability of each subtree can be obtained at the same time, and the dynamic fault tree can be rigorously analyzed.

The information obtained from the current research results is still very limited. Because of its influence by many factors, the accuracy of the failure probability still needs further research. Therefore, the subsequent researches should go along diversification. Since the amount of information that can be obtained using only one data source is small, in the future, a multisource information fusion method will be used to more accurately evaluate the system reliability.

7. Conclusion

This article introduces how to use the modular approach to solve the probability density of basic events in the dynamic fault tree when the system has certain complexity and multiple subsystems. The module pretreatment method is adopted to simplify the submodule of the fault tree due to the excessive mixture and overlap of logic gates. This modular approach has two advantages: first the variables ordering for the module becomes easy to reduce the complexity of BDD and solve difficulty by pretreatment, and second the failure probability of the subsystem can be obtained for evaluating the reliability of the subsystem. The feasibility of the method was verified by analyzing dynamic fault tree of explosive production system for the BCZH-15 explosive vehicle. At present, due to the difficulty of individual data collection in the data collection process and the lack of a large amount of experimental data support, the failure rate of the collected products is not accurate enough. It may have an impact on the accuracy of the result evaluation. In the future, when the data are insufficient, fuzzy theory will be used to define the failure rate of the product, and the rationality of the final output result will be determined through the comparison of expert experience.

Acknowledgments

This work was partially supported by the National Natural Science Foundation of China under the contract no. 71761030 and the Graduate Teaching Program of Inner Mongolia University of Technology under the contract no. YJG2017013.

References

[1] E. J. Henley, H. Kumamoto, Reliability Engineering and Risk Assessment, 1981.

[2] N. G. Leveson, Safeware: System Safety and Computers, 1995.

[3] Y. Ren, J. B. Dugan, "Optimal design of reliable systems using static and dynamic fault trees," IEEE Transaction on Reliability, vol. 47, pp. 234-244, 1998.

[4] N. Siu, "Risk assessment for dynamic systems: an overview," Reliability Engineering and System Safety, vol. 43 no. 1, pp. 43-73, DOI: 10.1016/0951-8320(94)90095-7, 1994.

[5] J. Mi, Y. F. Li, Y. J. Yang, W. Peng, H. Z. Huang, "Reliability assessment of complex electromechanical systems under epistemic uncertainty," Reliability Engineering and System Safety, vol. 152, 2016.

[6] M. Yazdi, S. Kabir, M. Walker, "Uncertainty handling in fault tree based risk assessment: state of the art and future perspectives," Process Safety and Environmental Protection, vol. 131, pp. 89-104, DOI: 10.1016/j.psep.2019.09.003, 2019.

[7] M. Yazdi, F. Nikfar, M. Nasrabadi, "Failure probability analysis by employing fuzzy fault tree analysis," International Journal of System Assurance Engineering and Management, vol. 8 no. 2, pp. 1177-1193, DOI: 10.1007/s13198-017-0583-y, 2017.

[8] M. Yazdi, A. Nedjati, E. Zarei, R. Abbassi, "A novel extension of DEMATEL approach for probabilistic safety analysis in process systems," Safety Science, vol. 121, pp. 119-136, DOI: 10.1016/j.ssci.2019.09.006, 2020.

[9] C. A. Ericson, Hazard Analysis Techniques for System Safety, 2015.

[10] A. C. Torres-Echeverria, "Modeling and optimization of proof testing policies for safety instrumented systems," Reliability Engineering and System Safety, vol. 94, pp. 838-854, 2009.

[11] A. Lisnianski, "Extended block diagram method for a multi-state system reliability assessment," Reliability Engineering and System Safety, vol. 92, pp. 1601-1607, 2007.

[12] Y. Dutuit, F. Innal, A. Rauzy, J.-P. Signoret, "Probabilistic assessments in relationship with safety integrity levels by using Fault Trees," Reliability Engineering and System Safety, vol. 93 no. 12, pp. 1867-1876, DOI: 10.1016/j.ress.2008.03.024, 2008.

[13] Y. F. Li, J. Mi, Y. Liu, Y. J. Yang, H. Z. Huang, "Dynamic fault tree analysis based on continuous-time Bayesian networks under fuzzy numbers," Proceedings of the Institution of Mechanical Engineers, Part O, Journal of Risk and Reliability, vol. 229 no. 6, pp. 530-541, 2005.

[14] H. Li, H. Diaz, C. Guedes Soares, "A developed failure mode and effect analysis for floating offshore wind turbine support structures," Renewable Energy, vol. 164, pp. 133-145, DOI: 10.1016/j.renene.2020.09.033, 2021.

[15] H. Li, A. P. Teixeira, C. Guedes Soares, "A two-stage Failure Mode and Effect Analysis of offshore wind turbines," Renewable Energy, vol. 162, pp. 1438-1461, DOI: 10.1016/j.renene.2020.08.001, 2020.

[16] H. Li, C. G. Soares, H. Z. Huang, "Reliability analysis of a floating offshore wind turbine using Bayesian Networks," Ocean Engineering, vol. 217, 2020.

[17] J. B. Dugan, S. J. Bavuso, M. A. Boyd, "Dynamic fault-tree for fault-tolerant computer systems," IEEE Transaction on Reliability, vol. 41 no. 3, pp. 363-376, 1992.

[18] J. B. Dugan, K. J. Sullivan, D. Coppit, "Developing a low-cost high-quality software tool for dynamic fault-tree analysis," IEEE Transactions on Reliability, vol. 49 no. 1, pp. 49-59, DOI: 10.1109/24.855536, 2000.

[19] L. Meshkat, J. B. Dugan, J. D. Andrews, "Dependability analysis of systems with on demand and active failure modes using dynamic fault trees," IEEE Transaction Reliability, vol. 51 no. 3, pp. 240-251, DOI: 10.1109/tr.2002.1011531, 2002.

[20] G.-J. Jiang, L. Gao, "Reliability analysis of martial arts arena robot systems based on fuzzy set theory," Journal of Mechanical Science and Technology, vol. 32 no. 11, pp. 5069-5077, DOI: 10.1007/s12206-018-1003-1, 2018.

[21] C.-Y. Huang, Y.-R. Chang, "An improved decomposition scheme for assessing the reliability of embedded systems by using dynamic fault trees," Reliability Engineering and System Safety, vol. 92 no. 10, pp. 1403-1412, DOI: 10.1016/j.ress.2006.09.008, 2007.

[22] M. Soeken, L. Tague, G. W. Dueck, R. Drechsler, "Ancilla-free synthesis of large reversible functions using binary decision diagrams," Journal of Symbolic Computation, vol. 73,DOI: 10.1016/j.jsc.2015.03.002, 2016.

[23] J. B. Dugan, "DIF tree: a software package for the analysis of dynamic fault tree models," Proceedings of the Reliability and Maintainability Symposium, pp. 64-70, .

[24] D. Ge, M. Lin, Y. Yang, R. Zhang, Q. Chou, "Quantitative analysis of dynamic fault trees using improved Sequential Binary Decision Diagrams," Reliability Engineering and System Safety, vol. 142, pp. 289-299, DOI: 10.1016/j.ress.2015.06.001, 2015.

[25] C. Bandyopadhyay, R. Das, R. Wille, R. Drechsler, H. Rahaman, "Synthesis of circuits based on all-optical mach-zehnder interferometers using binary decision diagrams," Microelectronics Journal, vol. 71, pp. 19-29, DOI: 10.1016/j.mejo.2017.11.008, 2018.

[26] X. Zhang, H. Gao, H.-Z. Huang, Y.-F. Li, J. Mi, "Dynamic reliability modeling for system analysis under complex load," Reliability Engineering and System Safety, vol. 180, pp. 345-351, DOI: 10.1016/j.ress.2018.07.025, 2018.

[27] X.-Y. Li, H.-Z. Huang, Y.-F. Li, "Reliability analysis of phased mission system with non-exponential and partially repairable components," Reliability Engineering and System Safety, vol. 175, pp. 119-127, DOI: 10.1016/j.ress.2018.03.008, 2018.

[28] M. Abimbola, F. Khan, N. Khakzad, S. Butt, "Safety and risk analysis of managed pressure drilling operation using Bayesian network," Safety Science, vol. 76, pp. 133-144, DOI: 10.1016/j.ssci.2015.01.010, 2015.

[29] Y. D. Rauzy, "A linear-time algorithm to find modules of fault tree," IEEE Transaction on Reliability, vol. 45 no. 3, 1996.

[30] S. B. Akers, "Binary decision diagrams," IEEE Transaction on Computers, vol. C-27, pp. 509-516, 1978.

[31] E. Bartocci, L. Bortolussi, T. Brázdil, D. Milios, G. Sanguinetti, "Policy learning in continuous-time Markov decision processes using Gaussian Processes," Performance Evaluation, vol. 116, pp. 84-100, DOI: 10.1016/j.peva.2017.08.007, 2017.

[32] S. Reed, "An efficient algorithm for exact computation of system and survival signatures using binary decision diagrams," Reliability Engineering and System Safety, vol. 165, pp. 257-267, DOI: 10.1016/j.ress.2017.03.036, 2017.

[33] A. Toppila, "Binary decision diagrams for generating and storing non-dominated project portfolios with interval-valued project scores," European Journal of Operational Research, vol. 260 no. 1, pp. 244-254, 2017.

[34] J. Mi, Y.-F. Li, W. Peng, H.-Z. Huang, "Reliability analysis of complex multi-state system with common cause failure based on evidential networks," Reliability Engineering and System Safety, vol. 174, pp. 71-81, DOI: 10.1016/j.ress.2018.02.021, 2018.

[35] H. Li, H.-Z. Huang, Y.-F. Li, J. Zhou, J. Mi, "Physics of failure-based reliability prediction of turbine blades using multi-source information fusion," Applied Soft Computing, vol. 72, pp. 624-635, DOI: 10.1016/j.asoc.2018.05.015, 2018.