ReliaWiki - User contributions [en]

Life Data Classification

2015-05-22T16:48:31Z

2015-05-20T23:16:32Z

Athanasios Gerokostopoulos: /* Destructive Degradation Analysis */

{{template:LDABOOK|21|Degradation Data Analysis}}
Given that products are more frequently being designed with higher reliability and developed in a shorter amount of time, it is often not possible to test new designs to failure under normal operating conditions. In some cases, it is possible to infer the reliability behavior of unfailed test samples with only the accumulated test time information and assumptions about the distribution. However, this generally leads to a great deal of uncertainty in the results. Another option in this situation is the use of degradation analysis. Degradation analysis involves the measurement of performance data that can be directly related to the presumed failure of the product in question. Many failure mechanisms can be directly linked to the degradation of part of the product, and degradation analysis allows the analyst to extrapolate to an assumed failure time based on the measurements of degradation over time.

In some cases, it is possible to either directly measure the degradation of a physical characteristic over time, as with the wear of brake pads or with the propagation of crack size or the degradation of a performance characteristic over time such as the voltage of a battery or the luminous flux of an LED bulb. These cases belong to the Non-Destructive Degradation Analysis category. In other cases, direct measurement of degradation might not be possible without invasive or destructive measurement techniques that would directly affect the subsequent performance of the product and therefore only one degradation measurement is possible. Examples are the measurement of corrosion in a chemical container or the strength measurement of an adhesive bond. These cases belong to the Destructive Degradation Analysis Category. In either case, however, it is necessary to be able to define a level of degradation or performance at which a failure is said to have occurred.

With this failure level defined, it is a relatively simple matter to use basic mathematical models to extrapolate the measurements over time to the point where the failure is said to occur. Once these have been determined, it is merely a matter of analyzing the extrapolated failure times in the same manner as conventional time-to-failure data.

==Non-Destructive Degradation Analysis==
The Non-Destructive Degradation Analysis applies to cases where multiple degradation measurements over time can be obtained for each sample in the test. Given a defined level of failure (or the degradation level that would constitute a failure), basic mathematical models are used to extrapolate the degradation measurements over time of each sample to the point in time where the failure will occur. Once these extrapolated failure times are obtained, it is merely a matter of analyzing the extrapolated failure times in the same manner as conventional time-to-failure data. As with conventional life data analysis, the amount of certainty in the results is directly related to the number of samples being tested. The following figure combines the steps of the analysis by showing the extrapolation of the degradation measurements to a failure time and the subsequent distribution analysis of these failure times.

[[Image:Non-Destructive Degradation.png|center|450px|]]

===Non-Destructive Degradation Models===
Once the degradation information has been recorded, the next task is to extrapolate the measurements to the defined failure level in order to estimate the failure time. Weibull++ allows the user to perform such extrapolation using a linear, exponential, power or logarithmic model. These models have the following forms:

:* Linear: <math>y=a\cdot x+b \!</math>
:* Exponential: <math>y=b\cdot {{e}^{a\cdot x}}\!</math>
:* Power: <math>y=b\cdot {{x}^{a}} \!</math>
:* Logarithmic: <math>y=a\cdot ln(x)+b \!</math>
:* Gompertz: <math>y=a\cdot {{b}^{{{c}^{x}}}} \!</math>
:* Lloyd-Lipow: <math>y=a-\frac{b}{x} \!</math>

where <math>y\,\!</math> represents the performance, <math>x\,\!</math> represents time, and <math>a,\,\!</math> <math>b\,\!</math> and <math>c\,\!</math> are model parameters to be solved for.

Once the model parameters <math>{{a}_{i}}\,\!</math>, <math>{{b}_{i}}\,\!</math> and <math>{{c}_{i}}\,\!</math> are estimated for each sample <math>i\,\!</math>, a time, <math>{{x}_{i}}\,\!</math>, can be extrapolated, which corresponds to the defined level of failure <math>y\,\!</math>. The computed <math>{{x}_{i}}\,\!</math> values can now be used as our times-to-failure for subsequent life data analysis. As with any sort of extrapolation, one must be careful not to extrapolate too far beyond the actual range of data in order to avoid large inaccuracies (modeling errors).

====Example====
'''Crack Propagation Example (Point Estimation)'''

Five turbine blades are tested for crack propagation. The test units are cyclically stressed and inspected every 100,000 cycles for crack length. Failure is defined as a crack of length 30mm or greater. The following table shows the test results for the five units at each cycle:

::<math>\begin{matrix}
Cycles (x1000) & Unit A (mm)& Unit B (mm) & Unit C (mm) & Unit D (mm)& Unit E (mm) \\
100 & 15 & 10 & 17 & 12 & 10 \\
200 & 20& 15 & 25 & 16 & 15 \\
300 & 22 & 20 &26 & 17 & 20 \\
400 & 26 &25 & 27 & 20 & 26 \\
500 & 29 & 30 & 33 &26 & 33 \\
\end{matrix}\,\!</math>

Use the exponential degradation model to extrapolate the times-to-failure data.

'''Solution'''

The first step is to solve the equation <math>y=b\cdot {{e}^{a\cdot x}}\,\!</math> for <math>a\,\!</math> and <math>b\,\!</math> for each of the test units. Using regression analysis, the values for each of the test units are:

::<math>\begin{matrix}
{} & a & b \\
Unit A & 0.00158 & 13.596 \\
Unit B & 0.00271 & 8.272 \\
Unit C & 0.00140 & 16.435 \\
Unit D & 0.00177 & 10.361 \\
Unit E & 0.00294 & 7.931 \\
\end{matrix}\,\!</math>

Substituted the values into the underlying exponential model, solved for <math>x\,\!</math> or:

::<math>x=\frac{\text{ln}(y)-\text{ln}(b)}{a}\,\!</math>

Using the values of <math>a\,\!</math> and <math>b\,\!</math>, with <math>y=30\,\!</math>, the resulting time at which the crack length reaches 30mm can then found for each sample:

::<math>\begin{matrix}
{} & Cycles-to-Failure \\
Unit A & \text{500,622} \\
Unit B & \text{475,739} \\
Unit C & \text{428,739} \\
Unit D & \text{600,810} \\
Unit E & \text{452,832} \\
\end{matrix}\,\!</math>

These times-to-failure can now be analyzed using traditional life data analysis to obtain metrics such as the probability of failure, B10 life, mean life, etc. This analysis can be automatically performed in the Weibull++ degradation analysis folio.

