# computeSystemSurvSignature: Compute the survival signature of a system In ReliabilityTheory: Tools for Structural Reliability Analysis

## Description

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.

## Usage

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

## Arguments

 `graph` an `igraph` object representing the system whose survival signature is to be computed. There should be two terminal 'dummy' nodes to represent either end of the structure which must be labelled "s" and "t" (assumed perfectly reliable) as well as a vertex attribute named `compType` identifying each component type. See details and examples. `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.

## Details

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.

## Value

`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.

## Note

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

## Author(s)

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

## References

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.

`computeSystemSignature`

## Examples

 ``` 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) ```

### Example output

```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.