Description Usage Arguments Details Value Note Author(s) References See Also Examples

The system survival signature (Coolen and Coolen-Maturi, 2012) is a generalisation of the signature to systems with multiple component types. This function automatically computes the survival signature of the specified system. Here, system implies components (as opposed to links) are unreliable.

1 | ```
computeSystemSurvivalSignature(graph, cutsets=NULL, frac=FALSE)
``` |

`graph` |
an |

`cutsets` |
if the cut-sets of the system or network are already known they may be passed in as a list of numeric vectors. This can save time because cut-set computation is the slowest part of the algorithm. Leaving as NULL causes the function to find the cut sets itself. |

`frac` |
if TRUE then the function prints out survival signature probabilities as fractions rather than decimals. |

The survival signature of a system with *K* types of component is the functional *Φ(l_1, …, l_K)* giving the probability that the system works given exactly *l_k* of the components of type *k* are working. See Coolen and Coolen-Maturi (2012) for details. Thus, the survival signature can be represented by a table with *K+1* columns, the first *K* being the number of each type of component which is working and the final column being the probability the system works.

The system or network is specified by means of an `igraph`

object, whereby each end of the system is denoted by nodes names "s" and "t" which are taken to be perfectly reliable. It is easy to construct the appropriate graph representation using the function `graph.formula`

. Note that each physically distinct component should be separately numbered when constructing this graph object.

Once the topology of the system has been defined, one must attach a vertex attribute named `compType`

to each component to indicate the type of the component. The Examples section below features the full computation of the survival signature for Figure 1 in Coolen and Coolen-Maturi (2012) and Figure 2 in Coolen *et al* (2013) to make this clear.

`computeSystemSurvivalSignature`

returns a data frame with *K+1* columns. The first *K* columns represent the function inputs, *l_1, …, l_K* and the final column is the probability that the system works given the corresponding numbers of each component which are working.

Please feel free to email [email protected] with any queries or if you encounter errors when running this function.

Louis J. M. Aslett [email protected] (http://www.louisaslett.com/)

Coolen, F. P. A. and Coolen-Maturi, T. (2012), Generalizing the signature to systems with multiple types of components, *in* 'Complex Systems and Dependability', Springer, pp. 115-130.

Coolen, F. P. A., Coolen-Maturi, T., Al-nefaiee, A. H. and Aboalkhair, A. M. (2013), ‘Recent advances in system reliability using the survival signature’, *Proceedings of Advances in Risk and Reliability Technology Symposium, Loughborough*.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 | ```
## EXAMPLE 1
## Figure 1 in Coolen and Coolen-Maturi (2012)
# First, define the structure, ensuring that each physically separate component
# is separately numbered
fig1 <- graph.formula(s -- 1 -- 2:3 -- 4 -- 5:6 -- t, 2 -- 5, 3 -- 6)
# Second, create a vertex attribute specifying the type of each of those
# numbered component (leaving s,t with no type)
V(fig1)$compType <- NA # This just creates the attribute compType
V(fig1)$compType[match(c("1","2","5"), V(fig1)$name)] <- "Type 1"
V(fig1)$compType[match(c("3","4","6"), V(fig1)$name)] <- "Type 2"
V(fig1)$compType[match(c("s","t"), V(fig1)$name)] <- NA
# Third, compute the survival signature (getting fractions rather than decimals)
computeSystemSurvivalSignature(fig1, frac=TRUE)
## EXAMPLE 2
## Figure 3 in Coolen et al (2013)
# First, define the structure, ensuring that each physically separate component
# is separately numbered
fig3 <- graph.formula(s -- 1:4 -- 2:5 -- 3:6 -- t, s -- 7:8, 8 -- 9, 7:9 -- t)
# Second, create a vertex attribute specifying the type of each of those
# numbered component (leaving s,t with no type)
V(fig3)$compType <- NA # This just creates the attribute compType
V(fig3)$compType[match(c("1"), V(fig3)$name)] <- "Type 1"
V(fig3)$compType[match(c("2","3","4","7"), V(fig3)$name)] <- "Type 2"
V(fig3)$compType[match(c("5","6","8","9"), V(fig3)$name)] <- "Type 3"
V(fig3)$compType[match(c("s","t"), V(fig3)$name)] <- NA
# Third, compute the survival signature (getting fractions rather than decimals)
computeSystemSurvivalSignature(fig3, frac=TRUE)
``` |

```
Loading required package: igraph
Attaching package: 'igraph'
The following objects are masked from 'package:stats':
decompose, spectrum
The following object is masked from 'package:base':
union
Type 1 Type 2 Probability
1 0 0 0
2 0 1 0
3 0 2 0
4 0 3 0
5 1 0 0
6 1 1 0
7 1 2 1/9
8 1 3 1/3
9 2 0 0
10 2 1 0
11 2 2 4/9
12 2 3 2/3
13 3 0 1
14 3 1 1
15 3 2 1
16 3 3 1
Type 1 Type 2 Type 3 Probability
1 0 0 0 0
2 0 0 1 0
3 0 0 2 1/6
4 0 0 3 1/2
5 0 0 4 1
6 0 1 0 1/4
7 0 1 1 1/4
8 0 1 2 5/12
9 0 1 3 3/4
10 0 1 4 1
11 0 2 0 1/2
12 0 2 1 7/12
13 0 2 2 3/4
14 0 2 3 11/12
15 0 2 4 1
16 0 3 0 1
17 0 3 1 1
18 0 3 2 1
19 0 3 3 1
20 0 3 4 1
21 0 4 0 1
22 0 4 1 1
23 0 4 2 1
24 0 4 3 1
25 0 4 4 1
26 1 0 0 0
27 1 0 1 0
28 1 0 2 1/3
29 1 0 3 1
30 1 0 4 1
31 1 1 0 1/4
32 1 1 1 3/8
33 1 1 2 2/3
34 1 1 3 1
35 1 1 4 1
36 1 2 0 2/3
37 1 2 1 3/4
38 1 2 2 8/9
39 1 2 3 1
40 1 2 4 1
41 1 3 0 1
42 1 3 1 1
43 1 3 2 1
44 1 3 3 1
45 1 3 4 1
46 1 4 0 1
47 1 4 1 1
48 1 4 2 1
49 1 4 3 1
50 1 4 4 1
```

ReliabilityTheory documentation built on May 29, 2017, 6:14 p.m.

Embedding an R snippet on your website

Add the following code to your website.

For more information on customizing the embed code, read Embedding Snippets.