{{Examples Box|Weibull++ Examples|More degradation analysis examples are available! See also:
{{Examples Both|http://www.reliasoft.com/Weibull/examples/rc4/index.htm|Degradation Analysis|http://www.reliasoft.tv/weibull/appexamples/weibull_app_ex_4|Watch the video...}}<nowiki/>
}}

===Using Extrapolated Intervals===
The parameters in a degradation model are estimated using available degradation data. If the data is large, the uncertainty of the estimated parameters will be small. Otherwise, the uncertainty will be large. Since the failure time for a test unit is predicted based on the estimated model, we sometimes would like to see how the parameter uncertainty affects the failure time prediction. Let’s use the exponential model as an example. Assume the critical degradation value is <math>{{y}_{crit}}\,\!</math>. The predicted failure time will be:

::<math> \hat{x}=\frac{\ln ({{y}_{crit}})-\ln (\hat{b})}{{\hat{a}}}\,\!</math>

The variance of the predicted failure time will be:

::<math>Var(\hat{x})={{\left( \frac{\partial x}{\partial a} \right)}^{2}}Var(\hat{a})+{{\left( \frac{\partial x}{\partial b} \right)}^{2}}Var(\hat{b})+2\left( \frac{\partial x}{\partial a} \right)\left( \frac{\partial x}{\partial b} \right)Cov(\hat{a},\hat{b})\,\!</math>

The variance and covariance of the model parameters are calculated from using Least Squares Estimation. The details of the calculation are not given here.

The 2-sided upper and lower bounds for the predicted failure time, with a confidence level of <math>1-\alpha \,\!</math> are:

::<math>{{x}_{U}}=\hat{x}+{{K}_{1-\alpha /2}}\sqrt{Var(\hat{x})}\,\!</math>
::<math>{{x}_{L}}=\hat{x}-{{K}_{1-\alpha /2}}\sqrt{Var(\hat{x})}\,\!</math>

In Weibull++, the default confidence level is 90%.

====Example====
'''Crack Propagation Example (Extrapolated Intervals)'''

Using the same data set from the previous example, predict the interval failure times for the turbine blades.

'''Solution'''

In the Weibull++ degradation analysis folio, select the '''Use extrapolated intervals''' check box, as shown next.

[[Image:Check Use Extrapolated Intervals.png|center|250px| ]]

Use the exponential degradation model for the degradation analysis, and the Weibull distribution parameters with MLE for the life data analysis. The following report shows the estimated degradation model parameters.

[[Image:Model Parameters and Stds.png|center|450px| ]]

The following report shows the extrapolated failure time intervals.

[[Image:Extraploated Failure Time Intervals.png|center|450px| ]]

==Destructive Degradation Analysis==
The Destructive Degradation Analysis applies to cases where the sample has to be destroyed in order to obtain a degradation measurement. As a result, degradation measurements for multiple samples are required at different points in time. The analysis performed is very similar to the Accelerated Life Testing Analysis (ALTA). In this case, the “stress” used in ALTA becomes time while the random variable instead of time-to-failure becomes the degradation measurement. . Given a defined level of failure (or the degradation level that would constitute a failure), the probability that the degradation measurement will be beyond that level at a given time can be obtained. The following plot shows the relationship between the distribution of the degradation measurement and time. The red shaded area of the last two pdfs represents the probability that the degradation measurement will be less than the critical degradation level at the corresponding times.

[[Image:Destructive_Degradation_1.1.png|center|450px| ]]

===Destructive Degradation Models===
The first step of destructive degradation analysis involves using a statistical distribution to represent the variability of a degradation measurement at a given time. The following distributions can be used:

:*Weibull
:*Exponential
:*Normal
:*Lognormal
:*Gumbell

Similar to accelerated life testing analysis, the assumption is that the location or log-location parameter of the degradation measurement distribution will change with time while the shape parameter will remain constant. For each distribution:

:* Weibull: <math>\ln (\eta )</math> is set as a function of time while <math>\beta </math> remains constant
:* Exponential: <math>\ln (MTTF)</math> is set as a function of time
:* Normal: <math>\mu </math> is set as a function of time while <math>\sigma </math> remains constant
:* Lognormal: <math>{\mu }'</math> is set as a function of time while <math>{\sigma }'</math> remains constant
:* Gumbel: <math>\mu </math> is set as a function of time while <math>\sigma </math> remains constant

Finally, given the selected distribution, a degradation model is used to represent the change of the location (or log-location) parameter with time. The following degradation models can be used:

:* Linear: <math>\mu (t)=b+a\times t</math>
:* Exponential: <math>\mu (t)=b\times {{e}^{a\times t}}</math>
:* Power: <math>\mu (t)=b\times {{t}^{a}}</math>
:* Logarithm: <math>\mu (t)=a\times \ln (t)+b</math>
:* Lioyd-Lipow: <math>\mu (t)=a-\frac{b}{t}</math>

The distribution and degradation models parameters are then calculated using Maximum Likelihood Estimation (MLE).

For example, if a normal distribution is used to represent the degradation measurement and a linear degradation model is assumed, then the standard deviation, <math>\sigma </math>, will be assumed constant with time and the mean, <math>\mu </math>, will be:

:: <math>\mu (t)=b+a\times t</math>

The CDF of the degradation measurement <math>x(t)</math> is:

:: <math>\Pr (x(t)<X)=\Phi \left( \frac{X-\mu (t)}{\sigma } \right)</math>

Given the CDF, the parameters <math>\sigma </math>, <math>b</math> and <math>a</math> are estimated using Maximum Likelihood Estimation.

Assuming that the requirement is that the measurement needs to be greater than a critical degradation value <math>{{D}_{crit}}</math> for the product to fail, the probability of failure at time t will be:

:: <math>F(t)=\Pr (x(t)>{{D}_{crit}})=1-\Phi \left( \frac{{{D}_{crit}}-\mu (t)}{\sigma } \right)</math>

It should be noted that the failure threshold could be specified as a degradation measurement less than (for the case of decreasing degradation) or greater than (for the case of increasing degradation) a critical degradation value.

The relationship between the distribution of degradation measurement and the distribution of failure time is illustrated in the following plot.

[[Image:Destructive_Degradation_2.png|center|450px| ]]

====Example====
A company has been collecting degradation data over a period of 4 years with the purpose of calculating reliability after 5 years. With the degradation measurement decreasing with time, failure is defined as a measurement of 150 or below. In order to obtain such measurements, the unit has to be destroyed and therefore removed from the population.

The following table gives the degradation measurements over 4 years.

::<math>\begin{matrix}
Year 1 & Year 2 & Year 3 & Year 4 & \\
437 & 412 & 246 & 125 \\
446 & 420 & 324 & 208 \\
497 & 451 & 330 & 229 \\
503 & 454 & 426 & 242 \\
705 & 554 & 499 & 273 \\
737 & 580 & 546 & 297 \\
748 & 608 & 554 & 311 \\
788 & 610 & 559 & 318 \\
818 & 727 & 625 & 393 \\
860 & 825 & & 403 \\
875 & 925 & & 470 \\
934 & & & \\
1124 & & & \\
1250 & & & \\
1350 & & & \\
\end{matrix}\,\!</math>

1. Estimate parameters using the Linear degradation model and the 2-Parameter Weibull distribution
2. Plot the degradation curve vs. time
3. Calculate the reliability at 5 years.

'''Solution'''

Enter the data into a Destructive Degradation folio in Weibull++. Select '''Linear''' under the Degradation Model and '''2P-Weibull''' under the Measurement Distribution. Set the critical degradation to '''150'''. Click '''Calculate'''.

:1. The estimated parameters are <math>\hat{\beta }=3.618336\,\!</math>, <math>\hat{a}=-0.331695\,\!</math> and <math>\hat{b}=7.154643\,\!</math>.
:2. The following plot shows the degradation curve vs. time

[[Image:Destructive_Degradation_Example_Plot1.png|center|450px| ]]

:3. Using the QCP, the reliability at 5 years, or in other words the probability that the degradation measurement will be less than 150 at 5 years, is:

[[Image:Destructive_Degradation_Example_QCP.png|center|450px| ]]

2015-05-20T22:13:05Z

Athanasios Gerokostopoulos:

Degradation Data Analysis

2015-05-20T22:11:39Z

Athanasios Gerokostopoulos: /* Destructive Degradation Models */

{{template:LDABOOK|21|Degradation Data Analysis}}
Given that products are more frequently being designed with higher reliability and developed in a shorter amount of time, it is often not possible to test new designs to failure under normal operating conditions. In some cases, it is possible to infer the reliability behavior of unfailed test samples with only the accumulated test time information and assumptions about the distribution. However, this generally leads to a great deal of uncertainty in the results. Another option in this situation is the use of degradation analysis. Degradation analysis involves the measurement of performance data that can be directly related to the presumed failure of the product in question. Many failure mechanisms can be directly linked to the degradation of part of the product, and degradation analysis allows the analyst to extrapolate to an assumed failure time based on the measurements of degradation over time.

In some cases, it is possible to either directly measure the degradation of a physical characteristic over time, as with the wear of brake pads or with the propagation of crack size or the degradation of a performance characteristic over time such as the voltage of a battery or the luminous flux of an LED bulb. These cases belong to the Non-Destructive Degradation Analysis category. In other cases, direct measurement of degradation might not be possible without invasive or destructive measurement techniques that would directly affect the subsequent performance of the product and therefore only one degradation measurement is possible. Examples are the measurement of corrosion in a chemical container or the strength measurement of an adhesive bond. These cases belong to the Destructive Degradation Analysis Category. In either case, however, it is necessary to be able to define a level of degradation or performance at which a failure is said to have occurred.

With this failure level defined, it is a relatively simple matter to use basic mathematical models to extrapolate the measurements over time to the point where the failure is said to occur. Once these have been determined, it is merely a matter of analyzing the extrapolated failure times in the same manner as conventional time-to-failure data.

==Non-Destructive Degradation Analysis==
The Non-Destructive Degradation Analysis applies to cases where multiple degradation measurements over time can be obtained for each sample in the test. Given a defined level of failure (or the degradation level that would constitute a failure), basic mathematical models are used to extrapolate the degradation measurements over time of each sample to the point in time where the failure will occur. Once these extrapolated failure times are obtained, it is merely a matter of analyzing the extrapolated failure times in the same manner as conventional time-to-failure data. As with conventional life data analysis, the amount of certainty in the results is directly related to the number of samples being tested. The following figure combines the steps of the analysis by showing the extrapolation of the degradation measurements to a failure time and the subsequent distribution analysis of these failure times.

[[Image:Non-Destructive Degradation.png|center|450px|]]

===Non-Destructive Models===
Once the degradation information has been recorded, the next task is to extrapolate the measurements to the defined failure level in order to estimate the failure time. Weibull++ allows the user to perform such extrapolation using a linear, exponential, power or logarithmic model. These models have the following forms:

:* Linear: <math>y=a\cdot x+b \!</math>
:* Exponential: <math>y=b\cdot {{e}^{a\cdot x}}\!</math>
:* Power: <math>y=b\cdot {{x}^{a}} \!</math>
:* Logarithmic: <math>y=a\cdot ln(x)+b \!</math>
:* Gompertz: <math>y=a\cdot {{b}^{{{c}^{x}}}} \!</math>
:* Lloyd-Lipow: <math>y=a-\frac{b}{x} \!</math>

where <math>y\,\!</math> represents the performance, <math>x\,\!</math> represents time, and <math>a,\,\!</math> <math>b\,\!</math> and <math>c\,\!</math> are model parameters to be solved for.

Once the model parameters <math>{{a}_{i}}\,\!</math>, <math>{{b}_{i}}\,\!</math> and <math>{{c}_{i}}\,\!</math> are estimated for each sample <math>i\,\!</math>, a time, <math>{{x}_{i}}\,\!</math>, can be extrapolated, which corresponds to the defined level of failure <math>y\,\!</math>. The computed <math>{{x}_{i}}\,\!</math> values can now be used as our times-to-failure for subsequent life data analysis. As with any sort of extrapolation, one must be careful not to extrapolate too far beyond the actual range of data in order to avoid large inaccuracies (modeling errors).

====Example====
'''Crack Propagation Example (Point Estimation)'''

Five turbine blades are tested for crack propagation. The test units are cyclically stressed and inspected every 100,000 cycles for crack length. Failure is defined as a crack of length 30mm or greater. The following table shows the test results for the five units at each cycle:

::<math>\begin{matrix}
Cycles (x1000) & Unit A (mm)& Unit B (mm) & Unit C (mm) & Unit D (mm)& Unit E (mm) \\
100 & 15 & 10 & 17 & 12 & 10 \\
200 & 20& 15 & 25 & 16 & 15 \\
300 & 22 & 20 &26 & 17 & 20 \\
400 & 26 &25 & 27 & 20 & 26 \\
500 & 29 & 30 & 33 &26 & 33 \\
\end{matrix}\,\!</math>

Use the exponential degradation model to extrapolate the times-to-failure data.

'''Solution'''

The first step is to solve the equation <math>y=b\cdot {{e}^{a\cdot x}}\,\!</math> for <math>a\,\!</math> and <math>b\,\!</math> for each of the test units. Using regression analysis, the values for each of the test units are:

::<math>\begin{matrix}
{} & a & b \\
Unit A & 0.00158 & 13.596 \\
Unit B & 0.00271 & 8.272 \\
Unit C & 0.00140 & 16.435 \\
Unit D & 0.00177 & 10.361 \\
Unit E & 0.00294 & 7.931 \\
\end{matrix}\,\!</math>

Substituted the values into the underlying exponential model, solved for <math>x\,\!</math> or:

::<math>x=\frac{\text{ln}(y)-\text{ln}(b)}{a}\,\!</math>

Using the values of <math>a\,\!</math> and <math>b\,\!</math>, with <math>y=30\,\!</math>, the resulting time at which the crack length reaches 30mm can then found for each sample:

::<math>\begin{matrix}
{} & Cycles-to-Failure \\
Unit A & \text{500,622} \\
Unit B & \text{475,739} \\
Unit C & \text{428,739} \\
Unit D & \text{600,810} \\
Unit E & \text{452,832} \\
\end{matrix}\,\!</math>

These times-to-failure can now be analyzed using traditional life data analysis to obtain metrics such as the probability of failure, B10 life, mean life, etc. This analysis can be automatically performed in the Weibull++ degradation analysis folio.

{{Examples Box|Weibull++ Examples|More degradation analysis examples are available! See also:
{{Examples Both|http://www.reliasoft.com/Weibull/examples/rc4/index.htm|Degradation Analysis|http://www.reliasoft.tv/weibull/appexamples/weibull_app_ex_4|Watch the video...}}<nowiki/>
}}

===Using Extrapolated Intervals===
The parameters in a degradation model are estimated using available degradation data. If the data is large, the uncertainty of the estimated parameters will be small. Otherwise, the uncertainty will be large. Since the failure time for a test unit is predicted based on the estimated model, we sometimes would like to see how the parameter uncertainty affects the failure time prediction. Let’s use the exponential model as an example. Assume the critical degradation value is <math>{{y}_{crit}}\,\!</math>. The predicted failure time will be:

::<math> \hat{x}=\frac{\ln ({{y}_{crit}})-\ln (\hat{b})}{{\hat{a}}}\,\!</math>

The variance of the predicted failure time will be:

::<math>Var(\hat{x})={{\left( \frac{\partial x}{\partial a} \right)}^{2}}Var(\hat{a})+{{\left( \frac{\partial x}{\partial b} \right)}^{2}}Var(\hat{b})+2\left( \frac{\partial x}{\partial a} \right)\left( \frac{\partial x}{\partial b} \right)Cov(\hat{a},\hat{b})\,\!</math>

The variance and covariance of the model parameters are calculated from using Least Squares Estimation. The details of the calculation are not given here.

The 2-sided upper and lower bounds for the predicted failure time, with a confidence level of <math>1-\alpha \,\!</math> are:

::<math>{{x}_{U}}=\hat{x}+{{K}_{1-\alpha /2}}\sqrt{Var(\hat{x})}\,\!</math>
::<math>{{x}_{L}}=\hat{x}-{{K}_{1-\alpha /2}}\sqrt{Var(\hat{x})}\,\!</math>

In Weibull++, the default confidence level is 90%.

====Example====
'''Crack Propagation Example (Extrapolated Intervals)'''

Using the same data set from the previous example, predict the interval failure times for the turbine blades.

'''Solution'''

In the Weibull++ degradation analysis folio, select the '''Use extrapolated intervals''' check box, as shown next.

[[Image:Check Use Extrapolated Intervals.png|center|250px| ]]

Use the exponential degradation model for the degradation analysis, and the Weibull distribution parameters with MLE for the life data analysis. The following report shows the estimated degradation model parameters.

[[Image:Model Parameters and Stds.png|center|450px| ]]

The following report shows the extrapolated failure time intervals.

[[Image:Extraploated Failure Time Intervals.png|center|450px| ]]

==Destructive Degradation Analysis==
The Destructive Degradation Analysis applies to cases where the sample has to be destroyed in order to obtain a degradation measurement. As a result, degradation measurements for multiple samples are required at different points in time. The analysis performed is very similar to the Accelerated Life Testing Analysis (ALTA). In this case, the “stress” used in ALTA becomes time while the random variable instead of time-to-failure becomes the degradation measurement. . Given a defined level of failure (or the degradation level that would constitute a failure), the probability that the degradation measurement will be beyond that level at a given time can be obtained. The following plot shows the relationship between the distribution of the degradation measurement and time. The red shaded area of the last two pdfs represents the probability that the degradation measurement will be less than the critical degradation level at the corresponding times.

[[Image:Destructive_Degradation_1.png|center|450px| ]]

===Destructive Degradation Models===
The first step of destructive degradation analysis involves using a statistical distribution to represent the variability of a degradation measurement at a given time. The following distributions can be used:

:*Weibull
:*Exponential
:*Normal
:*Lognormal
:*Gumbell

Similar to accelerated life testing analysis, the assumption is that the location or log-location parameter of the degradation measurement distribution will change with time while the shape parameter will remain constant. For each distribution:

:* Weibull: <math>\ln (\eta )</math> is set as a function of time while <math>\beta </math> remains constant
:* Exponential: <math>\ln (MTTF)</math> is set as a function of time
:* Normal: <math>\mu </math> is set as a function of time while <math>\sigma </math> remains constant
:* Lognormal: <math>{\mu }'</math> is set as a function of time while <math>{\sigma }'</math> remains constant
:* Gumbel: <math>\mu </math> is set as a function of time while <math>\sigma </math> remains constant

Finally, given the selected distribution, a degradation model is used to represent the change of the location (or log-location) parameter with time. The following degradation models can be used:

:* Linear: <math>\mu (t)=b+a\times t</math>
:* Exponential: <math>\mu (t)=b\times {{e}^{a\times t}}</math>
:* Power: <math>\mu (t)=b\times {{t}^{a}}</math>
:* Logarithm: <math>\mu (t)=a\times \ln (t)+b</math>
:* Lioyd-Lipow: <math>\mu (t)=a-\frac{b}{t}</math>

The distribution and degradation models parameters are then calculated using Maximum Likelihood Estimation (MLE).

For example, if a normal distribution is used to represent the degradation measurement and a linear degradation model is assumed, then the standard deviation, <math>\sigma </math>, will be assumed constant with time and the mean, <math>\mu </math>, will be:

:: <math>\mu (t)=b+a\times t</math>

The CDF of the degradation measurement <math>x(t)</math> is:

:: <math>\Pr (x(t)<X)=\Phi \left( \frac{X-\mu (t)}{\sigma } \right)</math>

Given the CDF, the parameters <math>\sigma </math>, <math>b</math> and <math>a</math> are estimated using Maximum Likelihood Estimation.

Assuming that the requirement is that the measurement needs to be greater than a critical degradation value <math>{{D}_{crit}}</math> for the product to fail, the probability of failure at time t will be:

:: <math>F(t)=\Pr (x(t)>{{D}_{crit}})=1-\Phi \left( \frac{{{D}_{crit}}-\mu (t)}{\sigma } \right)</math>

It should be noted that the failure threshold could be specified as a degradation measurement less than (for the case of decreasing degradation) or greater than (for the case of increasing degradation) a critical degradation value.

The relationship between the distribution of degradation measurement and the distribution of failure time is illustrated in the following plot.

Degradation Data Analysis

2015-05-20T22:10:48Z

2013-11-27T20:06:29Z

Athanasios Gerokostopoulos:

{{Template:RGA_BOOK_SUB|Appendix A|Failure Discounting}}
During a reliability growth test, once a failure has been analyzed and corrective actions for that specific failure mode have been implemented, the probability of its recurrence is diminished, as given in Lloyd [[RGA_References|[4]]]. Then for the success/failure data that follow, the value of the failure for which corrective actions have already been implemented should be subtracted from the total number of failures. However, certain questions arise, such as to what extent should the failure value be diminished or discounted, and how should the failure value be defined? One answer would be to use engineering judgment (e.g., a panel of specialists would agree that the probability of failure has been reduced by 50% or 90% and therefore, that failure should be given a value of 0.5 or 0.9). The obvious disadvantage of this approach is its arbitrariness and the difficulty of reaching an agreement. Therefore, a statistical basis needs to be selected, one that is repeatable and less arbitrary. Failure discounting is applied when using the Lloyd-Lipow, logistic, and the standard and modified Gompertz models.

The value of the failure, <math>f\,\!</math>, is chosen to be the upper confidence limit on the probability of failure based on the number of successful tests following implementation of the corrective action. The failure value is given by the following equation:

::<math>f=1-{{(1-CL)}^{\tfrac{1}{{{S}_{n}}}}}\,\!</math>

where:

*<math>CL\,\!</math> is the confidence level.
*<math>{{S}_{n}}\,\!</math> is the number of successful tests after the first success following the corrective action.

For example, after one successful test following a corrective action, <math>{{S}_{n}}=1\,\!</math>, the failure is given a value of 0.9 based on a 90% confidence level. After two successful tests, <math>{{S}_{n}}=2\,\!</math>, the failure is given a value of 0.684, and so on. The procedure for applying this method is illustrated in the next example.

'''Example'''

Use failure discounting to answer the questions below. Assume that during the 22 launches given in the first table below, the first failure was caused by Mode 1, the second and fourth failures were caused by Mode 2, the third and fifth failures were caused by Mode 3, the sixth failure was caused by Mode 4 and the seventh failure was caused by Mode 5.

:1) Find the standard Gompertz reliability growth curve using the results of the first 15 launches.
:2) Find the predicted reliability after launch 22.
:3) Calculate the reliability after launch 22 based on the full data set from the second table, and compare it with the estimate obtained for question 2.

{|border="1" align="center" style="border-collapse: collapse;" cellpadding="5" cellspacing="5"
|-
|colspan="10" style="text-align:center"|'''Launch sequence with failure modes and failure values'''
|-
!Launch Number
!Result/Mode
!Failure 1
!Failure 2
!Failure 3
!Failure 4
!Failure 5
!Failure 6
!Failure 7
!Sum of Failures
|-
|1|| F1|| 1.000|| || || || || || || 1.000
|-
|2|| F2|| 1.000|| 1.000 || || || || || || 2.000
|-
|3|| F3|| 0.900|| 1.000|| 1.000|| || || || || 2.900
|-
|4|| S|| 0.684|| 0.900|| 1.000|| || || || || 2.584
|-
|5|| F2|| 0.536|| 1.000|| 0.900|| 1.000|| || || || 3.436
|-
|6|| F3|| 0.438|| 1.000|| 1.000|| 1.000|| 1.000|| || || 4.438
|-
|7|| S|| 0.369|| 0.900|| 1.000|| 0.900|| 1.000|| || || 4.169
|-
|8|| S|| 0.319|| 0.684|| 0.900|| 0.684|| 0.900|| || || 3.486
|-
|9|| S|| 0.280|| 0.536|| 0.684|| 0.536|| 0.684|| || || 2.720
|-
|10|| S|| 0.250|| 0.438|| 0.536|| 0.438|| 0.536|| || || 2.197
|-
|11|| S|| 0.226|| 0.369|| 0.438|| 0.369|| 0.438|| || || 1.839
|-
|12|| S|| 0.206|| 0.319|| 0.369|| 0.319|| 0.369|| || || 1.581
|-
|13|| S|| 0.189|| 0.280|| 0.319|| 0.280|| 0.319|| || || 1.387
|-
|14|| S|| 0.175|| 0.250|| 0.280|| 0.250|| 0.280|| || || 1.235
|-
|15|| S|| 0.162|| 0.226|| 0.250|| 0.226|| 0.250|| || || 1.114
|-
|16|| S|| 0.152|| 0.206|| 0.226|| 0.206|| 0.226|| || || 1.014
|-
|17|| F4|| 0.142|| 0.189|| 0.206|| 0.189|| 0.206|| 1.000|| || 1.931
|-
|18|| S|| 0.134|| 0.175|| 0.189|| 0.175|| 0.189|| 1.000|| || 1.861
|-
|19|| F5|| 0.127|| 0.162|| 0.175|| 0.162|| 0.175|| 0.900|| 1.000|| 2.701
|-
|20|| S|| 0.120|| 0.152|| 0.162|| 0.152|| 0.162|| 0.684|| 1.000|| 2.432
|-
|21|| S|| 0.114|| 0.142|| 0.152|| 0.142|| 0.152|| 0.536|| 0.900|| 2.138
|-
|22|| S|| 0.109|| 0.134|| 0.142|| 0.134|| 0.142|| 0.438|| 0.684|| 1.783
|}

 

{|border="1" align="center" style="border-collapse: collapse;" cellpadding="5" cellspacing="5"
|-
|colspan="4" style="text-align:center"|'''Comparison of the predicted reliability with the actual data'''
|-
!Launch Number
!Calculated Reliability (%)
!ln(R)
!Gompertz Reliability (%)
|-
|1|| 0.000|| ||
|-
|2|| 0.000|| ||
|-
|3|| 3.333|| 1.204||
|-
|4|| 35.406|| 3.567|| 16.426
|-
|5|| 31.283|| 3.443|| 26.691
|-
|6|| 26.039|| 3.260|| 37.858
|-
|7|| 40.442|| 3.670|| 48.691
|-
|8|| 56.422|| 4.033|| 58.363
|-
|9|| 69.783|| 4.245|| 66.496
|-
| || || <math>{{S}_{1}}\,\!</math> = 22.218 ||
|-
|10|| 78.029 ||4.357 ||73.044
|-
|11|| 83.281 ||4.422 ||78.155
|-
|12|| 86.824 ||4.464 ||82.055
|-
|13|| 89.331|| 4.492|| 84.983
|-
|14|| 91.175|| 4.513|| 87.155
|-
|15|| 92.573|| 4.528|| 88.754
|-
| || || <math>{{S}_{2}}\,\!</math> = 26.776||
|-
|16|| 93.660|| 4.540|| 89.923
|-
|17|| 88.639|| 4.484|| 90.774
|-
|18|| 89.661|| 4.496 ||91.392
|-
|19|| 85.787|| 4.452|| 91.839
|-
|20|| 87.841|| 4.476 ||92.163
|-
|21|| 89.820|| 4.498|| 92.396
|-
| || || <math>{{S}_{3}}\,\!</math> = 26.946||
|-
|22|| 91.896 4.521 92.565|| ||
|}

'''Solution'''

1) The first table above is organized as follows:

