Voting OR Gate Example - Revision history

Lisa Hacker at 21:00, 18 September 2023

2023-09-18T21:00:21Z

← Older revision		Revision as of 21:00, 18 September 2023
Line 1:		Line 1:
	<noinclude>{{Banner BlockSim Examples}}		<noinclude>{{Banner BlockSim Examples}}
	''This example also appears in the [~~[Fault_Tree_Diagrams_and_System_Analysis\|~~System ~~Analysis Reference book]~~]''. </noinclude>		''This example also appears in the [https://help.reliasoft.com/reference/system_analysis System analysis reference]''. </noinclude>
	===Voting OR Gate===		===Voting OR Gate===

Cruz Daniel: /* Voting OR Gate */

2021-08-16T17:47:40Z

Voting OR Gate

← Older revision		Revision as of 17:47, 16 August 2021
Line 16:		Line 16:

	In this configuration, the system will not fail if three out of four components are operating, but will fail if more than one fails. In other words, the fault tree considers ''k''-out-of-''n'' failures for the system failure while the RBD considers ''k''-out-of-''n'' successes for system success.		In this configuration, the system will not fail if three out of four components are operating, but will fail if more than one fails. In other words, the fault tree considers ''k''-out-of-''n'' failures for the system failure while the RBD considers ''k''-out-of-''n'' successes for system success.

			====Note: Complexity of k-out-of-n configurations====
			Note that for large values of <math>n</math> and intermediate values of <math>k</math> it is possible to create a configuration that appears simple but is actually extremely mathematically complex. This arises from the equation describing the number of combinations of <math>k</math> choices out of <math>n</math> units:

			::<math>\binom{n}{k} = \frac{n!}{k! (n-k)!}</math>

			With <math>k = 1, n = 50</math> this expression evaluates to 50, meaning there are 50 unique failure combinations. With <math> k = 49, n = 50</math> this number is again 50. Further, with <math>k = 2, n = 50</math> this number increases to 1225. But with <math>k = 25, n = 50</math> there are 126,410,606,437,752 unique combinations that must all be evaluated to provide answers. Attempting to calculate results or cut sets from such a fault tree analytically therefore requires an inordinate amount of calculation time. As such, similar combinations of <math>k</math> and <math>n</math> should be avoided, or solved with simulation if possible.

	====Increasing the Flexibility====		====Increasing the Flexibility====

Richard House: /* Example */

2015-12-11T20:48:16Z

Example

← Older revision		Revision as of 20:48, 11 December 2015
Line 23:		Line 23:
	Consider a system with three components, ''A'', ''B'' and ''C''. The system fails if any two components fail. Draw the fault tree and reliability block diagram for the system. The next two figures show both the FTD and RBD representations.		Consider a system with three components, ''A'', ''B'' and ''C''. The system fails if any two components fail. Draw the fault tree and reliability block diagram for the system. The next two figures show both the FTD and RBD representations.

	<center>[[Image:I10.8.png\|center\|250px\|]]		<center>[[Image:I10.8.png\|center\|250px\|link=\|]]


	[[Image:I10.9.png\|center\|250px\|]]</center>		[[Image:I10.9.png\|center\|250px\|link=\|]]</center>

	The reliability equation for either configuration is:		The reliability equation for either configuration is:

Richard House: /* Voting OR Gate */

2015-12-11T20:47:43Z

Voting OR Gate

← Older revision		Revision as of 20:47, 11 December 2015
Line 3:		Line 3:
	===Voting OR Gate===		===Voting OR Gate===

	[[Image:I10.7.png\|center\|100px\|]]		[[Image:I10.7.png\|center\|100px\|link=\|]]

	In a Voting OR gate, the output event occurs if <math>k\,\!</math> or more of the input events occur. In system reliability terms, this implies that if any ''k''-out-of-''n'' components fail (input) then the system will fail (output).		In a Voting OR gate, the output event occurs if <math>k\,\!</math> or more of the input events occur. In system reliability terms, this implies that if any ''k''-out-of-''n'' components fail (input) then the system will fail (output).
Line 9:		Line 9:
	The equivalent RBD construct is a node and is similar to a ''k''-out-of-''n'' parallel configuration with a distinct difference, as discussed next. To illustrate this difference, consider a fault tree diagram with a 2-out-of-4 Voting OR gate, as shown in the following figure.		The equivalent RBD construct is a node and is similar to a ''k''-out-of-''n'' parallel configuration with a distinct difference, as discussed next. To illustrate this difference, consider a fault tree diagram with a 2-out-of-4 Voting OR gate, as shown in the following figure.

	[[Image:3.png\|center\|300px\|Illustration of a 2-out-or-4 Voting OR gate.]]		[[Image:3.png\|center\|300px\|Illustration of a 2-out-or-4 Voting OR gate.\|link=]]

	In this diagram, the system will fail if any two of the blocks below fail. Equivalently, this can be represented by the RBD shown in the next figure using a 3-out-of-4 node.		In this diagram, the system will fail if any two of the blocks below fail. Equivalently, this can be represented by the RBD shown in the next figure using a 3-out-of-4 node.

	[[Image:4.png\|center\|300px\|Equivalent representation of the 2-out-of-4 Voting OR gate.]]		[[Image:4.png\|center\|300px\|Equivalent representation of the 2-out-of-4 Voting OR gate.\|link=]]

	In this configuration, the system will not fail if three out of four components are operating, but will fail if more than one fails. In other words, the fault tree considers ''k''-out-of-''n'' failures for the system failure while the RBD considers ''k''-out-of-''n'' successes for system success.		In this configuration, the system will not fail if three out of four components are operating, but will fail if more than one fails. In other words, the fault tree considers ''k''-out-of-''n'' failures for the system failure while the RBD considers ''k''-out-of-''n'' successes for system success.

Richard House at 21:26, 17 September 2012

2012-09-17T21:26:19Z

← Older revision		Revision as of 21:26, 17 September 2012
Line 5:		Line 5:
	[[Image:I10.7.png\|center\|100px\|]]		[[Image:I10.7.png\|center\|100px\|]]

	In a Voting OR gate, the output event occurs if <math>k</math> or more of the input events occur. In system reliability terms, this implies that if any ''k''-out-of-''n'' components fail (input) then the system will fail (output).		In a Voting OR gate, the output event occurs if <math>k\,\!</math> or more of the input events occur. In system reliability terms, this implies that if any ''k''-out-of-''n'' components fail (input) then the system will fail (output).

	The equivalent RBD construct is a node and is similar to a ''k''-out-of-''n'' parallel configuration with a distinct difference, as discussed next. To illustrate this difference, consider a fault tree diagram with a 2-out-of-4 Voting OR gate, as shown in the following figure.		The equivalent RBD construct is a node and is similar to a ''k''-out-of-''n'' parallel configuration with a distinct difference, as discussed next. To illustrate this difference, consider a fault tree diagram with a 2-out-of-4 Voting OR gate, as shown in the following figure.
Line 30:		Line 30:
	The reliability equation for either configuration is:		The reliability equation for either configuration is:

	::<math>{{R}_{System}}=-2\cdot {{R}_{A}}\cdot {{R}_{B}}\cdot {{R}_{C}}+{{R}_{A}}\cdot {{R}_{B}}+{{R}_{A}}\cdot {{R}_{C}}+{{R}_{B}}\cdot {{R}_{C}}\ </math>		::<math>{{R}_{System}}=-2\cdot {{R}_{A}}\cdot {{R}_{B}}\cdot {{R}_{C}}+{{R}_{A}}\cdot {{R}_{B}}+{{R}_{A}}\cdot {{R}_{C}}+{{R}_{B}}\cdot {{R}_{C}}\,\!</math>

	Equation above assumes a classical Voting OR gate (i.e., the voting gate itself cannot fail). If the gate can fail then the equation is modified as follows:		Equation above assumes a classical Voting OR gate (i.e., the voting gate itself cannot fail). If the gate can fail then the equation is modified as follows:

	::<math>{{R}_{System}}={{R}_{Voting}}\left( -2\cdot {{R}_{A}}\cdot {{R}_{B}}\cdot {{R}_{C}}+{{R}_{A}}\cdot {{R}_{B}}+{{R}_{A}}\cdot {{R}_{C}}+{{R}_{B}}\cdot {{R}_{C}} \right)</math>		::<math>{{R}_{System}}={{R}_{Voting}}\left( -2\cdot {{R}_{A}}\cdot {{R}_{B}}\cdot {{R}_{C}}+{{R}_{A}}\cdot {{R}_{B}}+{{R}_{A}}\cdot {{R}_{C}}+{{R}_{B}}\cdot {{R}_{C}} \right)\,\!</math>

	Note that while both the gate and the node are 2-out-of-3, they represent different circumstances. The Voting OR gate in the fault tree indicates that if two components fail then the system will fail; while the node in the reliability block diagram indicates that if at least two components succeed then the system will succeed.		Note that while both the gate and the node are 2-out-of-3, they represent different circumstances. The Voting OR gate in the fault tree indicates that if two components fail then the system will fail; while the node in the reliability block diagram indicates that if at least two components succeed then the system will succeed.

Lisa Hacker at 07:11, 17 August 2012

2012-08-17T07:11:56Z

← Older revision		Revision as of 07:11, 17 August 2012
Line 1:		Line 1:
	<noinclude>{{Banner BlockSim Examples}}</noinclude>		<noinclude>{{Banner BlockSim Examples}}
			''This example also appears in the [[Fault_Tree_Diagrams_and_System_Analysis\|System Analysis Reference book]]''. </noinclude>
	===Voting OR Gate===		===Voting OR Gate===

Richard House: /* Voting OR Gate */

2012-08-10T07:08:20Z

Voting OR Gate

← Older revision		Revision as of 07:08, 10 August 2012
Line 4:		Line 4:
	[[Image:I10.7.png\|center\|100px\|]]		[[Image:I10.7.png\|center\|100px\|]]

	In a Voting OR gate, the output event occurs if <math>k</math> or more of the input events occur. In system reliability terms, this implies that if any ~~<math>~~k~~</math>~~ -out-of- ~~<math>~~n~~</math>~~ components fail (input) then the system will fail (output).		In a Voting OR gate, the output event occurs if <math>k</math> or more of the input events occur. In system reliability terms, this implies that if any ''k''-out-of-''n'' components fail (input) then the system will fail (output).

	The equivalent RBD construct is a node and is similar to a ''k''-out-of- ~~<math>~~n~~</math>~~ parallel configuration with a distinct difference, as discussed next. To illustrate this difference, consider a fault tree diagram with a 2-out-of-4 Voting OR gate, as shown in the following figure.		The equivalent RBD construct is a node and is similar to a ''k''-out-of-''n'' parallel configuration with a distinct difference, as discussed next. To illustrate this difference, consider a fault tree diagram with a 2-out-of-4 Voting OR gate, as shown in the following figure.

	[[Image:3.png\|center\|300px\|Illustration of a 2-out-or-4 Voting OR gate.]]		[[Image:3.png\|center\|300px\|Illustration of a 2-out-or-4 Voting OR gate.]]
Line 14:		Line 14:
	[[Image:4.png\|center\|300px\|Equivalent representation of the 2-out-of-4 Voting OR gate.]]		[[Image:4.png\|center\|300px\|Equivalent representation of the 2-out-of-4 Voting OR gate.]]

	In this configuration, the system will not fail if three out of four components are operating, but will fail if more than one fails. In other words, the fault tree considers ''k''-out-of- ~~<math>~~n~~</math>~~ failures for the system failure while the RBD considers ''k''-out-of- ~~<math>~~n~~</math>~~ successes for system success.		In this configuration, the system will not fail if three out of four components are operating, but will fail if more than one fails. In other words, the fault tree considers ''k''-out-of-''n'' failures for the system failure while the RBD considers ''k''-out-of-''n'' successes for system success.

	====Increasing the Flexibility====		====Increasing the Flexibility====

Richard House at 06:45, 10 August 2012

2012-08-10T06:45:52Z

← Older revision		Revision as of 06:45, 10 August 2012
Line 6:		Line 6:
	In a Voting OR gate, the output event occurs if <math>k</math> or more of the input events occur. In system reliability terms, this implies that if any <math>k</math> -out-of- <math>n</math> components fail (input) then the system will fail (output).		In a Voting OR gate, the output event occurs if <math>k</math> or more of the input events occur. In system reliability terms, this implies that if any <math>k</math> -out-of- <math>n</math> components fail (input) then the system will fail (output).

	The equivalent RBD construct is a node and is similar to a ''k''-out-of- <math>n</math> parallel configuration with a distinct difference, as discussed next. To illustrate this difference, consider a fault tree diagram with a 2-out-of- ~~<math>~~4~~</math>~~ Voting OR gate, as shown in the following figure.		The equivalent RBD construct is a node and is similar to a ''k''-out-of- <math>n</math> parallel configuration with a distinct difference, as discussed next. To illustrate this difference, consider a fault tree diagram with a 2-out-of-4 Voting OR gate, as shown in the following figure.

	[[Image:3.png\|center\|300px\|Illustration of a 2-out-or-4 Voting OR gate.]]		[[Image:3.png\|center\|300px\|Illustration of a 2-out-or-4 Voting OR gate.]]

Richard House: /* Voting OR Gate */

2012-08-10T06:45:34Z

Voting OR Gate

← Older revision		Revision as of 06:45, 10 August 2012
Line 6:		Line 6:
	In a Voting OR gate, the output event occurs if <math>k</math> or more of the input events occur. In system reliability terms, this implies that if any <math>k</math> -out-of- <math>n</math> components fail (input) then the system will fail (output).		In a Voting OR gate, the output event occurs if <math>k</math> or more of the input events occur. In system reliability terms, this implies that if any <math>k</math> -out-of- <math>n</math> components fail (input) then the system will fail (output).

	The equivalent RBD construct is a node and is similar to a ~~<math>~~k~~</math>~~ -out-of- <math>n</math> parallel configuration with a distinct difference, as discussed next. To illustrate this difference, consider a fault tree diagram with a ~~<math>~~2~~</math>~~ -out-of- <math>4</math> Voting OR gate, as shown in the following figure.		The equivalent RBD construct is a node and is similar to a ''k''-out-of- <math>n</math> parallel configuration with a distinct difference, as discussed next. To illustrate this difference, consider a fault tree diagram with a 2-out-of- <math>4</math> Voting OR gate, as shown in the following figure.

	[[Image:3.png\|center\|300px\|Illustration of a 2-out-or-4 Voting OR gate.]]		[[Image:3.png\|center\|300px\|Illustration of a 2-out-or-4 Voting OR gate.]]

	In this diagram, the system will fail if any two of the blocks below fail. Equivalently, this can be represented by the RBD shown in the next figure using a ~~<math>~~3~~</math>~~ -out-of- ~~<math>~~4~~</math>~~ node.		In this diagram, the system will fail if any two of the blocks below fail. Equivalently, this can be represented by the RBD shown in the next figure using a 3-out-of-4 node.

	[[Image:4.png\|center\|300px\|Equivalent representation of the 2-out-of-4 Voting OR gate.]]		[[Image:4.png\|center\|300px\|Equivalent representation of the 2-out-of-4 Voting OR gate.]]

	In this configuration, the system will not fail if three out of four components are operating, but will fail if more than one fails. In other words, the fault tree considers ~~<math>~~k~~</math>~~ -out-of- <math>n</math> failures for the system failure while the RBD considers ~~<math>~~k~~</math>~~ -out-of- <math>n</math> successes for system success.		In this configuration, the system will not fail if three out of four components are operating, but will fail if more than one fails. In other words, the fault tree considers ''k''-out-of- <math>n</math> failures for the system failure while the RBD considers ''k''-out-of- <math>n</math> successes for system success.

	====Increasing the Flexibility====		====Increasing the Flexibility====
Line 20:		Line 20:

	====Example====		====Example====
	Consider a system with three components, ~~<math>~~A,~~</math> <math>~~B~~</math>~~ and ~~<math>~~C~~</math>~~ . The system fails if any two components fail. Draw the fault tree and reliability block diagram for the system. The next two figures show both the FTD and RBD representations.		Consider a system with three components, ''A'', ''B'' and ''C''. The system fails if any two components fail. Draw the fault tree and reliability block diagram for the system. The next two figures show both the FTD and RBD representations.

	<center>[[Image:I10.8.png\|center\|250px\|]]		<center>[[Image:I10.8.png\|center\|250px\|]]

Richard House at 07:02, 6 August 2012

2012-08-06T07:02:49Z

← Older revision		Revision as of 07:02, 6 August 2012
Line 1:		Line 1:
	<noinclude>{{Banner BlockSim Examples}}</noinclude>		<noinclude>{{Banner BlockSim Examples}}</noinclude>
	===Voting OR Gate===		===Voting OR Gate===
	~~<br>~~
	[[Image:I10.7.png\|center\|100px\|]]		[[Image:I10.7.png\|center\|100px\|]]
	~~<br>~~

	In a Voting OR gate, the output event occurs if <math>k</math> or more of the input events occur. In system reliability terms, this implies that if any <math>k</math> -out-of- <math>n</math> components fail (input) then the system will fail (output).		In a Voting OR gate, the output event occurs if <math>k</math> or more of the input events occur. In system reliability terms, this implies that if any <math>k</math> -out-of- <math>n</math> components fail (input) then the system will fail (output).
	~~<br>~~

	The equivalent RBD construct is a node and is similar to a <math>k</math> -out-of- <math>n</math> parallel configuration with a distinct difference, as discussed next. To illustrate this difference, consider a fault tree diagram with a <math>2</math> -out-of- <math>4</math> Voting OR gate, as shown in the following figure.		The equivalent RBD construct is a node and is similar to a <math>k</math> -out-of- <math>n</math> parallel configuration with a distinct difference, as discussed next. To illustrate this difference, consider a fault tree diagram with a <math>2</math> -out-of- <math>4</math> Voting OR gate, as shown in the following figure.
Line 20:		Line 18:
	====Increasing the Flexibility====		====Increasing the Flexibility====
	Classical Voting OR gates have no properties and cannot fail or be repaired (i.e., they cannot be an event themselves). In BlockSim, Voting OR gates behave like nodes in an RBD; thus, they can also fail and be repaired just like any other event. By default, when a Voting OR gate is inserted into a fault tree diagram within BlockSim, the gate is set so that it cannot fail (classical definition). However, this property can be modified to allow for additional flexibility.		Classical Voting OR gates have no properties and cannot fail or be repaired (i.e., they cannot be an event themselves). In BlockSim, Voting OR gates behave like nodes in an RBD; thus, they can also fail and be repaired just like any other event. By default, when a Voting OR gate is inserted into a fault tree diagram within BlockSim, the gate is set so that it cannot fail (classical definition). However, this property can be modified to allow for additional flexibility.
	~~<br>~~

	====Example====		====Example====
	Consider a system with three components, <math>A,</math> <math>B</math> and <math>C</math> . The system fails if any two components fail. Draw the fault tree and reliability block diagram for the system. The next two figures show both the FTD and RBD representations.		Consider a system with three components, <math>A,</math> <math>B</math> and <math>C</math> . The system fails if any two components fail. Draw the fault tree and reliability block diagram for the system. The next two figures show both the FTD and RBD representations.

	~~<br>~~
	<center>[[Image:I10.8.png\|center\|250px\|]]		<center>[[Image:I10.8.png\|center\|250px\|]]

Line 31:		Line 27:
	[[Image:I10.9.png\|center\|250px\|]]</center>		[[Image:I10.9.png\|center\|250px\|]]</center>

	~~<br>~~
	The reliability equation for either configuration is:		The reliability equation for either configuration is:
	~~<br>~~
	::<math>{{R}_{System}}=-2\cdot {{R}_{A}}\cdot {{R}_{B}}\cdot {{R}_{C}}+{{R}_{A}}\cdot {{R}_{B}}+{{R}_{A}}\cdot {{R}_{C}}+{{R}_{B}}\cdot {{R}_{C}}\ </math>		::<math>{{R}_{System}}=-2\cdot {{R}_{A}}\cdot {{R}_{B}}\cdot {{R}_{C}}+{{R}_{A}}\cdot {{R}_{B}}+{{R}_{A}}\cdot {{R}_{C}}+{{R}_{B}}\cdot {{R}_{C}}\ </math>
	~~<br>~~

	Equation above assumes a classical Voting OR gate (i.e., the voting gate itself cannot fail). If the gate can fail then the equation is modified as follows:		Equation above assumes a classical Voting OR gate (i.e., the voting gate itself cannot fail). If the gate can fail then the equation is modified as follows:
	~~<br>~~

	::<math>{{R}_{System}}={{R}_{Voting}}\left( -2\cdot {{R}_{A}}\cdot {{R}_{B}}\cdot {{R}_{C}}+{{R}_{A}}\cdot {{R}_{B}}+{{R}_{A}}\cdot {{R}_{C}}+{{R}_{B}}\cdot {{R}_{C}} \right)</math>		::<math>{{R}_{System}}={{R}_{Voting}}\left( -2\cdot {{R}_{A}}\cdot {{R}_{B}}\cdot {{R}_{C}}+{{R}_{A}}\cdot {{R}_{B}}+{{R}_{A}}\cdot {{R}_{C}}+{{R}_{B}}\cdot {{R}_{C}} \right)</math>
	~~<br>~~

	Note that while both the gate and the node are 2-out-of-3, they represent different circumstances. The Voting OR gate in the fault tree indicates that if two components fail then the system will fail; while the node in the reliability block diagram indicates that if at least two components succeed then the system will succeed.		Note that while both the gate and the node are 2-out-of-3, they represent different circumstances. The Voting OR gate in the fault tree indicates that if two components fail then the system will fail; while the node in the reliability block diagram indicates that if at least two components succeed then the system will succeed.
	~~<br>~~