:*The failures are represented by columns "Failure 1", "Failure 2", etc. The "Result/Mode" column shows whether each launch is a failure (indicated by the failure modes F1, F2, etc.) or a success (S).

:*The values of failure are based on <math>CL=0.90\,\!</math> and are calculated from:

::<math>f=1-{{(1-CL)}^{\tfrac{1}{{{S}_{n}}}}}\,\!</math>

:*These values are summed and the reliability is calculated from:

:::<math>R=\left[ 1-\left( \frac{\mathop{}_{i=1}^{N}{{f}_{i}}}{n} \right) \right]\cdot 100\text{ }%\,\!</math>

::where <math>N\,\!</math> is the number of failures and <math>n\,\!</math> is the number of events, tests, runs or launches.

:*Failure 1 is Mode 1; it occurs at launch 1 and it does not recur throughout the process. So at launch 3, <math>{{S}_{n}}=1\,\!</math>, and so on.

:*Failure 2 is Mode 2; it occurs at launch 2 and it recurs at launch 5. Therefore, <math>{{S}_{n}}=1\,\!</math> at launch 4 and at launch 7, and so on.

:*Failure 3 is Mode 3; it occurs at launch 3 and it recurs at launch 6. Therefore, <math>{{S}_{n}}=1\,\!</math> at launch 5 and at launch 8, and so on.

:*Failure 6 is Mode 4; it occurs at launch 17 and it does not recur throughout the process. So at launch 19, <math>{{S}_{n}}=1\,\!</math>, and so on.

:*Failure 7 is Mode 5; it occurs at launch 19 and it does not recur throughout the process. So at launch 21, <math>{{S}_{n}}=1\,\!</math>, and so on.

:For launch 3 and failure 1, <math>{{S}_{n}}=1\,\!</math>.

::<math>\begin{align}
{{f}_{1/3}}=1-{{(1-0.90)}^{1/1}}=0.900
\end{align}\,\!</math>

:For launch 4 and failure 1, <math>{{S}_{n}}=2\,\!</math>.

::<math>\begin{align}
{{f}_{1/4}}=1-{{(1-0.90)}^{1/2}}=0.684
\end{align}\,\!</math>

:And so on.

:Calculate the initial values of the Gompertz parameters using the second table above. Based on the equations from the [[Gompertz Models]] chapter, the initial values are:

::<math>\begin{align}
c &= \left ( \frac{S_{3}-S_{2}}{S_{2}-S_{1}} \right )^\frac{1}{n\cdot I} \\
&= \left [ \frac{26.946-26.776}{26.776-22.218} \right ]^\frac{1}{6} \\
&= 0.578 \\
\end{align}\,\!</math>

::<math>\begin{align}
a &= e^\left [\frac{1}{n}\left (S_{1} + \frac {S_{2}-S_{1}}{1-e^{n\cdot I}} \right )\right ] \\
&= e^\left [\frac{1}{6}\left (22.218 + \frac{26.776 - 22.218}{1-0.578^{6}}\right ) \right ] \\
&= 89.31% \\
\end{align}\,\!</math>

::<math>\begin{align}
b &= e^\left [\frac{(S_{2}-S_{1})(c-1)}{(1-c^{n})^{2}} \right ] \\
&= e^\left [\frac{(26.776-22.218)(0.578-1)}{(1-0.578^{6})^{2}} \right ] \\
&= 0.127 \\
\end{align}\,\!</math>

:Now, since the initial values have been determined, the Gauss-Newton method can be used. Substituting <math>{{Y}_{i}}={{R}_{i}},\,\!</math> <math>g_{1}^{(0)}=89.31,\,\!</math> <math>g_{2}^{(0)}=0.127,\,\!</math> <math>g_{3}^{(0)}=0.578\,\!</math>. The iterations are continued to solve for the parameters. Using the RGA software, the estimators of the parameters for the given example are:

::<math>\begin{align}
\widehat{a}&= 0.9299 \\
\widehat{b} &= 0.0943 \\
\widehat{c} &= 0.7170
\end{align}\,\!</math>

:The next figure shows the entered data and the estimated parameters.

[[Image:rgaA.1.png|thumb|center|450px|Entered data and the estimated Standard Gompertz parameters.]]

:The Gompertz reliability growth curve may now be written as follows where <math>{{L}_{G}}\,\!</math> is the number of launches, with the first successful launch being counted as <math>{{L}_{G}}=1\,\!</math>. Therefore, <math>{{L}_{G}}\,\!</math> is equal to 19, since reliability growth starts with launch 4.

::<math>R=0.9299{{(0.0943)}^{{{0.7170}^{{{L}_{G}}}}}}\,\!</math>

2) The predicted reliability after launch 22 is therefore:

::<math>\begin{align}
R &= 0.9299{{(0.0943)}^{{{0.7170}^{19}}}} \\
&= 0.9260
\end{align}\,\!</math>

:The predicted reliability after launch 22 is calculated using the Quick Calculation Pad (QCP), as shown next.

[[Image:rgaA.2.png|thumb|center|450px|Predicted reliability after launch 22.]]

3) In the second table, the predicted reliability values are compared with the reliabilities that are calculated from the raw data using failure discounting. It can be seen in the table, and in the following figure, that the Gompertz curve appears to provide a good fit to the actual data.

[[Image:rgaA.3.png|thumb|center|450px|Standard Gompertz reliability growth curve.]]

Reliability Demonstration Test Design for Repairable Systems

2013-11-27T20:05:40Z

Athanasios Gerokostopoulos: /* Example: Solve for Number of Samples */

{{template:RGA BOOK|15}}
The RGA software provides a utility that allows you to design reliability demonstration tests for repairable systems. For example, you may want to design a test to demonstrate a specific cumulative MTBF for a specific operating period at a specific confidence level for a repairable system. The same applies for demonstrating an instantaneous MTBF or cumulative and instantaneous failure intensity at a given time <math>t.\,\!</math>

==Underlying Theory==
The failure process in a repairable system is considered to be a non-homogeneous Poisson process (NHPP) with power law failure intensity. The instantaneous failure intensity at time <math>t\,\!</math> is:

::<math>{{\lambda }_{i}}\left( t \right)=\lambda \beta {{t}^{\beta -1}}={{\lambda }_{c}}\left( t \right)\beta \,\!</math>

So, the cumulative failure intensity at time <math>t\,\!</math> is:

::<math>{{\lambda }_{c}}\left( t \right)=\lambda {{t}^{\beta -1}}=\frac{{{\lambda }_{i}}\left( t \right)}{\beta }\,\!</math>

The instantaneous MTTF is:

::<math>\begin{align}
MTT{{F}_{i}}\left( t \right)= & \frac{1}{{{\lambda }_{i\left( t \right)}}} \\
= & \frac{1}{\lambda \beta }{{t}^{1-\beta }} \\
= & \frac{MTT{{F}_{c}}\left( t \right)}{\beta }
\end{align}\,\!</math>

The cumulative MTBF at time <math>t\,\!</math> is:

::<math>MTB{{F}_{c}}\left( \beta \right)=\frac{1}{{{\lambda }_{c}}\left( t \right)}=\frac{1}{\lambda }{{t}^{1-\beta }}=MTT{{F}_{i}}\left( t \right)\beta \,\!</math>

The relation between the confidence level, required test time, number of systems under test and allowed total number of failures in the test is:

::<math>1-CL=\underset{i=0}{\overset{r}{\mathop \sum }}\,\frac{{{\left( m\lambda {{T}^{\beta }} \right)}^{i}}\exp (-m\lambda {{T}^{\beta }})}{i!}\,\!</math>

where:

*<math>T\,\!</math> is the total test time for each system.
*<math>m\,\!</math> is the number of systems under test.
*<math>r\,\!</math> is the number of allowed failures in the test.
*<math>CL\,\!</math> is the confidence level.

Given any three of the parameters, the equation above can be solved for the fourth unknown parameter. Note that when <math>\beta =1,\,\!</math> the number of failures is a homogeneous Poisson process, and the time between failures is given by the exponential distribution.

==Example: Solve for Time==

The objective is to design a test to demonstrate that the number of failures per system in five years is less than or equal to 10. In other words, demonstrate that the cumulative MTBF for a repairable system is less than or equal to 0.5 during a five year operating period, with 80% confidence level. Assume that <math>\beta =1\,\!</math>, the number of systems for the test is <math>m=6\,\!</math> and that the number of allowed failures in the test is <math>r=2.\,\!</math>

'''Solution'''

Since the given requirement is the number of failures, we transfer the requirement to the cumulative MTBF or cumulative failure intensity.

::<math>MTBF_c=\frac{5}{10}=0.5 year\,\!</math>

:then:

::<math>{{\lambda }_{c}}=\frac{1}{MTB{{F}_{c}}}=2\text{ }failures/\ \ year\,\!</math>

We can then solve for <math>\lambda \,\!</math> :

::<math>{{\lambda }_{c}}\left( t \right)=\lambda {{t}^{\beta -1}}\,\!</math>

For the five year period:

::<math>{{\lambda }_{c}}\left( 5 \right)=\lambda \cdot {{5}^{\beta -1}}\,\!</math>

Using the values of <math>\lambda \,\!</math> and <math>\beta \,\!</math>, we have:

::<math>2=\lambda \cdot {{5}^{1-1}}\,\!</math>

Then solving for <math>\lambda \,\!</math> yields:

::<math>\begin{align}
\lambda =2
\end{align}\,\!</math>

We can then solve for the required test time, <math>T,\,\!</math> for each system:

::<math>1-CL=\underset{i=0}{\overset{r}{\mathop \sum }}\,\frac{{{\left( m\lambda {{T}^{\beta }} \right)}^{i}}\exp (-m\lambda {{T}^{\beta }})}{i!}\,\!</math>

:or:

::<math>1-0.8=\underset{i=0}{\overset{2}{\mathop \sum }}\,\frac{{{\left( 6\cdot 0.894\cdot {{T}^{1}} \right)}^{i}}\exp (-6\cdot 2\cdot {{T}^{1}})}{i!}\,\!</math>

:or:

::<math>0.2=exp (-6\cdot 2\cdot T^1)+\,\!</math>
:::<math>\frac{(6\cdot 2\cdot T^1)^1 exp(-6\cdot 2\cdot T^1)}{1!}\,\!</math>
::::<math>+\frac{6\cdot 2\cdot T^1)^2 exp(-6\cdot 2\cdot T^1)}{2!}\,\!</math>

Solving the above equation numerically yields:

::<math>\begin{align}
T=0.36
\end{align}\,\!</math>

In other words, for this example we have to test for 0.36 years to demonstrate that the number of failures per system in five years is less than or equal to 10.

The same result can be obtained in the RGA software, by using the Design of Reliability Tests (DRT) tool. The next figure shows the calculated required test time per system of 0.3566 on the results of the example.

[[File:DesignReliabilityDemTst.png|center|600px|]]

==Example: Solve for Number of Samples==
At the end of a reliability growth testing program, a manufacturer wants to demonstrate that a new product has achieved an MTBF of 10,000 hours with 80% confidence. The available time for the demonstration test is 4,000 hours for each test unit. Assuming zero failures are allowed, what is the required number of units to be tested in order to demonstrate the desired MTBF?

'''Solution'''

We can obtain the required number of units by using the Design of Reliability Tests (DRT) tool in the RGA software. Since this is a demonstration test then <math>\beta =1\,\!</math>, and no growth will be achieved. The results are shown next. It can be seen that in order to demonstrate a 10,000 hours MTBF with 80% confidence, 5 test units will be required.

[[Image:rga14.16.png|thumb|center|600px|Calculated number of units for the demonstration test.]]

The next figure shows the different combinations of test time per unit, and the number of units in the test for different numbers of allowable failures. It helps to visually examine other possible test scenarios.

[[Image:rga14.17.png|thumb|center|600px|Combinations of test time and number of units for different numbers of allowable failures.]]

Reliability Demonstration Test Design for Repairable Systems

2013-11-27T20:05:13Z

Athanasios Gerokostopoulos: /* Example: Solve for Time */

{{template:RGA BOOK|15}}
The RGA software provides a utility that allows you to design reliability demonstration tests for repairable systems. For example, you may want to design a test to demonstrate a specific cumulative MTBF for a specific operating period at a specific confidence level for a repairable system. The same applies for demonstrating an instantaneous MTBF or cumulative and instantaneous failure intensity at a given time <math>t.\,\!</math>

==Underlying Theory==
The failure process in a repairable system is considered to be a non-homogeneous Poisson process (NHPP) with power law failure intensity. The instantaneous failure intensity at time <math>t\,\!</math> is:

::<math>{{\lambda }_{i}}\left( t \right)=\lambda \beta {{t}^{\beta -1}}={{\lambda }_{c}}\left( t \right)\beta \,\!</math>

So, the cumulative failure intensity at time <math>t\,\!</math> is:

::<math>{{\lambda }_{c}}\left( t \right)=\lambda {{t}^{\beta -1}}=\frac{{{\lambda }_{i}}\left( t \right)}{\beta }\,\!</math>

The instantaneous MTTF is:

::<math>\begin{align}
MTT{{F}_{i}}\left( t \right)= & \frac{1}{{{\lambda }_{i\left( t \right)}}} \\
= & \frac{1}{\lambda \beta }{{t}^{1-\beta }} \\
= & \frac{MTT{{F}_{c}}\left( t \right)}{\beta }
\end{align}\,\!</math>

The cumulative MTBF at time <math>t\,\!</math> is:

::<math>MTB{{F}_{c}}\left( \beta \right)=\frac{1}{{{\lambda }_{c}}\left( t \right)}=\frac{1}{\lambda }{{t}^{1-\beta }}=MTT{{F}_{i}}\left( t \right)\beta \,\!</math>

The relation between the confidence level, required test time, number of systems under test and allowed total number of failures in the test is:

::<math>1-CL=\underset{i=0}{\overset{r}{\mathop \sum }}\,\frac{{{\left( m\lambda {{T}^{\beta }} \right)}^{i}}\exp (-m\lambda {{T}^{\beta }})}{i!}\,\!</math>

where:

*<math>T\,\!</math> is the total test time for each system.
*<math>m\,\!</math> is the number of systems under test.
*<math>r\,\!</math> is the number of allowed failures in the test.
*<math>CL\,\!</math> is the confidence level.

Given any three of the parameters, the equation above can be solved for the fourth unknown parameter. Note that when <math>\beta =1,\,\!</math> the number of failures is a homogeneous Poisson process, and the time between failures is given by the exponential distribution.

==Example: Solve for Time==

The objective is to design a test to demonstrate that the number of failures per system in five years is less than or equal to 10. In other words, demonstrate that the cumulative MTBF for a repairable system is less than or equal to 0.5 during a five year operating period, with 80% confidence level. Assume that <math>\beta =1\,\!</math>, the number of systems for the test is <math>m=6\,\!</math> and that the number of allowed failures in the test is <math>r=2.\,\!</math>

'''Solution'''

Since the given requirement is the number of failures, we transfer the requirement to the cumulative MTBF or cumulative failure intensity.

::<math>MTBF_c=\frac{5}{10}=0.5 year\,\!</math>

:then:

::<math>{{\lambda }_{c}}=\frac{1}{MTB{{F}_{c}}}=2\text{ }failures/\ \ year\,\!</math>

We can then solve for <math>\lambda \,\!</math> :

::<math>{{\lambda }_{c}}\left( t \right)=\lambda {{t}^{\beta -1}}\,\!</math>

For the five year period:

::<math>{{\lambda }_{c}}\left( 5 \right)=\lambda \cdot {{5}^{\beta -1}}\,\!</math>

Using the values of <math>\lambda \,\!</math> and <math>\beta \,\!</math>, we have:

::<math>2=\lambda \cdot {{5}^{1-1}}\,\!</math>

Then solving for <math>\lambda \,\!</math> yields:

::<math>\begin{align}
\lambda =2
\end{align}\,\!</math>

We can then solve for the required test time, <math>T,\,\!</math> for each system:

::<math>1-CL=\underset{i=0}{\overset{r}{\mathop \sum }}\,\frac{{{\left( m\lambda {{T}^{\beta }} \right)}^{i}}\exp (-m\lambda {{T}^{\beta }})}{i!}\,\!</math>

:or:

::<math>1-0.8=\underset{i=0}{\overset{2}{\mathop \sum }}\,\frac{{{\left( 6\cdot 0.894\cdot {{T}^{1}} \right)}^{i}}\exp (-6\cdot 2\cdot {{T}^{1}})}{i!}\,\!</math>

:or:

::<math>0.2=exp (-6\cdot 2\cdot T^1)+\,\!</math>
:::<math>\frac{(6\cdot 2\cdot T^1)^1 exp(-6\cdot 2\cdot T^1)}{1!}\,\!</math>
::::<math>+\frac{6\cdot 2\cdot T^1)^2 exp(-6\cdot 2\cdot T^1)}{2!}\,\!</math>

Solving the above equation numerically yields:

::<math>\begin{align}
T=0.36
\end{align}\,\!</math>

In other words, for this example we have to test for 0.36 years to demonstrate that the number of failures per system in five years is less than or equal to 10.

The same result can be obtained in the RGA software, by using the Design of Reliability Tests (DRT) tool. The next figure shows the calculated required test time per system of 0.3566 on the results of the example.

[[File:DesignReliabilityDemTst.png|center|600px|]]

==Example: Solve for Number of Samples==
At the end of a reliability growth testing program, a manufacturer wants to demonstrate that a new product has achieved an MTBF of 10,000 hours with 80% confidence. The available time for the demonstration test is 4,000 hours for each test unit. Assuming zero failures are allowed, what is the required number of units to be tested in order to demonstrate the desired MTBF?

'''Solution'''

We can obtain the required number of units by using the Design of Reliability Tests (DRT) tool in the RGA software. Since this is a demonstration test then <math>\beta =1\,\!</math>, and no growth will be achieved. The results are shown next. It can be seen that in order to demonstrate a 10,000 hours MTBF with 80% confidence, 5 test units will be required.

[[Image:rga14.16.png|thumb|center|450px|Calculated number of units for the demonstration test.]]

The next figure shows the different combinations of test time per unit, and the number of units in the test for different numbers of allowable failures. It helps to visually examine other possible test scenarios.

[[Image:rga14.17.png|thumb|center|450px|Combinations of test time and number of units for different numbers of allowable failures.]]

File:DesignReliabilityDemTst.png

2013-11-27T20:04:15Z

Athanasios Gerokostopoulos: uploaded a new version of "File:DesignReliabilityDemTst.png"

File:Rga14.17.png

2013-11-27T20:03:20Z

Athanasios Gerokostopoulos: uploaded a new version of "File:Rga14.17.png"

File:Rga14.16.png

2013-11-27T20:01:30Z

Athanasios Gerokostopoulos: uploaded a new version of "File:Rga14.16.png"

Reliability Demonstration Test Design for Repairable Systems

2013-11-27T19:59:56Z

Athanasios Gerokostopoulos: /* Example: Solve for Time */

{{template:RGA BOOK|15}}
The RGA software provides a utility that allows you to design reliability demonstration tests for repairable systems. For example, you may want to design a test to demonstrate a specific cumulative MTBF for a specific operating period at a specific confidence level for a repairable system. The same applies for demonstrating an instantaneous MTBF or cumulative and instantaneous failure intensity at a given time <math>t.\,\!</math>

==Underlying Theory==
The failure process in a repairable system is considered to be a non-homogeneous Poisson process (NHPP) with power law failure intensity. The instantaneous failure intensity at time <math>t\,\!</math> is:

::<math>{{\lambda }_{i}}\left( t \right)=\lambda \beta {{t}^{\beta -1}}={{\lambda }_{c}}\left( t \right)\beta \,\!</math>

So, the cumulative failure intensity at time <math>t\,\!</math> is:

::<math>{{\lambda }_{c}}\left( t \right)=\lambda {{t}^{\beta -1}}=\frac{{{\lambda }_{i}}\left( t \right)}{\beta }\,\!</math>

The instantaneous MTTF is:

::<math>\begin{align}
MTT{{F}_{i}}\left( t \right)= & \frac{1}{{{\lambda }_{i\left( t \right)}}} \\
= & \frac{1}{\lambda \beta }{{t}^{1-\beta }} \\
= & \frac{MTT{{F}_{c}}\left( t \right)}{\beta }
\end{align}\,\!</math>

The cumulative MTBF at time <math>t\,\!</math> is:

::<math>MTB{{F}_{c}}\left( \beta \right)=\frac{1}{{{\lambda }_{c}}\left( t \right)}=\frac{1}{\lambda }{{t}^{1-\beta }}=MTT{{F}_{i}}\left( t \right)\beta \,\!</math>

The relation between the confidence level, required test time, number of systems under test and allowed total number of failures in the test is:

::<math>1-CL=\underset{i=0}{\overset{r}{\mathop \sum }}\,\frac{{{\left( m\lambda {{T}^{\beta }} \right)}^{i}}\exp (-m\lambda {{T}^{\beta }})}{i!}\,\!</math>

where:

*<math>T\,\!</math> is the total test time for each system.
*<math>m\,\!</math> is the number of systems under test.
*<math>r\,\!</math> is the number of allowed failures in the test.
*<math>CL\,\!</math> is the confidence level.

Given any three of the parameters, the equation above can be solved for the fourth unknown parameter. Note that when <math>\beta =1,\,\!</math> the number of failures is a homogeneous Poisson process, and the time between failures is given by the exponential distribution.

==Example: Solve for Time==

The objective is to design a test to demonstrate that the number of failures per system in five years is less than or equal to 10. In other words, demonstrate that the cumulative MTBF for a repairable system is less than or equal to 0.5 during a five year operating period, with 80% confidence level. Assume that <math>\beta =1\,\!</math>, the number of systems for the test is <math>m=6\,\!</math> and that the number of allowed failures in the test is <math>r=2.\,\!</math>

'''Solution'''

Since the given requirement is the number of failures, we transfer the requirement to the cumulative MTBF or cumulative failure intensity.

::<math>MTBF_c=\frac{5}{10}=0.5 year\,\!</math>

:then:

::<math>{{\lambda }_{c}}=\frac{1}{MTB{{F}_{c}}}=2\text{ }failures/\ \ year\,\!</math>

We can then solve for <math>\lambda \,\!</math> :

::<math>{{\lambda }_{c}}\left( t \right)=\lambda {{t}^{\beta -1}}\,\!</math>

For the five year period:

::<math>{{\lambda }_{c}}\left( 5 \right)=\lambda \cdot {{5}^{\beta -1}}\,\!</math>

Using the values of <math>\lambda \,\!</math> and <math>\beta \,\!</math>, we have:

::<math>2=\lambda \cdot {{5}^{1-1}}\,\!</math>

Then solving for <math>\lambda \,\!</math> yields:

::<math>\begin{align}
\lambda =2
\end{align}\,\!</math>

We can then solve for the required test time, <math>T,\,\!</math> for each system:

::<math>1-CL=\underset{i=0}{\overset{r}{\mathop \sum }}\,\frac{{{\left( m\lambda {{T}^{\beta }} \right)}^{i}}\exp (-m\lambda {{T}^{\beta }})}{i!}\,\!</math>

:or:

::<math>1-0.8=\underset{i=0}{\overset{2}{\mathop \sum }}\,\frac{{{\left( 6\cdot 0.894\cdot {{T}^{1}} \right)}^{i}}\exp (-6\cdot 2\cdot {{T}^{1}})}{i!}\,\!</math>

:or:

::<math>0.2=exp (-6\cdot 2\cdot T^1)+\,\!</math>
:::<math>\frac{(6\cdot 2\cdot T^1)^1 exp(-6\cdot 2\cdot T^1)}{1!}\,\!</math>
::::<math>+\frac{6\cdot 2\cdot T^1)^2 exp(-6\cdot 2\cdot T^1)}{2!}\,\!</math>

Solving the above equation numerically yields:

::<math>\begin{align}
T=0.36
\end{align}\,\!</math>

In other words, for this example we have to test for 0.36 years to demonstrate that the number of failures per system in five years is less than or equal to 10.

The same result can be obtained in the RGA software, by using the Design of Reliability Tests (DRT) tool. The next figure shows the calculated required test time per system of 0.3566 on the results of the example.

[[File:DesignReliabilityDemTst.png|center|450px|]]

==Example: Solve for Number of Samples==
At the end of a reliability growth testing program, a manufacturer wants to demonstrate that a new product has achieved an MTBF of 10,000 hours with 80% confidence. The available time for the demonstration test is 4,000 hours for each test unit. Assuming zero failures are allowed, what is the required number of units to be tested in order to demonstrate the desired MTBF?

'''Solution'''

We can obtain the required number of units by using the Design of Reliability Tests (DRT) tool in the RGA software. Since this is a demonstration test then <math>\beta =1\,\!</math>, and no growth will be achieved. The results are shown next. It can be seen that in order to demonstrate a 10,000 hours MTBF with 80% confidence, 5 test units will be required.

[[Image:rga14.16.png|thumb|center|450px|Calculated number of units for the demonstration test.]]

The next figure shows the different combinations of test time per unit, and the number of units in the test for different numbers of allowable failures. It helps to visually examine other possible test scenarios.

[[Image:rga14.17.png|thumb|center|450px|Combinations of test time and number of units for different numbers of allowable failures.]]

Reliability Demonstration Test Design for Repairable Systems

2013-11-27T19:59:03Z

Athanasios Gerokostopoulos: /* Example: Solve for Number of Samples */

{{template:RGA BOOK|15}}
The RGA software provides a utility that allows you to design reliability demonstration tests for repairable systems. For example, you may want to design a test to demonstrate a specific cumulative MTBF for a specific operating period at a specific confidence level for a repairable system. The same applies for demonstrating an instantaneous MTBF or cumulative and instantaneous failure intensity at a given time <math>t.\,\!</math>

==Underlying Theory==
The failure process in a repairable system is considered to be a non-homogeneous Poisson process (NHPP) with power law failure intensity. The instantaneous failure intensity at time <math>t\,\!</math> is:

::<math>{{\lambda }_{i}}\left( t \right)=\lambda \beta {{t}^{\beta -1}}={{\lambda }_{c}}\left( t \right)\beta \,\!</math>

So, the cumulative failure intensity at time <math>t\,\!</math> is:

::<math>{{\lambda }_{c}}\left( t \right)=\lambda {{t}^{\beta -1}}=\frac{{{\lambda }_{i}}\left( t \right)}{\beta }\,\!</math>

The instantaneous MTTF is:

::<math>\begin{align}
MTT{{F}_{i}}\left( t \right)= & \frac{1}{{{\lambda }_{i\left( t \right)}}} \\
= & \frac{1}{\lambda \beta }{{t}^{1-\beta }} \\
= & \frac{MTT{{F}_{c}}\left( t \right)}{\beta }
\end{align}\,\!</math>

The cumulative MTBF at time <math>t\,\!</math> is:

::<math>MTB{{F}_{c}}\left( \beta \right)=\frac{1}{{{\lambda }_{c}}\left( t \right)}=\frac{1}{\lambda }{{t}^{1-\beta }}=MTT{{F}_{i}}\left( t \right)\beta \,\!</math>

The relation between the confidence level, required test time, number of systems under test and allowed total number of failures in the test is:

::<math>1-CL=\underset{i=0}{\overset{r}{\mathop \sum }}\,\frac{{{\left( m\lambda {{T}^{\beta }} \right)}^{i}}\exp (-m\lambda {{T}^{\beta }})}{i!}\,\!</math>

where:

*<math>T\,\!</math> is the total test time for each system.
*<math>m\,\!</math> is the number of systems under test.
*<math>r\,\!</math> is the number of allowed failures in the test.
*<math>CL\,\!</math> is the confidence level.

Given any three of the parameters, the equation above can be solved for the fourth unknown parameter. Note that when <math>\beta =1,\,\!</math> the number of failures is a homogeneous Poisson process, and the time between failures is given by the exponential distribution.

==Example: Solve for Time==

The objective is to design a test to demonstrate that the number of failures per system in five years is less than or equal to 10. In other words, demonstrate that the cumulative MTBF for a repairable system is less than or equal to 0.5 during a five year operating period, with 80% confidence level. Assume that <math>\beta =1\,\!</math>, the number of systems for the test is <math>m=6\,\!</math> and that the number of allowed failures in the test is <math>r=2.\,\!</math>

'''Solution'''

Since the given requirement is the number of failures, we transfer the requirement to the cumulative MTBF or cumulative failure intensity.

::<math>MTBF_c=\frac{5}{10}=0.5 year\,\!</math>

:then:

::<math>{{\lambda }_{c}}=\frac{1}{MTB{{F}_{c}}}=2\text{ }failures/\ \ year\,\!</math>

We can then solve for <math>\lambda \,\!</math> :

::<math>{{\lambda }_{c}}\left( t \right)=\lambda {{t}^{\beta -1}}\,\!</math>

For the five year period:

::<math>{{\lambda }_{c}}\left( 5 \right)=\lambda \cdot {{5}^{\beta -1}}\,\!</math>

Using the values of <math>\lambda \,\!</math> and <math>\beta \,\!</math>, we have:

::<math>2=\lambda \cdot {{5}^{1-1}}\,\!</math>

Then solving for <math>\lambda \,\!</math> yields:

::<math>\begin{align}
\lambda =2
\end{align}\,\!</math>

We can then solve for the required test time, <math>T,\,\!</math> for each system:

::<math>1-CL=\underset{i=0}{\overset{r}{\mathop \sum }}\,\frac{{{\left( m\lambda {{T}^{\beta }} \right)}^{i}}\exp (-m\lambda {{T}^{\beta }})}{i!}\,\!</math>

:or:

::<math>1-0.8=\underset{i=0}{\overset{2}{\mathop \sum }}\,\frac{{{\left( 6\cdot 0.894\cdot {{T}^{1}} \right)}^{i}}\exp (-6\cdot 2\cdot {{T}^{1}})}{i!}\,\!</math>

:or:

::<math>0.2=exp (-6\cdot 2\cdot T^1)+\,\!</math>
:::<math>\frac{(6\cdot 2\cdot T^1)^1 exp(-6\cdot 2\cdot T^1)}{1!}\,\!</math>
::::<math>+\frac{6\cdot 2\cdot T^1)^2 exp(-6\cdot 2\cdot T^1)}{2!}\,\!</math>

Solving the above equation numerically yields:

::<math>\begin{align}
T=0.36
\end{align}\,\!</math>

In other words, for this example we have to test for 0.36 years to demonstrate that the number of failures per system in five years is less than or equal to 10.

The same result can be obtained in the RGA software, by using the Design of Reliability Tests (DRT) tool. The next figure shows the calculated required test time per system of 0.3566 on the results of the example.
[[File:DesignReliabilityDemTst.png]]

==Example: Solve for Number of Samples==
At the end of a reliability growth testing program, a manufacturer wants to demonstrate that a new product has achieved an MTBF of 10,000 hours with 80% confidence. The available time for the demonstration test is 4,000 hours for each test unit. Assuming zero failures are allowed, what is the required number of units to be tested in order to demonstrate the desired MTBF?

'''Solution'''

We can obtain the required number of units by using the Design of Reliability Tests (DRT) tool in the RGA software. Since this is a demonstration test then <math>\beta =1\,\!</math>, and no growth will be achieved. The results are shown next. It can be seen that in order to demonstrate a 10,000 hours MTBF with 80% confidence, 5 test units will be required.

[[Image:rga14.16.png|thumb|center|450px|Calculated number of units for the demonstration test.]]

The next figure shows the different combinations of test time per unit, and the number of units in the test for different numbers of allowable failures. It helps to visually examine other possible test scenarios.

[[Image:rga14.17.png|thumb|center|450px|Combinations of test time and number of units for different numbers of allowable failures.]]

File:Rga14.14.png

2013-11-27T19:45:12Z

Athanasios Gerokostopoulos: uploaded a new version of "File:Rga14.14.png"

File:Rga14.13.png

2013-11-27T19:43:58Z

Athanasios Gerokostopoulos: uploaded a new version of "File:Rga14.13.png"

File:Rga14.12.png

2013-11-27T19:41:41Z

Athanasios Gerokostopoulos: uploaded a new version of "File:Rga14.12.png"

Simulation with RGA Models

2013-11-27T19:38:32Z

Athanasios Gerokostopoulos: /* SimuMatic Example */

{{template:RGA BOOK|14|Additional Tools}}
When analyzing developmental systems for reliability growth, and conducting data analysis of fielded repairable systems, it is often useful to experiment with various ''what if'' scenarios or put together hypothetical analyses before data sets become available in order to plan for the best way to perform the analysis. With that in mind, the RGA software offers applications based on Monte Carlo simulation that can be used in order to:

:a) Better understand reliability growth concepts.
:b) Experiment with the impact of sample size, test time and growth parameters on analysis results.
:c) Construct simulation-based confidence intervals.
:d) Better understand concepts behind confidence intervals.
:e) Design reliability demonstration tests.

There are two applications of the Monte Carlo simulation in the RGA software. One is called Generate Monte Carlo Data and the other is called SimuMatic.

=Generate Monte Carlo Data=
Monte Carlo simulation is a computational algorithm in which we randomly generate input variables that follow a specified probability distribution. In the case of reliability growth and repairable system data analysis, we are interested in generating failure times for systems that we assume to have specific characteristics. In our applications we want the inter-arrival times of the failures to follow a non-homogeneous Poisson process with a Weibull failure intensity, as specified in the Crow-AMSAA (NHPP) model.

The first time to failure, <math>{{t}_{1}},\,\!</math> is assumed to follow a Weibull distribution. It is obtained by solving for <math>{{t}_{1}}\,\!</math> :

::<math>R(t_1)=e^{(-\frac{t_1}{\eta})^\beta}= Uniform (0,1)\,\!</math>

:where:

::<math>\eta ={{\left( \frac{1}{\lambda } \right)}^{\tfrac{1}{\beta }}}\,\!</math>

Solving for <math>{{t}_{1}}\,\!</math> yields:

::<math>t_{1} = \eta \left [ -ln(Uniform(0,1)) \right ]^{\frac {1}{\beta}}</math>

The failure times are then obtained based on the conditional unreliability equation that describes the non-homogeneous Poisson process (NHPP):

::<math>F(t_{i}\ | \ t_{i-1}) = 1 -e^{-\lambda\left[t_{i}^{\beta}-t_{i-1}^{\beta}\right]} = Uniform(0,1)</math>

and then solving for <math>{{t}_{i}}\,\!</math> yields:

::<math>t_{i}=\left[-\frac {ln(1-Uniform(0,1))}{\lambda}+t_{i-1}^{\beta} \right ]^{\frac{1}{\beta}}</math>

To access the data generation utility, choose '''Home > Tools > Generate Monte Carlo Data'''. There are different data types that can be generated with the Monte Carlo utility. For all of them, the basic parameters that are always specified are the beta <math>(\beta )\,\!</math> and lambda <math>(\lambda )\,\!</math> parameters of the Crow-AMSAA (NHPP) model. That does not mean that the generated data can be analyzed only with the Crow-AMSAA (NHPP) model. Depending on the data type, the Duane, Crow extended and power law models can also be used. They share the same growth patterns, which are based on the <math>\beta \,\!</math> and <math>\lambda \,\!</math> parameters. In the case of the Duane model, <math>\beta =1-\alpha \,\!</math>, where <math>\alpha \,\!</math> is the growth parameter for the Duane model. Below we present the available data types that can generated with the Monte Carlo utility.

*'''Failure Times:''' The data set is generated assuming a single system. There is a choice between a time terminated test, where the termination time needs to be specified, or a failure terminated test, where the number of failures needs to be specified. The generated failure times data can then be analyzed using the Duane or Crow-AMSAA (NHPP) models, or the Crow extended model if classifications and modes are entered for the failures.

*'''Grouped Failure Times:''' The data is generated assuming a single system. There is a choice between a time terminated test, where the termination time needs to be specified, or a failure terminated test, where the number of failures needs to be specified. In addition, constant or user-defined intervals need to be specified for the grouping of the data. The generated grouped data can then be analyzed using the Duane or Crow-AMSAA (NHPP) models, or the Crow Extended model if classifications and modes are entered for the failures.

*'''Multiple Systems - Concurrent:''' In this case, the number of systems needs to be specified. There is a choice between a time terminated test, where the termination time needs to be specified, or a failure terminated test, where the number of failures needs to be specified. The generated folio contains failure times for each of the systems. The data can then be analyzed using the Duane or Crow-AMSAA (NHPP) models, or the Crow Extended model if classifications and modes are entered for the failures.

*'''Repairable Systems:''' In this case, the number of systems needs to be specified. There is a choice between a time terminated test, where the termination time needs to be specified, or a failure terminated test, where the number of failures needs to be specified. The generated folio contains failure times for each of the systems. The data can then be analyzed using the power law model, or the Crow extended model if classifications and modes are entered for the failures.

The next figure shows the Monte Carlo utility and all the necessary user inputs.

[[Image:rga14.1.png|thumb|center|300px|Monte Carlo data generation utility.]]

The seed determines the starting point from which the random numbers will be generated. The use of a seed forces the software to use the same sequence of random numbers, resulting in repeatability. In other words, the same failure times can be generated if the same seed, data type, parameters and number of points/systems are used. If no seed is provided, the computer's clock is used to initialize the random number generator and a different set of failure times will be generated at each new request.

==Monte Carlo Data Example==
A reliability engineer wants to experiment with different testing scenarios as the reliability growth test of the company's new product is being prepared. From the reliability growth test data of a similar product that was developed previously, the beta and lambda parameters are <math>\beta =0.5\,\!</math> and <math>\lambda =0.75.\,\!</math> Three systems are to be used to generate a representative data set of expected times-to-failure for the upcoming test. The purpose is to explore different test durations in order to demonstrate an MTBF of 200 hours.

'''Solution'''

In the Monte Carlo window, the parameters are set to <math>\beta =0.5\,\!</math> and <math>\lambda =0.75.\,\!</math> Since we have three systems, we use the "multiple systems - concurrent" data sheet and then set the number of systems to 3. Initially, the test is set to be time terminated with 2,000 operating hours per system, for a total of 6,000 operating hours. The next figure shows the Monte Carlo window for this example.

[[Image:rga5.17.png|thumb|center|450px|Generate Monte Carlo data for 3 concurrent systems.]]

The next figure shows the generated failure times data. In this folio, the Advanced Systems View is used, so the data sheet shows the times-to-failure for system 2.

[[Image:rga14.3.png|thumb|center|450px|Monte Carlo generated data for 3 systems in concurrent operation.]]

The data can then be analyzed just like a regular folio in the RGA software. In this case, we are interested in analyzing the data with the Crow-AMSAA (NHPP) model to calculate the demonstrated MTBF at the end of the test. In the '''Results''' area of the folio (shown in the figure above), it can be seen that the demonstrated MTBF at the end of the test is 189.83 hours. Since that does not meet the requirement of demonstrating an MTBF of 200 hours, we can either generate a new Monte Carlo data set with different time termination settings, or access the Quick Calculation Pad (QCP) in this folio to find the time for which the demonstrated (instantaneous) MTBF becomes 200 hours, as shown in the following figure. From the QCP it can be seen that, based on this specific data set, 6651.38 total operating hours are needed to show a demonstrated MTBF of 200 hours.

[[Image:rga14.4.png|thumb|center|450px|Time required to demonstrate an MTBF equal 200 hours.]]

Note that since the Monte Carlo routine generates random input variables that follow the NHPP based on the specific <math>\beta \,\!</math> and <math>\lambda \,\!</math> values, if the same seed is not used the failure times will be different the next time you run the Monte Carlo routine. Also, because the input variables are pulled from an NHPP with the expected values of <math>\beta \,\!</math> and <math>\lambda ,\,\!</math> it should not be expected that the calculated parameters of the generated data set will match exactly the input parameters that were specified. In this example, the input parameters were set as <math>\beta =0.5\,\!</math> and <math>\lambda =0.75\,\!</math>, and the data set based on the Monte Carlo generated failure times yielded Crow-AMSAA (NHPP) parameters of <math>\beta =0.4939\,\!</math> and <math>\lambda =0.8716\,\!</math>. The next time a data set is generated with a random seed, the calculated parameters will be slightly different, since we are essentially pulling input variables from a predefined distribution. The more simulations that are run, the more the calculated parameters will converge with the expected parameters. In the RGA software, the total number of generated failures with the Monte Carlo utility has to be less than 64,000.

=SimuMatic=
Reliability growth analysis using simulation can be a valuable tool for reliability practitioners. With this approach, reliability growth analyses are performed a large number of times on data sets that have been created using Monte Carlo simulation.

The RGA software's SimuMatic utility generates calculated values of beta and lambda parameters, based on user specified input parameters of beta and lambda. SimuMatic essentially performs a number of Monte Carlo simulations based on user-defined required test time or failure termination settings, and then recalculates the beta and lambda parameters for each of the generated data sets. The number of times that the Monte Carlo data sets are generated and the parameters are re-calculated is also user defined. The final output presents the calculated values of beta and lambda, and allows for various types of analysis.

To access the SimuMatic utility, choose '''Insert > Tools > Add SimuMatic'''. For all of the data sets, the basic parameters that are always specified are the beta <math>(\beta )\,\!</math> and lambda <math>(\lambda )\,\!</math> parameters of the Crow-AMSAA (NHPP) model or the power law model.

*'''Failure Times''': The data set is generated assuming a single system. There is a choice between a time terminated test, where the termination time needs to be specified, or a failure terminated test, where the number of failures needs to be specified. SimuMatic will return the calculated values of <math>\beta \,\!</math> and <math>\lambda \,\!</math> for a specified number of data sets.

*'''Grouped Failure Times''': The data set is generated assuming a single system. There is a choice between a time terminated test, where the termination time needs to be specified, or a failure terminated test, where the number of failures needs to be specified. In addition, constant or user-defined intervals need to be specified for the grouping of the data. SimuMatic will return the calculated values of <math>\beta \,\!</math> and <math>\lambda \,\!</math> for a specified number of data sets.

*'''Multiple Systems - Concurrent''': In this case, the number of systems needs to be specified. There is a choice between a time terminated test, where the termination time needs to be specified, or a failure terminated test, where the number of failures needs to be specified. SimuMatic will return the calculated values of <math>\beta \,\!</math> and <math>\lambda \,\!</math> for a specified number of data sets.

*'''Repairable Systems:''' In this case, the number of systems needs to be specified. There is a choice between a time terminated test, where the termination time needs to be specified, or a failure terminated test, where the number of failures needs to be specified. SimuMatic will return the calculated values of <math>\beta \,\!</math> and <math>\lambda \,\!</math> for a specified number of data sets.

The next figure shows the Main tab of the SimuMatic window where all the necessary user inputs for a multiple systems - concurrent data set have been entered. The Analysis tab allows you to specify the confidence level for simulation-generated confidence bounds, while the Results tab gives you the option to compute for additional results, such as the instantaneous MTBF given a specific test time.

[[Image:rga14.5.png|thumb|center|450px|The SimuMatic input window.]]

The next figure shows the generated results based on the inputs shown above. The data sheet called "Sorted" allows us to extract conclusions about the simulation-generated confidence bounds because the lambda and beta parameters and any other additional output are sorted by percentage.

[[Image:rga14.6.png|thumb|center|450px|SimuMatic output sorted by percentile.]]

The following plot shows the simulation-confidence bounds for the cumulative number of failures based on the input parameters specified.

[[Image:rga14.7.png|thumb|center|450px|Simulation generated confidence bounds on cumulative number of failures.]]

==SimuMatic Example==
A manufacturer wants to design a reliability growth test for a redesigned product, in order to achieve an MTBF of 1,000 hours. Simulation is chosen to estimate the 1-sided 90% confidence bound on the required time to achieve the goal MTBF of 1,000 hours and the 1-sided 90% lower confidence bound on the MTBF at the end of the test time. The total test time is expected to be 15,000 hours. Based on historical data for the previous version, the expected beta and lambda parameters of the test are 0.5 and 0.3, respectively. Do the following:

:1) Generate 1,000 data sets using SimuMatic along with the required output.
:2) Plot the instantaneous MTBF vs. time with the 90% confidence bounds.
:3) Estimate the 1-sided 90% lower confidence bound on time for an MTBF of 1,000 hours.
:4) Estimate the 1-sided 90% lower confidence bound on the instantaneous MTBF at the end of the test.

'''Solution'''

1) The next figure shows the SimuMatic window with all the appropriate inputs for creating the data sets.

[[Image:rga14.8.png|thumb|center|450px|The Main tab of the SimuMatic window.]]

:The next three figures show the settings in the Analysis, Test Design and Results tab of the SimuMatic window in order to obtain the desired outputs.

[[Image:rga14.9.png|thumb|center|450px|The '''Analysis''' tab of the SimuMatic window.]]

[[Image:rga14.9.5.png|thumb|center|450px|The '''Test Design''' tab of the SimuMatic window.]]

[[Image:rga14.10.png|thumb|center|450px|The '''Results''' tab of the SimuMatic window.]]

:The following figure displays the results of the simulation. The columns labeled "Beta" and "Lambda" contain the different parameters obtained by calculating each data set generated via simulation for the 1,000 data sets. The "DMTBF" column contains the instantaneous MTBF at 15,000 hours (the end of test time), given the parameters obtained by calculating each data set generated via simulation. The "T(IMTBF=1000 Hr)" column contains the time required for the MTBF to reach 1,000 hours, given the parameters obtained from the simulation.

[[Image:rga14.11.png|thumb|center|450px|Simulation results using SimuMatic.]]

2) The next figure shows the plot of the instantaneous MTBF with the 90% confidence bounds.

[[Image:rga14.12.png|thumb|center|450px|Instantaneous MTBF with 90% confidence bounds.]]

3) The 1-sided 90% lower confidence bound on time, assuming MTBF = 1,000 hours, can be obtained from the results of the simulation. In the "Sorted" data sheet, this is the target DMTBF value that corresponds to 10.00%, as shown in the next figure. Therefore the 1-sided 90% lower confidence bound on time is 12,642.21 hours.

[[Image:rga14.13.png|thumb|center|450px|The 1-sided 90% lower confidence bound on time assuming 1,000 hours MTBF.]]

4) The next figure shows the 1-sided 90% lower confidence bound on time in the instantaneous MTBF plot. This is indicated by the target lines on the plot.

[[Image:rga14.14.png|thumb|center|450px|Instantaneous MTBF with the target.]]

5) The 1-sided 90% lower confidence bound on the instantaneous MTBF at the end of the test is again obtained from the "Sorted" data sheet by looking at the value in the "IMTBF(15,000)" column that corresponds to 10.00%. As seen in the simulation results shown above, the 1-sided 90% lower confidence bound on the instantaneous MTBF at the end of the test is 605.93 hours.

File:Rga14.11.png

2013-11-27T19:37:18Z

Athanasios Gerokostopoulos: uploaded a new version of "File:Rga14.11.png"

File:Rga14.11.png

2013-11-27T19:36:38Z

Athanasios Gerokostopoulos: uploaded a new version of "File:Rga14.11.png"

File:Rga14.8.png

2013-11-27T19:35:02Z

Athanasios Gerokostopoulos: uploaded a new version of "File:Rga14.8.png"

Simulation with RGA Models

2013-11-27T19:33:48Z

Athanasios Gerokostopoulos: /* SimuMatic Example */

{{template:RGA BOOK|14|Additional Tools}}
When analyzing developmental systems for reliability growth, and conducting data analysis of fielded repairable systems, it is often useful to experiment with various ''what if'' scenarios or put together hypothetical analyses before data sets become available in order to plan for the best way to perform the analysis. With that in mind, the RGA software offers applications based on Monte Carlo simulation that can be used in order to:

:a) Better understand reliability growth concepts.
:b) Experiment with the impact of sample size, test time and growth parameters on analysis results.
:c) Construct simulation-based confidence intervals.
:d) Better understand concepts behind confidence intervals.
:e) Design reliability demonstration tests.

There are two applications of the Monte Carlo simulation in the RGA software. One is called Generate Monte Carlo Data and the other is called SimuMatic.

=Generate Monte Carlo Data=
Monte Carlo simulation is a computational algorithm in which we randomly generate input variables that follow a specified probability distribution. In the case of reliability growth and repairable system data analysis, we are interested in generating failure times for systems that we assume to have specific characteristics. In our applications we want the inter-arrival times of the failures to follow a non-homogeneous Poisson process with a Weibull failure intensity, as specified in the Crow-AMSAA (NHPP) model.

The first time to failure, <math>{{t}_{1}},\,\!</math> is assumed to follow a Weibull distribution. It is obtained by solving for <math>{{t}_{1}}\,\!</math> :

::<math>R(t_1)=e^{(-\frac{t_1}{\eta})^\beta}= Uniform (0,1)\,\!</math>

:where:

::<math>\eta ={{\left( \frac{1}{\lambda } \right)}^{\tfrac{1}{\beta }}}\,\!</math>

Solving for <math>{{t}_{1}}\,\!</math> yields:

::<math>t_{1} = \eta \left [ -ln(Uniform(0,1)) \right ]^{\frac {1}{\beta}}</math>

The failure times are then obtained based on the conditional unreliability equation that describes the non-homogeneous Poisson process (NHPP):

::<math>F(t_{i}\ | \ t_{i-1}) = 1 -e^{-\lambda\left[t_{i}^{\beta}-t_{i-1}^{\beta}\right]} = Uniform(0,1)</math>

and then solving for <math>{{t}_{i}}\,\!</math> yields:

::<math>t_{i}=\left[-\frac {ln(1-Uniform(0,1))}{\lambda}+t_{i-1}^{\beta} \right ]^{\frac{1}{\beta}}</math>

To access the data generation utility, choose '''Home > Tools > Generate Monte Carlo Data'''. There are different data types that can be generated with the Monte Carlo utility. For all of them, the basic parameters that are always specified are the beta <math>(\beta )\,\!</math> and lambda <math>(\lambda )\,\!</math> parameters of the Crow-AMSAA (NHPP) model. That does not mean that the generated data can be analyzed only with the Crow-AMSAA (NHPP) model. Depending on the data type, the Duane, Crow extended and power law models can also be used. They share the same growth patterns, which are based on the <math>\beta \,\!</math> and <math>\lambda \,\!</math> parameters. In the case of the Duane model, <math>\beta =1-\alpha \,\!</math>, where <math>\alpha \,\!</math> is the growth parameter for the Duane model. Below we present the available data types that can generated with the Monte Carlo utility.

*'''Failure Times:''' The data set is generated assuming a single system. There is a choice between a time terminated test, where the termination time needs to be specified, or a failure terminated test, where the number of failures needs to be specified. The generated failure times data can then be analyzed using the Duane or Crow-AMSAA (NHPP) models, or the Crow extended model if classifications and modes are entered for the failures.

*'''Grouped Failure Times:''' The data is generated assuming a single system. There is a choice between a time terminated test, where the termination time needs to be specified, or a failure terminated test, where the number of failures needs to be specified. In addition, constant or user-defined intervals need to be specified for the grouping of the data. The generated grouped data can then be analyzed using the Duane or Crow-AMSAA (NHPP) models, or the Crow Extended model if classifications and modes are entered for the failures.

*'''Multiple Systems - Concurrent:''' In this case, the number of systems needs to be specified. There is a choice between a time terminated test, where the termination time needs to be specified, or a failure terminated test, where the number of failures needs to be specified. The generated folio contains failure times for each of the systems. The data can then be analyzed using the Duane or Crow-AMSAA (NHPP) models, or the Crow Extended model if classifications and modes are entered for the failures.

*'''Repairable Systems:''' In this case, the number of systems needs to be specified. There is a choice between a time terminated test, where the termination time needs to be specified, or a failure terminated test, where the number of failures needs to be specified. The generated folio contains failure times for each of the systems. The data can then be analyzed using the power law model, or the Crow extended model if classifications and modes are entered for the failures.

The next figure shows the Monte Carlo utility and all the necessary user inputs.

[[Image:rga14.1.png|thumb|center|300px|Monte Carlo data generation utility.]]

The seed determines the starting point from which the random numbers will be generated. The use of a seed forces the software to use the same sequence of random numbers, resulting in repeatability. In other words, the same failure times can be generated if the same seed, data type, parameters and number of points/systems are used. If no seed is provided, the computer's clock is used to initialize the random number generator and a different set of failure times will be generated at each new request.

==Monte Carlo Data Example==
A reliability engineer wants to experiment with different testing scenarios as the reliability growth test of the company's new product is being prepared. From the reliability growth test data of a similar product that was developed previously, the beta and lambda parameters are <math>\beta =0.5\,\!</math> and <math>\lambda =0.75.\,\!</math> Three systems are to be used to generate a representative data set of expected times-to-failure for the upcoming test. The purpose is to explore different test durations in order to demonstrate an MTBF of 200 hours.

'''Solution'''

In the Monte Carlo window, the parameters are set to <math>\beta =0.5\,\!</math> and <math>\lambda =0.75.\,\!</math> Since we have three systems, we use the "multiple systems - concurrent" data sheet and then set the number of systems to 3. Initially, the test is set to be time terminated with 2,000 operating hours per system, for a total of 6,000 operating hours. The next figure shows the Monte Carlo window for this example.

[[Image:rga5.17.png|thumb|center|450px|Generate Monte Carlo data for 3 concurrent systems.]]

The next figure shows the generated failure times data. In this folio, the Advanced Systems View is used, so the data sheet shows the times-to-failure for system 2.

[[Image:rga14.3.png|thumb|center|450px|Monte Carlo generated data for 3 systems in concurrent operation.]]

The data can then be analyzed just like a regular folio in the RGA software. In this case, we are interested in analyzing the data with the Crow-AMSAA (NHPP) model to calculate the demonstrated MTBF at the end of the test. In the '''Results''' area of the folio (shown in the figure above), it can be seen that the demonstrated MTBF at the end of the test is 189.83 hours. Since that does not meet the requirement of demonstrating an MTBF of 200 hours, we can either generate a new Monte Carlo data set with different time termination settings, or access the Quick Calculation Pad (QCP) in this folio to find the time for which the demonstrated (instantaneous) MTBF becomes 200 hours, as shown in the following figure. From the QCP it can be seen that, based on this specific data set, 6651.38 total operating hours are needed to show a demonstrated MTBF of 200 hours.

[[Image:rga14.4.png|thumb|center|450px|Time required to demonstrate an MTBF equal 200 hours.]]

Note that since the Monte Carlo routine generates random input variables that follow the NHPP based on the specific <math>\beta \,\!</math> and <math>\lambda \,\!</math> values, if the same seed is not used the failure times will be different the next time you run the Monte Carlo routine. Also, because the input variables are pulled from an NHPP with the expected values of <math>\beta \,\!</math> and <math>\lambda ,\,\!</math> it should not be expected that the calculated parameters of the generated data set will match exactly the input parameters that were specified. In this example, the input parameters were set as <math>\beta =0.5\,\!</math> and <math>\lambda =0.75\,\!</math>, and the data set based on the Monte Carlo generated failure times yielded Crow-AMSAA (NHPP) parameters of <math>\beta =0.4939\,\!</math> and <math>\lambda =0.8716\,\!</math>. The next time a data set is generated with a random seed, the calculated parameters will be slightly different, since we are essentially pulling input variables from a predefined distribution. The more simulations that are run, the more the calculated parameters will converge with the expected parameters. In the RGA software, the total number of generated failures with the Monte Carlo utility has to be less than 64,000.

=SimuMatic=
Reliability growth analysis using simulation can be a valuable tool for reliability practitioners. With this approach, reliability growth analyses are performed a large number of times on data sets that have been created using Monte Carlo simulation.

The RGA software's SimuMatic utility generates calculated values of beta and lambda parameters, based on user specified input parameters of beta and lambda. SimuMatic essentially performs a number of Monte Carlo simulations based on user-defined required test time or failure termination settings, and then recalculates the beta and lambda parameters for each of the generated data sets. The number of times that the Monte Carlo data sets are generated and the parameters are re-calculated is also user defined. The final output presents the calculated values of beta and lambda, and allows for various types of analysis.

To access the SimuMatic utility, choose '''Insert > Tools > Add SimuMatic'''. For all of the data sets, the basic parameters that are always specified are the beta <math>(\beta )\,\!</math> and lambda <math>(\lambda )\,\!</math> parameters of the Crow-AMSAA (NHPP) model or the power law model.

*'''Failure Times''': The data set is generated assuming a single system. There is a choice between a time terminated test, where the termination time needs to be specified, or a failure terminated test, where the number of failures needs to be specified. SimuMatic will return the calculated values of <math>\beta \,\!</math> and <math>\lambda \,\!</math> for a specified number of data sets.

*'''Grouped Failure Times''': The data set is generated assuming a single system. There is a choice between a time terminated test, where the termination time needs to be specified, or a failure terminated test, where the number of failures needs to be specified. In addition, constant or user-defined intervals need to be specified for the grouping of the data. SimuMatic will return the calculated values of <math>\beta \,\!</math> and <math>\lambda \,\!</math> for a specified number of data sets.

*'''Multiple Systems - Concurrent''': In this case, the number of systems needs to be specified. There is a choice between a time terminated test, where the termination time needs to be specified, or a failure terminated test, where the number of failures needs to be specified. SimuMatic will return the calculated values of <math>\beta \,\!</math> and <math>\lambda \,\!</math> for a specified number of data sets.

*'''Repairable Systems:''' In this case, the number of systems needs to be specified. There is a choice between a time terminated test, where the termination time needs to be specified, or a failure terminated test, where the number of failures needs to be specified. SimuMatic will return the calculated values of <math>\beta \,\!</math> and <math>\lambda \,\!</math> for a specified number of data sets.

The next figure shows the Main tab of the SimuMatic window where all the necessary user inputs for a multiple systems - concurrent data set have been entered. The Analysis tab allows you to specify the confidence level for simulation-generated confidence bounds, while the Results tab gives you the option to compute for additional results, such as the instantaneous MTBF given a specific test time.

[[Image:rga14.5.png|thumb|center|450px|The SimuMatic input window.]]

The next figure shows the generated results based on the inputs shown above. The data sheet called "Sorted" allows us to extract conclusions about the simulation-generated confidence bounds because the lambda and beta parameters and any other additional output are sorted by percentage.

[[Image:rga14.6.png|thumb|center|450px|SimuMatic output sorted by percentile.]]

The following plot shows the simulation-confidence bounds for the cumulative number of failures based on the input parameters specified.

[[Image:rga14.7.png|thumb|center|450px|Simulation generated confidence bounds on cumulative number of failures.]]

==SimuMatic Example==
A manufacturer wants to design a reliability growth test for a redesigned product, in order to achieve an MTBF of 1,000 hours. Simulation is chosen to estimate the 1-sided 90% confidence bound on the required time to achieve the goal MTBF of 1,000 hours and the 1-sided 90% lower confidence bound on the MTBF at the end of the test time. The total test time is expected to be 15,000 hours. Based on historical data for the previous version, the expected beta and lambda parameters of the test are 0.5 and 0.3, respectively. Do the following:

:1) Generate 1,000 data sets using SimuMatic along with the required output.
:2) Plot the instantaneous MTBF vs. time with the 90% confidence bounds.
:3) Estimate the 1-sided 90% lower confidence bound on time for an MTBF of 1,000 hours.
:4) Estimate the 1-sided 90% lower confidence bound on the instantaneous MTBF at the end of the test.

'''Solution'''

1) The next figure shows the SimuMatic window with all the appropriate inputs for creating the data sets.

[[Image:rga14.8.png|thumb|center|450px|The Main tab of the SimuMatic window.]]

:The next two figures show the settings in the Analysis and Results tab of the SimuMatic window in order to obtain the desired outputs.

[[Image:rga14.9.png|thumb|center|450px|The '''Analysis''' tab of the SimuMatic window.]]

[[Image:rga14.9.5.png|thumb|center|450px|The '''Test Design''' tab of the SimuMatic window.]]

[[Image:rga14.10.png|thumb|center|450px|The '''Results''' tab of the SimuMatic window.]]

:The following figure displays the results of the simulation. The columns labeled "Beta" and "Lambda" contain the different parameters obtained by calculating each data set generated via simulation for the 1,000 data sets. The "IMTBF(15,000)" column contains the instantaneous MTBF at 15,000 hours (the end of test time), given the parameters obtained by calculating each data set generated via simulation. The "Target DMTBF" column contains the time required for the MTBF to reach 1,000 hours, given the parameters obtained from the simulation.

[[Image:rga14.11.png|thumb|center|450px|Simulation results using SimuMatic.]]

2) The next figure shows the plot of the instantaneous MTBF with the 90% confidence bounds.

[[Image:rga14.12.png|thumb|center|450px|Instantaneous MTBF with 90% confidence bounds.]]

3) The 1-sided 90% lower confidence bound on time, assuming MTBF = 1,000 hours, can be obtained from the results of the simulation. In the "Sorted" data sheet, this is the target DMTBF value that corresponds to 10.00%, as shown in the next figure. Therefore the 1-sided 90% lower confidence bound on time is 12,642.21 hours.

[[Image:rga14.13.png|thumb|center|450px|The 1-sided 90% lower confidence bound on time assuming 1,000 hours MTBF.]]

4) The next figure shows the 1-sided 90% lower confidence bound on time in the instantaneous MTBF plot. This is indicated by the target lines on the plot.

[[Image:rga14.14.png|thumb|center|450px|Instantaneous MTBF with the target.]]

5) The 1-sided 90% lower confidence bound on the instantaneous MTBF at the end of the test is again obtained from the "Sorted" data sheet by looking at the value in the "IMTBF(15,000)" column that corresponds to 10.00%. As seen in the simulation results shown above, the 1-sided 90% lower confidence bound on the instantaneous MTBF at the end of the test is 605.93 hours.

File:Rga14.9.5.png

2013-11-27T19:33:01Z

Athanasios Gerokostopoulos:

File:Rga14.9.png

2013-11-27T19:31:20Z

Athanasios Gerokostopoulos: uploaded a new version of "File:Rga14.9.png"

File:Rga14.10.png

2013-11-27T19:30:09Z

Athanasios Gerokostopoulos: uploaded a new version of "File:Rga14.10.png"